@intentius/chant 0.13.1 → 0.15.0

package/dist/components/driver.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Thin interpret driver — Phase 1 (#556), saga rollback hardened in Phase 4
+ * (#565, epic #551).
+ *
+ * One generic orchestrator that runs an arbitrary set of components on the
+ * local in-process executor: it orders components by `dependsOn` (reusing the
+ * same Kahn-layering approach `computeStackGraph` uses for `chant graph
+ * --stacks`, see ../build.ts), then for each component in order runs its
+ * `deploy` composition by dispatching every step to the `CapabilityRegistry`
+ * by `kind`. It resolves the three wiring reference forms from
+ * component.schema.json (`@Phase.field` prior-step references,
+ * `@<component>.publish.<field>` cross-component artifact references, and
+ * passes through `$env.*`/`stackOutput` values as opaque env config), runs
+ * `parallel` phases concurrently, rejects a `gate` locally (matching
+ * ../op/local-executor.ts's `LocalGateUnsupportedError`), and on terminal
+ * failure unwinds every executed step in reverse via that step's capability
+ * `rollback`, then runs `onFailure` phases in reverse order (best-effort),
+ * mirroring the Op local executor's saga semantics.
+ *
+ * A step whose capability declares no `rollback` is never silently passed
+ * over during unwind: it gets a `"rollback-opted-out"` record (see
+ * `rollbackExecuted`), carrying the step's `noRollback` reason when the
+ * composition declared one. This mirrors, at run time, the opt-out the
+ * COMP003 lint rule (../lint/rules/comp/comp003-mutating-no-rollback.ts)
+ * already requires at author time — the driver reports the same fact the
+ * lint rule already made a component author state.
+ *
+ * This unwind runs entirely in-process: if the process crashes mid-rollback
+ * on the local executor, nothing resumes it — there is no persisted run state
+ * to resume from. That is the documented Temporal boundary (see
+ * docs/components/orchestration.mdx#rollback-comes-free and
+ * docs/guide/local-vs-temporal.mdx): the *mechanism* (reverse-order unwind
+ * calling each capability's `rollback`) is capability-agnostic and works
+ * identically on both executors, but *durable resume of a rollback already in
+ * progress* is Temporal-only, the same boundary that already applies to
+ * forward `onFailure` compensation on an Op.
+ *
+ * Contains zero per-component logic: nothing in this module branches on a
+ * component or capability `kind`/name. All behavior is either generic
+ * (ordering, phase/step dispatch, wiring resolution) or delegated to the
+ * `CapabilityRegistry` the caller supplies.
+ */
+import type { CapabilityRegistry, DeployContext } from "./capability.js";
+/** A wiring reference or literal value, as it appears in a step's fields (schema `WiringValue`). */
+export type WiringValue = string | {
+    stackOutput: {
+        stack: string;
+        name: string;
+    };
+} | Record<string, unknown>;
+/** A single capability invocation — the leaf unit of a composition (schema `Step`). */
+export interface DriverStep {
+    kind: string;
+    [param: string]: unknown;
+}
+/** A gate step — pauses for an external signal; unsupported on the local executor (schema `Gate`). */
+export interface DriverGate {
+    kind: "gate";
+    signalName: string;
+    timeout?: string;
+    description?: string;
+}
+/** One named phase of a deploy composition (schema `Phase`). A step may itself be a nested `Phase` (fan-out). */
+export interface DriverPhase {
+    phase: string;
+    steps: Array<DriverStep | DriverGate | DriverPhase>;
+    parallel?: boolean;
+    onFailure?: DriverPhase[];
+}
+/** The subset of the Component contract the driver needs to run a deploy (schema-shaped; see component.schema.json). */
+export interface DriverComponent {
+    name: string;
+    dependsOn?: string[];
+    deploy: DriverPhase[];
+    /** Component-level saga compensation, run in reverse order on terminal failure (schema `rollback`). */
+    rollback?: DriverPhase[];
+}
+/** Thrown when a component's composition contains a `gate` — gates need a durable runtime, matching chant's Op local executor. */
+export declare class DriverGateUnsupportedError extends Error {
+    readonly component: string;
+    readonly signalName: string;
+    constructor(component: string, signalName: string);
+}
+/** Thrown when a dependency cycle is found among `dependsOn` edges. */
+export declare class DependencyCycleError extends Error {
+    readonly cycle: string[];
+    constructor(cycle: string[]);
+}
+/** Thrown when a component's `dependsOn` names a component not present in the run set. */
+export declare class UnknownDependencyError extends Error {
+    readonly component: string;
+    readonly dependency: string;
+    constructor(component: string, dependency: string);
+}
+/** Thrown on terminal run failure; carries the partial run result for rendering/inspection. */
+export declare class DriverRunFailure extends Error {
+    readonly result: DriverRunResult;
+    constructor(result: DriverRunResult);
+}
+export interface DriverStepRecord {
+    component: string;
+    phase: string;
+    kind: string;
+    status: "ok" | "fail" | "skipped" | "rolled-back" | "rollback-opted-out";
+    durationMs: number;
+    output?: unknown;
+    error?: string;
+}
+export interface DriverComponentResult {
+    component: string;
+    ok: boolean;
+    records: DriverStepRecord[];
+}
+export interface DriverRunResult {
+    /** Component order actually attempted, in run order. */
+    order: string[];
+    /** Parallel-safe waves the order was derived from (see resolveComponentGraph). */
+    waves: string[][];
+    results: DriverComponentResult[];
+    ok: boolean;
+    /** Name of the component that terminated the run, if any. */
+    failedComponent?: string;
+    /**
+     * The accumulated cross-component/cross-stack outputs after the run — each
+     * component's `publish` output and, for an applied stack, its `cfn-deploy`
+     * outputs, keyed by component name. Seeded from `options.componentOutputs`
+     * and grown as components complete. The CLI's `--dump-outputs` serializes
+     * this so a later, separate run (a downstream CI job) can `--seed-outputs`
+     * it and resolve `stackOutput()`/`@<name>.publish.*` references to a
+     * component that ran in an earlier job.
+     */
+    componentOutputs: Record<string, Record<string, unknown>>;
+}
+export interface ComponentGraph {
+    /** Flat topological order — every dependency before its dependents. */
+    order: string[];
+    /** Waves: components in the same wave share no dependency and may run concurrently. */
+    waves: string[][];
+}
+/**
+ * Resolve run order and parallel-safe waves from each component's `dependsOn`.
+ * Reuses the generic `topoSort` (../codegen/topo-sort.ts) for the flat order,
+ * and the same Kahn-layering approach `computeStackGraph` uses for `chant
+ * graph --stacks` (../build.ts) to additionally group independent components
+ * into waves. This is a plain string-graph algorithm — no lexicon/AttrRef
+ * machinery — since a component's `dependsOn` is already a flat name list.
+ */
+export declare function resolveComponentGraph(components: DriverComponent[]): ComponentGraph;
+/**
+ * Resolve one wiring value against already-produced outputs. Three reference
+ * forms, all resolved here rather than by any component-specific code:
+ *  - `@Phase.field` — a prior step's output within the same component, keyed
+ *    by phase name (`phaseOutputs`).
+ *  - `@<component>.publish.uri|digest|key` — another component's published
+ *    artifact output (`componentOutputs`), per composition-and-wiring.mdx.
+ *  - `{ stackOutput: { stack, name } }` — a cross-stack output; Phase 1 has no
+ *    cross-stack apply-order integration (out of scope per #556), so this
+ *    resolves via the same `componentOutputs` map keyed by `stack`/`name`,
+ *    letting tests and callers seed cross-stack values the same way as
+ *    artifact outputs. `$env.*` and plain literals pass through unchanged —
+ *    env resolution is the caller's `DeployContext.vars`, not the driver's.
+ */
+export declare function resolveWiring(value: WiringValue, phaseOutputs: Record<string, Record<string, unknown>>, componentOutputs: Record<string, Record<string, unknown>>): unknown;
+/**
+ * Deep-walk an object, resolving every string/stackOutput wiring value found.
+ * Arrays and nested objects are walked too.
+ *
+ * Exported (not just used internally) so the durable Temporal path
+ * (`@intentius/chant-lexicon-temporal`'s component workflow codegen, see
+ * epic #551 #589) can resolve a step's wiring the same way inside a Temporal
+ * *activity* — the workflow itself only accumulates `phaseOutputs`/
+ * `componentOutputs` and passes them through; resolution logic stays in one
+ * place so local and durable execution can never silently diverge.
+ */
+export declare function resolveStepInput(input: Record<string, unknown>, phaseOutputs: Record<string, Record<string, unknown>>, componentOutputs: Record<string, Record<string, unknown>>): Record<string, unknown>;
+/**
+ * Run one component's `deploy` composition. On terminal failure: unwind every
+ * executed step in reverse via its capability's `rollback` (saga
+ * compensation), then run the component's declared `rollback` phases in
+ * reverse order (best-effort), matching ../op/local-executor.ts's `onFailure`
+ * handling. Cross-component artifact outputs this component published (if
+ * any) are recorded into `componentOutputs` under its own name so downstream
+ * components can reference `@<name>.publish.*`.
+ */
+export declare function runComponentDeploy(component: DriverComponent, ctx: DeployContext, registry: CapabilityRegistry, componentOutputs: Record<string, Record<string, unknown>>): Promise<DriverComponentResult>;
+export interface InterpretRunOptions {
+    /** Target environment name, threaded into every capability's `DeployContext`. */
+    env: string;
+    /** Environment config resolved ahead of the run (registry URLs, cluster names, ...) — passed through as `DeployContext.vars`. */
+    vars?: Record<string, unknown>;
+    /** Pre-seeded cross-component/cross-stack outputs (e.g. from a prior run, or a caller resolving `stackOutput` externally). Merged with outputs this run produces. */
+    componentOutputs?: Record<string, Record<string, unknown>>;
+}
+/**
+ * Run a set of components to completion on the local in-process executor:
+ * resolve dependency order and parallel-safe waves from `dependsOn`, then run
+ * each wave's components (independent components within a wave run
+ * concurrently; components across waves run in wave order), dispatching
+ * every step to `registry` by `kind`. Stops the whole run at the first failed
+ * component (after that component's own saga rollback completes), returning
+ * a result with `ok: false`; throws `DriverRunFailure` carrying that result
+ * so callers can choose to inspect or propagate it.
+ *
+ * Zero per-component logic: this function and everything it calls dispatches
+ * purely on the generic `Component`/`Phase`/`Step` shapes and the registry —
+ * no branch anywhere names a specific component or capability.
+ */
+export declare function runInterpretDriver(components: DriverComponent[], registry: CapabilityRegistry, options: InterpretRunOptions): Promise<DriverRunResult>;
+//# sourceMappingURL=driver.d.ts.map

package/dist/components/driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../src/components/driver.ts"],"names":[],"mappings":"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"}

package/dist/components/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Component-native release orchestration — capability contract, starter verb
+ * set, and the thin interpret driver (epic #551, #554/#556). The pilot AWS
+ * leaves have real implementations over an injectable `CloudExecutor` (#557);
+ * every other verb remains a typed stub. See https://intentius.io/chant/components/orchestration/
+ */
+export { type Archetype, type Wiring, type StackOutputReference, type BuildSpec, type Step, type Gate, type Phase, type Component, phase, gate, stackOutput, inferArchetype, projectToJson, isComponent, } from "./component.js";
+export { type DiscoveredComponent, type ComponentDiscoveryResult, discoverComponents, } from "./discover.js";
+export { type ListedComponent, type ListComponentsResult, type DescribedComponent, type DescribeComponentResult, type ComponentGraphResult, type GenerateLexicon, type GenerateComponentsResult, type RunComponentsOptions, type RunComponentsResult, type ResolvedComponentTargets, listComponents, describeComponent, computeComponentGraph, generateComponentsPipeline, runComponents, findComponentGate, resolveComponentTargets, } from "./cli-support.js";
+export { renderDriverHuman, renderDriverJson } from "./driver-output.js";
+export { type Capability, type CapabilityInput, type CapabilityOutput, type DeployContext, CapabilityRegistry, CapabilityNotImplementedError, } from "./capability.js";
+export { createCapabilityRegistry, STARTER_VERB_FAMILIES } from "./registry.js";
+export { type CapabilityPlugin, type CapabilityManifest, isCapabilityPlugin, } from "./capability-plugin.js";
+export { CapabilityManifestSchema, type CapabilityManifestParsed, validateCapabilityManifest, } from "./capability-plugin-schema.js";
+export { loadCapabilityPlugin, loadCapabilityPlugins, registerCapabilityPlugins, buildCapabilityRegistry, type BuildCapabilityRegistryOptions, MalformedCapabilityPluginError, DuplicateCapabilityKindError, } from "./capability-plugin-loader.js";
+export { starterCapabilityPlugin } from "./starter-plugin.js";
+export * from "./verbs/index.js";
+export * from "./builders.js";
+export { type DriverStep, type DriverGate, type DriverPhase, type DriverComponent, type DriverStepRecord, type DriverComponentResult, type DriverRunResult, type ComponentGraph, type InterpretRunOptions, type WiringValue, resolveComponentGraph, resolveWiring, resolveStepInput, runComponentDeploy, runInterpretDriver, DriverGateUnsupportedError, DependencyCycleError, UnknownDependencyError, DriverRunFailure, } from "./driver.js";
+export { EcsFargateComponent, type EcsFargateComponentConfig, LambdaComponent, type LambdaComponentConfig, SingleHostComposeComponent, type SingleHostComposeComponentConfig, } from "./presets/index.js";
+export { type ComponentTemporalCodegen, type ComponentTemporalCodegenOptions, loadComponentTemporalCodegen, } from "./temporal-codegen-loader.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,KAAK,SAAS,EACd,KAAK,MAAM,EACX,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,IAAI,EACT,KAAK,IAAI,EACT,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,EACL,IAAI,EACJ,WAAW,EACX,cAAc,EACd,aAAa,EACb,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACrB,0BAA0B,EAC1B,aAAa,EACb,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,kBAAkB,EAClB,6BAA6B,GAC9B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,0BAA0B,GAC3B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,KAAK,8BAA8B,EACnC,8BAA8B,EAC9B,4BAA4B,GAC7B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,0BAA0B,EAC1B,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,mBAAmB,EACnB,KAAK,yBAAyB,EAC9B,eAAe,EACf,KAAK,qBAAqB,EAC1B,0BAA0B,EAC1B,KAAK,gCAAgC,GACtC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC"}

package/dist/components/manifest-persistence.d.ts

@@ -0,0 +1,79 @@
+import type { BuildArchiveManifest } from "./verbs/build-archive.js";
+import type { DriverStepRecord } from "./driver.js";
+/**
+ * Find the most fully-accumulated `BuildArchiveManifest` a component run
+ * produced, by scanning its step records for the last manifest-bearing
+ * output — mirroring `extractRunDigest`'s "last wins" convention, which is
+ * also the correct one here: every build-family capability's `manifest`
+ * input/output accumulates onto whatever manifest came before it in the same
+ * phase (see ../components/verbs/build.ts's `DockerBuildInput.manifest`
+ * doc), so the *last* manifest-bearing step output in run order is always
+ * the fullest one — a template + SBOM + config-BOM composition's final step
+ * carries every earlier entry too, not just its own.
+ */
+export declare function extractRunManifest(records: DriverStepRecord[]): BuildArchiveManifest | undefined;
+/**
+ * Same manifest extraction as `extractRunManifest`, but over a component
+ * Temporal workflow's returned `phaseOutputs` (`{ [phase]: output }`) —
+ * mirroring ./auto-release.ts's `extractRunDigestFromPhaseOutputs`, the
+ * `--temporal` CLI path's counterpart, since that path never sees individual
+ * step records either.
+ */
+export declare function extractRunManifestFromPhaseOutputs(phaseOutputs: Record<string, Record<string, unknown>> | undefined): BuildArchiveManifest | undefined;
+/** Explicit reasons `maybePersistBuildManifest` declined to write — never a thrown error, mirroring ./auto-release.ts's `AutoReleaseSkipReason`. */
+export type ManifestPersistSkipReason = "opted-out" | "run-not-successful" | "no-manifest";
+export type ManifestPersistResult = {
+    persisted: true;
+    commit: string;
+    manifestDigest: string;
+} | {
+    persisted: false;
+    reason: ManifestPersistSkipReason;
+} | {
+    persisted: false;
+    reason: "error";
+    error: string;
+};
+/** Input describing one component's completed run — the manifest-persistence counterpart of ./auto-release.ts's `AutoReleaseRunInfo`. */
+export interface ManifestPersistRunInfo {
+    /** Whether the run reported overall success. A caller must not call this for a non-terminal/in-progress run — mirrors `AutoReleaseRunInfo.success`. */
+    success: boolean;
+    /** The component's step records (local executor), used to locate the accumulated manifest via `extractRunManifest`. Mutually exclusive with `manifest`. */
+    records?: DriverStepRecord[];
+    /** A manifest already resolved by the caller (e.g. a future durable/Temporal path that has its own phaseOutputs-shaped extraction). Takes precedence over `records` when both are given. */
+    manifest?: BuildArchiveManifest;
+}
+/** Opt-out knobs for manifest persistence, mirroring ./auto-release.ts's `AutoReleaseOptions`. */
+export interface ManifestPersistOptions {
+    /** `--no-release-record` / `chant.config.ts`'s `release.autoRecord: false` also gates manifest persistence — both are "durably record this successful deploy" side effects with the same opt-out story, so one flag/config knob controls both rather than introducing a second, easy-to-forget switch. Default: persistence is ON. */
+    disabled?: boolean;
+    /** Working directory for the git plumbing calls (tests). */
+    cwd?: string;
+}
+/**
+ * After a successful `chant run --components <name> --env <env>` (local
+ * executor), persist the run's accumulated `BuildArchiveManifest` (if any)
+ * to the durable build-manifest store (../lifecycle/build-ledger-store.ts)
+ * and push it — or explain, without throwing, why it didn't. Never called
+ * for a failed run, matching `maybeRecordAutoRelease`'s contract exactly.
+ *
+ * Skips (returns `{ persisted: false, reason }`, never throws):
+ *  - `options.disabled` — the opt-out flag/config was set.
+ *  - `run.success` false — defensive; callers should not reach here on
+ *    failure. A dry-run/failed deploy persists nothing, by construction —
+ *    this is also what makes a dry run safe: `chant run --components` never
+ *    calls this function at all unless the run actually completed.
+ *  - no manifest found in the run's records — a component with no
+ *    build-family step (an infra-only/apply-only component, or a
+ *    build-less `Publish`-only producer that reused a prior archive) has
+ *    nothing to persist. This is the expected common case for most deploys,
+ *    not an error.
+ *
+ * Write/push failures (any error `persistBuildManifest`/`pushLifecycle`
+ * throw) are reported as `{ persisted: false, reason: "error", error }`
+ * rather than propagated — same "never turn a successful deploy into a
+ * failing CLI invocation" contract `maybeRecordAutoRelease` already
+ * establishes for release records.
+ */
+export declare function maybePersistBuildManifest(run: ManifestPersistRunInfo, options?: ManifestPersistOptions): Promise<ManifestPersistResult>;
+//# sourceMappingURL=manifest-persistence.d.ts.map

package/dist/components/manifest-persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-persistence.d.ts","sourceRoot":"","sources":["../../src/components/manifest-persistence.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAajD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,oBAAoB,GAAG,SAAS,CAShG;AAED;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GAChE,oBAAoB,GAAG,SAAS,CAQlC;AAED,oJAAoJ;AACpJ,MAAM,MAAM,yBAAyB,GAAG,WAAW,GAAG,oBAAoB,GAAG,aAAa,CAAC;AAE3F,MAAM,MAAM,qBAAqB,GAC7B;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,yBAAyB,CAAA;CAAE,GACvD;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,yIAAyI;AACzI,MAAM,WAAW,sBAAsB;IACrC,uJAAuJ;IACvJ,OAAO,EAAE,OAAO,CAAC;IACjB,2JAA2J;IAC3J,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC7B,4LAA4L;IAC5L,QAAQ,CAAC,EAAE,oBAAoB,CAAC;CACjC;AAED,kGAAkG;AAClG,MAAM,WAAW,sBAAsB;IACrC,sUAAsU;IACtU,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAC5D,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,sBAAsB,EAC3B,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAoBhC"}

package/dist/components/pilots/alb-ecs.pilot.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pilot: ALB/ECS target (#555, epic #551).
+ *
+ * Exercises the build + cross-stack + auto-rollback axes: `docker-build` →
+ * `publish-image` (promote by digest, deploy-time) → `cfn-deploy` (importing
+ * the shared ALB's listener/cluster/subnets as cross-stack outputs, resolved
+ * by `chant graph --stacks` rather than a `describe-stacks | jq` pipeline
+ * step — see composition-and-wiring.mdx#cross-stack-outputs) →
+ * `ecs-update-service` → `wait-steady-state` + `health-gate`.
+ *
+ * This is the direct component-native replacement for the hand-rolled GitLab
+ * pipeline in `examples/gitlab-aws-alb-api/src/pipeline.ts`: the
+ * `describe-stacks`/`jq` glue in that pipeline's `deployService` job is
+ * exactly the cross-stack `stackOutput()` wiring below, and its
+ * `docker build`/`docker push` steps are the `docker-build` + `publish-image`
+ * capabilities. `service` archetype: build → publish → apply → verify, the
+ * fullest of the three archetypes.
+ *
+ * The JSON projection of this pilot is authoritative at
+ * ../__fixtures__/alb-ecs-service.json (already schema-validated by
+ * component-schema.test.ts) — this module is the real typed `Component`
+ * authoring form (#560, ../component.ts) that composes to that same
+ * document; see ./pilots.test.ts, which asserts the two never diverge.
+ */
+import type { Component } from "../component.js";
+export declare const searchService: Component;
+//# sourceMappingURL=alb-ecs.pilot.d.ts.map

package/dist/components/pilots/alb-ecs.pilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alb-ecs.pilot.d.ts","sourceRoot":"","sources":["../../../src/components/pilots/alb-ecs.pilot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAU9C,eAAO,MAAM,aAAa,EAAE,SA2B3B,CAAC"}

package/dist/components/pilots/dynamodb.pilot.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pilot: DynamoDB table (#555, epic #551).
+ *
+ * Exercises the sticky-apply axis: `cfn-deploy` carries declarative safety
+ * options — `onReplace: "block"` refuses a changeset that would replace the
+ * table (losing data) rather than update it in place, and `stageGsi: true`
+ * stages a GSI change (add → backfill → remove) instead of an in-place
+ * replace. That stickiness lives inside the `cfn-deploy` capability, exposed
+ * as options, not scripted per component — see
+ * capabilities.mdx#stickiness-lives-in-the-capability. `infra` archetype: no
+ * build, apply → verify only. Verify fans out in parallel: the stack wait and
+ * a GSI backfill migration have no ordering dependency on each other.
+ *
+ * The JSON projection of this pilot is authoritative at
+ * ../__fixtures__/dynamodb-infra.json (already schema-validated by
+ * component-schema.test.ts) — this module is the real typed `Component`
+ * authoring form (#560, ../component.ts) that composes to that same
+ * document; see ./pilots.test.ts, which asserts the two never diverge.
+ */
+import type { Component } from "../component.js";
+export declare const ordersTable: Component;
+//# sourceMappingURL=dynamodb.pilot.d.ts.map

package/dist/components/pilots/dynamodb.pilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamodb.pilot.d.ts","sourceRoot":"","sources":["../../../src/components/pilots/dynamodb.pilot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAY9C,eAAO,MAAM,WAAW,EAAE,SA0BzB,CAAC"}

package/dist/components/pilots/jar-emr.pilot.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Pilot pair: JAR producer -> EMR consumer, cross-component artifact outputs
+ * (#561, epic #551).
+ *
+ * This is the epic's worked example for cross-component wiring (#551
+ * §"Cross-component outputs", docs/components/composition-and-wiring.mdx
+ * §"Cross-component outputs"): a **producer-library** component
+ * (`jar-lib`) that only builds and publishes an artifact — no apply, no
+ * service — paired with an **infra** consumer (`emr-job`) that submits an
+ * EMR job run against the producer's published S3 URI.
+ *
+ * The wiring itself needs no new machinery: `dependsOn: ["jar-lib"]` orders
+ * the producer first (`resolveComponentGraph`, ../driver.ts), and
+ * `"@jar-lib.publish.uri"` is the same `@<component>.publish.uri|digest|key`
+ * reference form `resolveWiring` (../driver.ts) already resolves generically
+ * from `componentOutputs`, which `runComponentDeploy` already populates from
+ * any step whose output carries `uri`/`digest`/`key` (`findPublishOutput`) —
+ * both landed with #556/#560 and are exercised by ../driver.test.ts's
+ * "wires a cross-component artifact reference" case. What #561 actually adds
+ * is: this pair authored as real typed `Component`s (rather than only the
+ * hand-written JSON fixtures), and a real `emr-start-job-run`/`wait-job`
+ * capability implementation (../verbs/job-submission.ts,
+ * ../verbs/wait-verify.ts) so the pair runs to completion against a mocked
+ * `CloudExecutor` instead of throwing `CapabilityNotImplementedError`.
+ *
+ * The JSON projections of these two components are authoritative at
+ * ../__fixtures__/jar-lib-producer.json and
+ * ../__fixtures__/emr-job-consumer.json (pre-existing, from #560) — this
+ * module is the real typed `Component` authoring form that composes to those
+ * same documents; see ./pilots.test.ts, which asserts the two never diverge.
+ */
+import type { Component } from "../component.js";
+/** Producer: a JAR built from a Maven project, published to S3. Publish-only deploy — no apply phase at all, the defining shape of the `producer-library` archetype. */
+export declare const jarLib: Component;
+/** Consumer: an EMR job run reading the producer's published JAR by S3 URI. `dependsOn: ["jar-lib"]` orders the producer first; the graph resolves the reference into the Submit step. */
+export declare const emrJob: Component;
+//# sourceMappingURL=jar-emr.pilot.d.ts.map

package/dist/components/pilots/jar-emr.pilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jar-emr.pilot.d.ts","sourceRoot":"","sources":["../../../src/components/pilots/jar-emr.pilot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C,wKAAwK;AACxK,eAAO,MAAM,MAAM,EAAE,SAUpB,CAAC;AAEF,0LAA0L;AAC1L,eAAO,MAAM,MAAM,EAAE,SAmBpB,CAAC"}

package/dist/components/pilots/lambda.pilot.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pilot: image-processor Lambda (#558, epic #551).
+ *
+ * The fourth, deliberately different component #558 asks for, added to prove
+ * the sprawl metric holds beyond the original three pilots (#555): a
+ * container-image AWS Lambda function. `service` archetype, same as ALB/ECS,
+ * but a genuinely different shape on two axes at once:
+ *
+ *  - **apply target**: no CloudFormation stack at all — `lambda-deploy`
+ *    updates a function's code directly (`UpdateFunctionCode` +
+ *    `PublishVersion` + `UpdateAlias`), never a `cfn-deploy` changeset. Every
+ *    prior pilot's apply step was `cfn-deploy`; this is the first pilot whose
+ *    Apply phase contains none.
+ *  - **verify shape**: a single `wait-for-stack`-free health check
+ *    (`health-gate` against the function's alias URL) rather than an ECS
+ *    steady-state poll or a Neo4j quorum probe.
+ *
+ * Reuses `docker-build` + `publish-image` unchanged from the ALB/ECS pilot's
+ * axis (build + promote-by-digest is identical for a container-image Lambda:
+ * https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) — the
+ * `imageRef`/`codeRef` wiring (`@Publish.digest` / `@Publish.uri`) is the same
+ * `@Phase.field` prior-step reference form every pilot already uses. The only
+ * capability this component needed that didn't already exist is `lambda-deploy`
+ * (../verbs/apply.ts) — one new capability, exactly the sprawl metric's bound
+ * for "genuinely novel"; see ../SPRAWL-VALIDATION.md for the full accounting.
+ *
+ * The JSON projection of this pilot is authoritative at
+ * ../__fixtures__/lambda-image-processor.json — this module is the real
+ * typed `Component` authoring form (#560, ../component.ts) that composes to
+ * that same document; see ./pilots.test.ts, which asserts the two never
+ * diverge.
+ */
+import type { Component } from "../component.js";
+export declare const imageProcessor: Component;
+//# sourceMappingURL=lambda.pilot.d.ts.map

package/dist/components/pilots/lambda.pilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambda.pilot.d.ts","sourceRoot":"","sources":["../../../src/components/pilots/lambda.pilot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C,eAAO,MAAM,cAAc,EAAE,SAkB5B,CAAC"}

package/dist/components/pilots/neo4j-fanout.pilot.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Pilot: Neo4j per-instance fan-out cluster (#555, epic #551).
+ *
+ * Exercises the fan-out axis: one component composing N per-instance
+ * mini-compositions (`cfn-deploy` + `code-deploy` + a health wait), seeded
+ * first, then rolled through the remaining instances one at a time behind a
+ * `wait-cluster-healthy` gate. See composition-and-wiring.mdx#fan-out-is-composition-not-orchestrator-knowledge.
+ *
+ * The JSON projection of this pilot is authoritative at
+ * ../__fixtures__/neo4j-fanout.json (already schema-validated by
+ * component-schema.test.ts) — this module is the real typed `Component`
+ * authoring form (#560, ../component.ts) that composes to that same
+ * document; see ./pilots.test.ts, which asserts the two never diverge.
+ */
+import type { Component } from "../component.js";
+export declare const neo4jCluster: Component;
+//# sourceMappingURL=neo4j-fanout.pilot.d.ts.map

package/dist/components/pilots/neo4j-fanout.pilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neo4j-fanout.pilot.d.ts","sourceRoot":"","sources":["../../../src/components/pilots/neo4j-fanout.pilot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAS,MAAM,cAAc,CAAC;AAkErD,eAAO,MAAM,YAAY,EAAE,SAU1B,CAAC"}

package/dist/components/pilots/project.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Re-exports the real `projectToJson` (#560, ../component.ts) under the
+ * pilots' original import path. Prior to #560, this module held its own
+ * "intentionally dumb" projection over the stopgap `authoring-shape.ts`
+ * (#555); now that the real typed `Component` authoring form exists, its
+ * `projectToJson` (which also fills in `archetype` via `inferArchetype` when
+ * a pilot doesn't set one explicitly) is the single implementation. Kept as a
+ * re-export, rather than inlining `../component`'s import into every pilot
+ * test, so `./pilots.test.ts`/`./pilots-e2e.test.ts`/`../driver.test.ts`
+ * don't need their import paths touched by this migration.
+ */
+export { projectToJson } from "../component.js";
+//# sourceMappingURL=project.d.ts.map

package/dist/components/pilots/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/components/pilots/project.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/components/presets/ecs-fargate.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Preset: `EcsFargateComponent` (#566, epic #551 §"6. Presets (Level 2 reuse)").
+ *
+ * The named-composition builder for the ALB/ECS shape
+ * (`../pilots/alb-ecs.pilot.ts`): `docker-build` -> `publish-image` ->
+ * `cfn-deploy` (importing a shared ALB's cross-stack outputs) ->
+ * `ecs-update-service` -> `wait-steady-state` + `health-gate`, with the same
+ * component-declared `rollback-previous` compensation phase the pilot uses
+ * (no native rollback for an already-running service swap — see
+ * ../pilots/alb-ecs.pilot.ts's docstring).
+ *
+ * This is Level 2 reuse over Level 1 raw capabilities: a component that looks
+ * like this composes `EcsFargateComponent({ ... })` directly; the odd case
+ * that needs something extra starts from the same shape and drops to raw
+ * `phase()`/capability `Step`s where it is special (see
+ * docs/components/capabilities.mdx#presets--reuse-without-a-closed-set) —
+ * `./ecs-fargate.test.ts` demonstrates exactly that by re-deriving
+ * `alb-ecs.pilot.ts`'s `searchService` component from this preset and
+ * asserting the two project to the identical JSON contract.
+ */
+import type { Component, Wiring } from "../component.js";
+export interface EcsFargateComponentConfig {
+    /** Component/service name (kebab-case) — becomes both the component's `name` and the ECS service name unless `service` overrides it. */
+    name: string;
+    /** ECS service name. Default: `name`. */
+    service?: string;
+    /** Docker build context. Default: ".". */
+    context?: string;
+    /** Path to the built CloudFormation template inside the archive. Default: `archive:<name>.template.json`. */
+    template?: string;
+    /** Health check path for the post-deploy `health-gate`. */
+    healthPath: string;
+    /** Other components that must complete first, beyond the shared-ALB stack (if any). */
+    dependsOn?: string[];
+    /**
+     * Shared ALB stack this service imports `ListenerArn`/`ClusterArn`/`Subnets`
+     * from, via cross-stack `stackOutput()` wiring — the same axis
+     * `alb-ecs.pilot.ts` exercises. Omit for a service with its own
+     * self-contained stack (no shared-ALB import; `cfn-deploy` receives no
+     * `inputs`).
+     */
+    sharedAlbStack?: string;
+    /** Additional/override CloudFormation template inputs, merged with (and taking precedence over) the shared-ALB outputs. */
+    extraInputs?: Record<string, Wiring>;
+    /** ECS cluster reference passed to `ecs-update-service`. Default: `"$env.cluster"`. */
+    cluster?: Wiring;
+    /** Destination registry `publish-image` promotes to. Default: `"$env.registry"`. */
+    registry?: Wiring;
+}
+/**
+ * Expand an ECS/Fargate service behind an ALB to its standard
+ * Publish/Apply/Verify composition — the 80% shape `alb-ecs.pilot.ts` is the
+ * hand-composed reference for. Returns a full `Component`; a caller that
+ * needs one extra step (an additional Apply capability, a different Verify
+ * shape) spreads the result and edits `deploy`/`rollback` directly — the
+ * preset is a starting composition, not a closed strategy object.
+ */
+export declare function EcsFargateComponent(config: EcsFargateComponentConfig): Component;
+//# sourceMappingURL=ecs-fargate.d.ts.map

package/dist/components/presets/ecs-fargate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecs-fargate.d.ts","sourceRoot":"","sources":["../../../src/components/presets/ecs-fargate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtD,MAAM,WAAW,yBAAyB;IACxC,wIAAwI;IACxI,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6GAA6G;IAC7G,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2HAA2H;IAC3H,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,SAAS,CAyChF"}

package/dist/components/presets/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Preset library (#566, epic #551 §"6. Presets (Level 2 reuse)") — named
+ * composition builders for the common component shapes. Each preset expands
+ * to a full, valid `Component` (../component.ts): the same typed authoring
+ * form and JSON contract every hand-composed component projects to, so a
+ * preset-based component and a hand-composed one are indistinguishable to
+ * `projectToJson`, schema validation, lint, and the driver.
+ *
+ * This is Level 2 reuse over Level 1 raw capabilities
+ * (docs/components/capabilities.mdx#presets--reuse-without-a-closed-set): a
+ * component that matches one of these shapes calls the preset directly; the
+ * odd one that needs something extra spreads the returned `Component` and
+ * edits `deploy`/`rollback` where it is special. Presets remove composition
+ * copy-paste (the COMP007 lint hint) without creating a closed strategy set —
+ * see ./ecs-fargate.test.ts, ./lambda.test.ts, and
+ * ./single-host-compose.test.ts, each of which re-derives an existing
+ * hand-composed pilot/fixture from its preset and asserts the two project to
+ * the identical JSON contract.
+ *
+ * Deliberately not exhaustive: three presets covering the three archetypes'
+ * most common shapes (a load-balanced container service, a container-image
+ * Lambda function, and a registry-less single-host compose deploy), per
+ * #566's explicit scope ("start with the common shapes; an exhaustive
+ * catalog is out of scope").
+ */
+export { EcsFargateComponent, type EcsFargateComponentConfig } from "./ecs-fargate.js";
+export { LambdaComponent, type LambdaComponentConfig } from "./lambda.js";
+export { SingleHostComposeComponent, type SingleHostComposeComponentConfig, } from "./single-host-compose.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/presets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/presets/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,mBAAmB,EAAE,KAAK,yBAAyB,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,EAAE,eAAe,EAAE,KAAK,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACvE,OAAO,EACL,0BAA0B,EAC1B,KAAK,gCAAgC,GACtC,MAAM,uBAAuB,CAAC"}