Struct ProjectionPlacement 

pub struct ProjectionPlacement {
    pub root_preference: RootPreference,
    pub dir_template: String,
}

The projection placement resolver (see the module doc for the full architecture narrative). Small and Clone — every consumer holds its own copy rather than sharing a lock. Serialize/Deserialize: the spawn-time in-flight pointer (crates/mlua-swarm-server/src/operator_ws/session.rs’s append_projection_pointer) has no direct Engine handle, so crate::middleware::agent_context::AgentContextMiddleware (which does) resolves this once per spawn and stashes it JSON-serialized into ctx.meta.runtime[crate::core::agent_context::PROJECTION_PLACEMENT_KEY] — the same channel AGENT_CONTEXT_KEY already establishes for AgentContextView itself.

Fields

root_preference: RootPreference

Root resolution preference.

dir_template: String

Target directory template, relative to the resolved root, with [TASK_ID_PLACEHOLDER] substituted at materialize time. Validated by Self::validate_dir_template before being accepted into a ProjectionPlacement — every instance in circulation already satisfies that contract.

Implementations

impl ProjectionPlacement

pub fn from_spec( spec: Option<&ProjectionPlacementSpec>, ) -> Result<Self, ProjectionPlacementError>

Builds a ProjectionPlacement from a Blueprint’s optional projection_placement spec — the sole construction site (blueprint::compiler::Compiler::compile, mirroring crate::core::step_naming::StepNaming::from_blueprint’s single-construction-site contract). None (no Blueprint.projection_placement declared) returns Self::default unchanged — every pre-GH-#27 Blueprint compiles byte-identically through this path. A declared spec’s dir_template is validated via Self::validate_dir_template; root, when present, must be exactly "work_dir" or "project_root".

pub fn validate_dir_template( template: &str, ) -> Result<(), ProjectionPlacementError>

Validates a dir_template candidate: non-empty, contains the {task_id} placeholder, is relative (not absolute, no leading /), and contains no .. path segment. Shared by Self::from_spec so every declared ProjectionPlacement in circulation already satisfies this contract — Self::target_dir never has to re-check it.

pub fn resolve_root(&self, view: &AgentContextView) -> Option<String>

Resolves the materialize root off view’s work_dir / project_root fields, per Self::root_preference, falling back to the other when the preferred one is absent. None when neither is present — every call site’s existing fail-open contract (unresolved root ⇒ skip materialize, never fail the caller) is preserved unchanged.

pub fn target_dir(&self, root: impl AsRef<Path>, task_id: &str) -> PathBuf

The materialize target DIRECTORY for task_id, rooted at root: Self::dir_template with [TASK_ID_PLACEHOLDER] substituted, joined onto root one path segment at a time (so a multi-segment template like the default "workspace/tasks/{task_id}/ctx" builds the same cross-platform PathBuf the pre-GH-#27 hardcoded .join("workspace").join("tasks")… chain did).

pub fn target_path( &self, root: impl AsRef<Path>, task_id: &str, stem: &str, ) -> PathBuf

The materialize target FILE for task_id / stem (stem is the canonical step name, or "_ctx" for the whole-ctx submission — see crate::core::projection::ProjectionKey::step_slug): Self::target_dir joined with "<stem>.md".

Trait Implementations

impl Clone for ProjectionPlacement

fn clone(&self) -> ProjectionPlacement

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProjectionPlacement

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ProjectionPlacement

fn default() -> Self

The byte-compat default (see the module doc).

impl<'de> Deserialize<'de> for ProjectionPlacement

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProjectionPlacement

fn eq(&self, other: &ProjectionPlacement) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProjectionPlacement

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ProjectionPlacement