Pipeline composition

Platform spec area

Pipeline composition

Back to Compiler ◎ Open in platform map

Owner

Piotr Mikstacki pmikstacki@cybernomad.it

Submitter

Piotr Mikstacki pmikstacki@cybernomad.it

Current document

ADRs

No architecture decision records under adr/ for this feature yet. Standard features must publish at least one ADR or keep a ## Decisions summary on the hub.

Articles

• No directly attached article pages for this node.

History

0 revisions (git unavailable at build; counts may be empty)

Open full history on GitHub

No commits recorded for this path.

Completeness

OKarea · 4 SpecSection(s) · 0 H2 heading(s)

Section id	Required	Found
scope	yes	yes
features	no	no

Full tree: run pnpm verify:platform-spec-layout (writes src/generated/platform-spec-layout-report.json).

Related spec docs

• Domain
  Compiler

  Parent domain hub

• Area
  Compiler Mods

  Beskid-side mods; does not mutate composition graph

• Area
  Build pipeline

  Observable phase ordering

• Feature
  Native dependency injection

  App host DI resolved at composition.resolve

• Feature
  Stage ordering and lowering

  Observable phase DAG and lowering order (primary pipeline contract)

Scope

Pipeline composition is Rust-only compiler infrastructure: pass registration, dependency injection between compiler services, phase DAG wiring, and feature-flagged stage enablement.

Mod projects and Beskid Compiler Mod SDK contracts must not mutate this graph. Mods observe compiler snapshots through SDK surfaces only.

Phase ordering and lowering (parse → semantic gates → HIR → CLIF → backends) are specified under Build pipeline / Stage ordering. This area documents how those phases are registered and wired in Rust, not the end-to-end stage list itself. Feature-level articles for composition DAG and pass registration may be added here later; until then, treat stage ordering as the authoritative cross-phase contract.

Boundary

flowchart TB
  subgraph rustPlane [Rust pipeline composition]
    pipeline[beskid_pipeline phase DAG]
    ioc[Compiler service IoC]
  end
  subgraph userPlane [User app composition]
    host[host registry scope launch]
  end
  subgraph modPlane [Compiler mods read-only]
    sdk[Mod SDK contracts]
    hostBridge[mod host bridge]
  end
  userPlane -->|composition.resolve| rustPlane
  modPlane -->|snapshots only| rustPlane
  sdk -.->|must not mutate graph| pipeline

Plane	Owner
Compiler composition / IoC	Rust (beskid_analysis, beskid_pipeline, related crates)
User DI (host, launch)	Language meta / composition
Compiler mods (type: Mod)	Compiler Mods + Compiler Mod SDK

User program composition (read-only)

The reference compiler resolves Beskid app composition (Native dependency injection) at compile time. Rust pipeline code materializes a frozen binding plan and composition snapshot for lowering and mod queries; it does not reinterpret host / registry / scope syntax.

Planned phase id: composition.resolve (after semantic.snapshot, before mod.analyze). See Native DI / Flow and algorithm.

Implementation anchors

• compiler/crates/beskid_pipeline/ — phase ids and observer hooks
• compiler/crates/beskid_analysis/src/services.rs — session orchestration
• compiler/crates/beskid_analysis/src/analysis/rules/staged/ — staged semantic pass graph
• compiler/crates/beskid_analysis — planned composition module for app DI graph (see native DI feature hub)