@intentius/chant 0.56.0 → 0.58.0

package/src/provenance.ts

@@ -71,11 +71,27 @@ export interface EntityProvenance {
  *   is governed by `tier`, which is what an editor needs to know. Under-reports
  *   (a shape the collector does not follow drops a dependency) and never
  *   over-reports a parameter the expression does not mention.
+ * - `composite-parameter` — the fold interpreted the composite's factory body,
+ *   and the expression for this path reads the named factory parameter paths
+ *   (chant #2161). Same syntactic-dependency discipline as `build-param`, and
+ *   for the same reason: a shape the collector does not follow drops a
+ *   parameter, it never invents one.
+ * - `composite-literal` — the fold interpreted the factory body and the
+ *   expression for this path reads no parameter at all. The composite fixes
+ *   this field, and no argument at the call site moves it.
+ *
+ * The coarse `composite` and the two fine kinds are not alternatives. A build
+ * records `composite` when it expanded a composite without interpreting its
+ * body (the run path, an inadmissible factory), and that is why
+ * ./fold-provenance.ts answers `unknown` there rather than falling through to a
+ * direct declaration.
  */
 export type PathOrigin =
   | { kind: "authored" }
   | { kind: "composite"; composite: string; instance: string }
-  | { kind: "build-param"; params: string[] };
+  | { kind: "build-param"; params: string[] }
+  | { kind: "composite-parameter"; composite: string; parameters: string[] }
+  | { kind: "composite-literal"; composite: string };
 
 /** True when `prefix` addresses `path` or an ancestor of it, on a segment boundary. */
 function isPathPrefix(prefix: string, path: string): boolean {
@@ -170,6 +186,10 @@ export function describePathOrigin(origin: PathOrigin): string {
       return `composite ${origin.composite} (${origin.instance})`;
     case "build-param":
       return `param ${origin.params.join(", ")}`;
+    case "composite-parameter":
+      return `composite ${origin.composite} parameter ${origin.parameters.join(", ")}`;
+    case "composite-literal":
+      return `composite ${origin.composite} literal`;
   }
 }
 

package/src/serializer-walker.test.ts

@@ -4,6 +4,7 @@ import { DECLARABLE_MARKER, type Declarable } from "./declarable";
 import { INTRINSIC_MARKER } from "./intrinsic";
 import { AttrRef } from "./attrref";
 import { createResource } from "./runtime";
+import { heldElsewhere } from "./held-elsewhere";
 
 function makeDeclarable(type: string, kind: "resource" | "property" = "resource", props?: Record<string, unknown>): Declarable & { props?: Record<string, unknown> } {
   const d: Declarable & { props?: Record<string, unknown> } = {
@@ -145,3 +146,44 @@ describe("walkValue", () => {
     });
   });
 });
+
+// #2162 — a `heldElsewhere()` marker is never written to the applied
+// payload: the field is omitted entirely so the provider defaults it once at
+// creation and the named holder owns it from there. Every apply this
+// synthesizes omits it, not only the first — re-asserting even the field's
+// own value on a later apply would fight whatever the holder wrote in
+// between.
+describe("walkValue — heldElsewhere() markers (#2162)", () => {
+  test("a top-level held value walks to undefined", () => {
+    const names = new Map<Declarable, string>();
+    const marker = heldElsewhere<number>({ by: "hpa", reason: "x" });
+    expect(walkValue(marker, names, mockVisitor)).toBeUndefined();
+  });
+
+  test("an object key holding a marker is omitted entirely, not set to undefined", () => {
+    const names = new Map<Declarable, string>();
+    const value = {
+      replicas: heldElsewhere<number>({ by: "hpa", reason: "the autoscaler owns replicas after the first apply" }),
+      image: "app:1",
+    };
+    const result = walkValue(value, names, mockVisitor);
+    expect(result).toEqual({ image: "app:1" });
+    expect(Object.keys(result as object)).not.toContain("replicas");
+  });
+
+  test("a held element inside an array is dropped, not left as a hole", () => {
+    const names = new Map<Declarable, string>();
+    const value = { tolerations: ["a", heldElsewhere<string>({ by: "controller", reason: "x" }), "b"] };
+    expect(walkValue(value, names, mockVisitor)).toEqual({ tolerations: ["a", "b"] });
+  });
+
+  test("nested inside a property-kind declarable's own props, still omitted", () => {
+    const names = new Map<Declarable, string>();
+    const scaleTarget = makeDeclarable("K8s::Autoscaling::HorizontalPodAutoscaler.Behavior", "property", {
+      scaleUp: heldElsewhere<Record<string, unknown>>({ by: "hpa", reason: "the controller tunes its own policy" }),
+      stabilizationWindowSeconds: 60,
+    });
+    const result = walkValue(scaleTarget, names, mockVisitor);
+    expect(result).toEqual({ stabilizationWindowSeconds: 60 });
+  });
+});

package/src/serializer-walker.ts

@@ -7,6 +7,7 @@
 
 import type { Declarable } from "./declarable";
 import { isPropertyDeclarable } from "./declarable";
+import { isHeldElsewhere } from "./held-elsewhere";
 import { INTRINSIC_MARKER } from "./intrinsic";
 import { AttrRef } from "./attrref";
 import { isAttrRefLike } from "./utils";
@@ -33,6 +34,16 @@ export function walkValue(
     return value;
   }
 
+  // A `heldElsewhere()` marker (#2162) is never written to the applied
+  // payload — the provider defaults the field once at actual creation, and
+  // whoever the declaration names as holder owns it from there. Every apply
+  // this synthesizes therefore omits the field entirely, not only the
+  // first: re-asserting even the field's own value on a later apply would
+  // fight whatever the holder wrote in between. Checked first, ahead of
+  // every other dispatch branch below — a held marker is never an AttrRef,
+  // an Intrinsic, or authored Declarable data.
+  if (isHeldElsewhere(value)) return undefined;
+
   // Handle AttrRef
   if (isAttrRefLike(value)) {
     const name = value.getLogicalName();
@@ -77,9 +88,13 @@ export function walkValue(
     return visitor.propertyDeclarable(decl, (v) => walkValue(v, entityNames, visitor));
   }
 
-  // Handle arrays
+  // Handle arrays. A held marker element is filtered out before recursing —
+  // `walkValue` would return `undefined` for it too, but leaving it in the
+  // array would emit a hole (`[a, null, b]`) rather than omitting it.
   if (Array.isArray(value)) {
-    return value.map((item) => walkValue(item, entityNames, visitor));
+    return value
+      .filter((item) => !isHeldElsewhere(item))
+      .map((item) => walkValue(item, entityNames, visitor));
   }
 
   // Handle serialized AttrRef envelopes (produced by AttrRef.toJSON() inside intrinsics)
@@ -92,6 +107,10 @@ export function walkValue(
   if (typeof value === "object") {
     const result: Record<string, unknown> = {};
     for (const [key, val] of Object.entries(value)) {
+      // A held marker key is omitted entirely (#2162), not set to
+      // `undefined` — the two read differently to a YAML emitter, and only
+      // omission is "the provider never hears about this field".
+      if (isHeldElsewhere(val)) continue;
       const outKey = key;
       result[outKey] = walkValue(val, entityNames, visitor);
     }

package/src/stack-output.ts

@@ -33,6 +33,10 @@ export interface StackOutput extends Declarable {
   /** When set, the serializer emits a cross-stack export under this name
    * (CloudFormation `Output.Export.Name`) in addition to the plain output. */
   readonly exportName?: string;
+  /** When set, the output is gated on a declared condition (CloudFormation
+   * `Output.Condition`) — a condition name, or the condition Declarable
+   * itself, resolved to its logical name at serialization (#2068/#2069). */
+  readonly condition?: string | Declarable;
 }
 
 /** What a wrapping intrinsic's lexicon gets derived from: either a nested
@@ -108,7 +112,7 @@ export function isStackOutput(value: unknown): value is StackOutput {
  */
 export function stackOutput(
   ref: AttrRef | Intrinsic | string,
-  options?: { description?: string; exportName?: string; lexicon?: string },
+  options?: { description?: string; exportName?: string; lexicon?: string; condition?: string | Declarable },
 ): StackOutput {
   // Duck-type, not `instanceof` (chant #1137): AttrRef also implements
   // Intrinsic (a global-symbol marker), so `isIntrinsic(ref)` alone already
@@ -147,6 +151,7 @@ export function stackOutput(
     sourceRef: ref,
     description: options?.description,
     exportName: options?.exportName,
+    condition: options?.condition,
   };
 
   return output;

package/dist/cli/handlers/op-progress.d.ts

@@ -1,90 +0,0 @@
-/**
- * Per-phase progress reconstructed from a Temporal Op workflow's history
- * (chant #1676) — the durable-path counterpart to the local executor's
- * `StepRecord[]` (op/local-executor.ts), so `chant run <name> --temporal
- * --progress-json` and `op-status` can report the same shape `chant run
- * <name> --json` already does for the local path, instead of the two raw
- * `ActivityTaskScheduled`/`ActivityTaskCompleted` counts.
- *
- * A step is joined to its declared (phase, fn) by position, not by name: the
- * declared step list (`declaredStepOrder`, mirroring the serializer's own
- * `collectActivitySteps` traversal — main phases, then `onFailure` phases
- * *reversed*, matching how the generated workflow actually runs them) is
- * walked in order, and each step consumes the next not-yet-consumed
- * `ActivityTaskScheduled` event whose activity type matches its `fn` — a
- * per-fn FIFO queue, not a global "does this name appear anywhere" scan.
- * Two steps calling the same activity therefore each get their own
- * scheduled event instead of the later one overwriting the earlier
- * (the collision the prior `run-report.ts` join had). A step whose queue is
- * empty never ran this execution — an untaken effect branch, or an
- * `onFailure` phase on a run that succeeded.
- */
-import type { OpConfig } from "../../op/types.js";
-import type { StepRecord } from "../../op/local-executor.js";
-import type { WorkflowHistoryRaw, WorkflowHandleRaw } from "./run-client.js";
-/**
- * A step record paired with the position of the declared step it came from.
- *
- * `index` is an offset into `declaredStepOrder(config)`, which depends only
- * on the Op config — not on the history — so it is the record's identity
- * and is stable across polls. The record *list* is not: a mid-run poll omits
- * every step that hasn't settled yet, and the terminal `final: true` pass
- * inserts a `"skipped"` record at each such step's declared position, which
- * shifts every later record's list offset (chant #2032). Anything tracking
- * what it has already seen must key on `index`, never on how many records
- * the previous call returned.
- */
-export interface IndexedStepRecord {
-    index: number;
-    record: StepRecord;
-}
-/**
- * Reconstruct per-step progress records from a workflow's history, in
- * declared order, each tagged with its declared-step `index`. Only settled
- * steps (matched to a scheduled event that has since completed or failed)
- * produce a record — a step that hasn't been scheduled yet simply isn't in
- * the result. Pass `final: true` once the workflow has reached a terminal
- * status to also emit a `"skipped"` record for every declared step that
- * never got a matching scheduled event (an untaken effect branch, or an
- * `onFailure` phase on a run that succeeded) — never before, or a
- * still-running Op would show its not-yet-reached steps as skipped.
- */
-export declare function extractIndexedStepRecords(config: OpConfig, history: WorkflowHistoryRaw, opts?: {
-    final?: boolean;
-}): IndexedStepRecord[];
-/** `extractIndexedStepRecords` without the indices — the plain declared-order record list. */
-export declare function extractStepRecords(config: OpConfig, history: WorkflowHistoryRaw, opts?: {
-    final?: boolean;
-}): StepRecord[];
-/**
- * A sink that forwards each declared step's record exactly once, however many
- * times the poll loop re-derives the list.
- *
- * `--progress-json` calls this per poll with the whole list so far, plus once
- * more with the terminal `final: true` list. Deduplicating by declared-step
- * `index` is what makes that safe: an emitted-count watermark assumed the list
- * was append-only, and the `final` pass's inserted `"skipped"` records break
- * that assumption — with an unreached phase declared before an `onFailure`
- * phase that ran, the insertion shifted the tail, so the last record shipped
- * twice and the skipped one never shipped at all (chant #2032).
- */
-export declare function stepRecordEmitter(emit: (record: StepRecord) => void): (records: IndexedStepRecord[]) => void;
-/** `{completed, scheduled}` activity counts for the summary line `chant run status`/`op-status` show alongside the full record list. */
-export declare function countActivities(history: WorkflowHistoryRaw): {
-    completed: number;
-    scheduled: number;
-};
-/** The `gateState` workflow query's result (op/serializer.ts's `emitGate`) — the gate currently blocking the workflow, or `null` when none is pending. */
-export interface GateQueryResult {
-    signalName: string;
-    description?: string;
-    since: string;
-}
-/**
- * Best-effort `gateState` query. `undefined` (as opposed to `null`) means
- * the query itself failed — an Op with no gate steps never registers a
- * `gateState` handler, so querying it is expected to fail, not an error
- * worth surfacing.
- */
-export declare function queryGateState(handle: WorkflowHandleRaw): Promise<GateQueryResult | null | undefined>;
-//# sourceMappingURL=op-progress.d.ts.map

package/dist/cli/handlers/op-progress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"op-progress.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/op-progress.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAmB,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAgB,iBAAiB,EAAE,MAAM,cAAc,CAAC;AA2FxF;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;CACpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7B,iBAAiB,EAAE,CAsCrB;AAED,8FAA8F;AAC9F,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC7B,UAAU,EAAE,CAEd;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,GAAG,CAAC,OAAO,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAS5G;AAED,wIAAwI;AACxI,wBAAgB,eAAe,CAAC,OAAO,EAAE,kBAAkB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAMrG;AAED,0JAA0J;AAC1J,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC,CAM3G"}

package/dist/cli/handlers/run-client.d.ts

@@ -1,127 +0,0 @@
-/** Subset of WorkerProfile fields used by `chant run`. */
-export interface WorkerProfile {
-    address: string;
-    namespace: string;
-    taskQueue: string;
-    tls?: boolean | {
-        serverNameOverride?: string;
-    };
-    apiKey?: string | {
-        env: string;
-    };
-    autoStart?: boolean;
-}
-export interface TemporalClientModule {
-    Connection: {
-        connect(opts: Record<string, unknown>): Promise<unknown>;
-    };
-    Client: new (opts: Record<string, unknown>) => TemporalClientHandle;
-}
-export interface TemporalClientHandle {
-    workflow: {
-        start(workflowFn: unknown, opts: Record<string, unknown>): Promise<WorkflowHandleRaw>;
-        getHandle(workflowId: string): WorkflowHandleRaw;
-        list(opts?: Record<string, unknown>): AsyncIterable<WorkflowExecutionInfo>;
-    };
-}
-export interface WorkflowHandleRaw {
-    workflowId: string;
-    firstExecutionRunId?: string;
-    result(): Promise<unknown>;
-    describe(): Promise<WorkflowExecutionDescription>;
-    fetchHistory(): Promise<WorkflowHistoryRaw>;
-    signal(signalName: string, ...args: unknown[]): Promise<void>;
-    query<T = unknown>(queryName: string, ...args: unknown[]): Promise<T>;
-    cancel(): Promise<void>;
-}
-export interface WorkflowExecutionDescription {
-    workflowId: string;
-    runId: string;
-    status: {
-        name: string;
-    };
-    startTime: Date;
-    closeTime?: Date;
-    taskQueue: string;
-    type: {
-        name: string;
-    };
-}
-export interface WorkflowExecutionInfo {
-    workflowId: string;
-    runId: string;
-    type: {
-        name: string;
-    };
-    status: {
-        name: string;
-    };
-    startTime: Date;
-    closeTime?: Date;
-}
-export interface WorkflowHistoryRaw {
-    events?: HistoryEvent[];
-}
-/**
- * `eventType` is the short PascalCase form (`"ActivityTaskScheduled"`, not
- * the wire enum's `"EVENT_TYPE_ACTIVITY_TASK_SCHEDULED"`) and `eventId`/
- * `scheduledEventId` are decimal strings — the shape {@link fetchNormalizedHistory}
- * produces, not `WorkflowHandleRaw.fetchHistory()`'s own raw return value.
- */
-export interface HistoryEvent {
-    eventId?: string;
-    eventType?: string;
-    eventTime?: Date;
-    activityTaskCompletedEventAttributes?: {
-        scheduledEventId?: string;
-    };
-    activityTaskScheduledEventAttributes?: {
-        activityId?: string;
-        activityType?: {
-            name?: string;
-        };
-    };
-    activityTaskFailedEventAttributes?: {
-        scheduledEventId?: string;
-        failure?: {
-            message?: string;
-        };
-    };
-    workflowExecutionCompletedEventAttributes?: unknown;
-    workflowExecutionFailedEventAttributes?: {
-        failure?: {
-            message?: string;
-        };
-    };
-}
-/**
- * `WorkflowHandleRaw.fetchHistory()` returns the Temporal wire proto
- * untouched: `eventType` is the numeric enum, `eventId`/`scheduledEventId`
- * are `Long` instances, `eventTime` is a `{seconds, nanos}` protobuf
- * Timestamp — none of them comparable or constructible the way the rest of
- * this file (and run-report.ts, op-progress.ts) needs. The proto message's
- * own `toJSON()` is what turns enums into their string name and `Long`s into
- * decimal strings, so a JSON round-trip is the normalization step; only
- * `eventTime` then needs a further Timestamp-to-Date conversion.
- */
-export declare function fetchNormalizedHistory(handle: WorkflowHandleRaw): Promise<WorkflowHistoryRaw>;
-/**
- * Dynamically import @temporalio/client from the user's project node_modules.
- * Fails with a helpful message if not installed.
- */
-export declare function loadTemporalClient(): Promise<TemporalClientModule>;
-/**
- * Build a Temporal Connection.connect() options object from a worker profile.
- */
-export declare function connectionOptions(profile: WorkerProfile): Record<string, unknown>;
-/**
- * Deterministic workflow ID for an Op — allows status/signal/cancel/log
- * without storing run IDs locally.
- */
-export declare function resolveWorkflowId(opName: string): string;
-/**
- * Resolve a named profile from the chant config.
- * Falls back to defaultProfile then "local".
- */
-export declare function resolveProfile(config: Record<string, unknown>, profileName?: string): WorkerProfile;
-//# sourceMappingURL=run-client.d.ts.map

package/dist/cli/handlers/run-client.d.ts.map

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

package/dist/cli/handlers/run-report.d.ts

@@ -1,5 +0,0 @@
-import type { OpConfig } from "../../op/types.js";
-import type { WorkflowExecutionDescription, WorkflowHistoryRaw } from "./run-client.js";
-export declare function generateReport(opName: string, config: OpConfig, description: WorkflowExecutionDescription, history: WorkflowHistoryRaw): string;
-export declare function writeReport(opName: string, markdown: string): string;
-//# sourceMappingURL=run-report.d.ts.map

package/dist/cli/handlers/run-report.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-report.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/run-report.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,4BAA4B,EAAE,kBAAkB,EAAgB,MAAM,cAAc,CAAC;AA2CnG,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,EAChB,WAAW,EAAE,4BAA4B,EACzC,OAAO,EAAE,kBAAkB,GAC1B,MAAM,CA+DR;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKpE"}

package/dist/components/temporal-codegen-loader.d.ts

@@ -1,27 +0,0 @@
-/**
- * Dynamic loader for the durable component → Temporal codegen (#589, epic
- * #551 §5/§8). The actual `serializeComponent` generator lives in
- * `@intentius/chant-lexicon-temporal` (`src/component-op/serializer.ts`),
- * mirroring `Temporal::Op` codegen — core never statically depends on the
- * Temporal lexicon, the same boundary `../op/activity-registry.ts`'s
- * `loadActivities`/`loadProfiles` already keep for Op activities.
- */
-import type { DriverComponent } from "./driver.js";
-/** Target environment (and env-config) baked into the generated workflow at compile time — see `serializeComponent`'s docstring in the Temporal lexicon for why this can't be resolved at workflow-run time instead. */
-export interface ComponentTemporalCodegenOptions {
-    env?: string;
-    vars?: Record<string, unknown>;
-}
-export interface ComponentTemporalCodegen {
-    /** Serialize one component into `{ "components/<name>/workflow.ts": "...", ... }`. */
-    serializeComponent(component: DriverComponent, options?: ComponentTemporalCodegenOptions): Record<string, string>;
-    /** Deterministic workflow function name for a component (mirrors the generated `export async function <fn>()`). */
-    componentWorkflowFnName(componentName: string): string;
-}
-/**
- * Dynamically import the Temporal lexicon's component codegen. Throws a
- * friendly error if the lexicon is not installed — the durable component
- * path needs the generator even though discovery/local execution never do.
- */
-export declare function loadComponentTemporalCodegen(): Promise<ComponentTemporalCodegen>;
-//# sourceMappingURL=temporal-codegen-loader.d.ts.map

package/dist/components/temporal-codegen-loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"temporal-codegen-loader.d.ts","sourceRoot":"","sources":["../../src/components/temporal-codegen-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,wNAAwN;AACxN,MAAM,WAAW,+BAA+B;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,wBAAwB;IACvC,sFAAsF;IACtF,kBAAkB,CAAC,SAAS,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,+BAA+B,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClH,mHAAmH;IACnH,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAAC;CACxD;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAWtF"}

package/dist/lint/rules/comp/comp004-gate-needs-temporal.d.ts

@@ -1,37 +0,0 @@
-/**
- * COMP004: gate-needs-temporal
- *
- * Flags a `gate` step anywhere in a component's composition — a durable,
- * human-approval wait that cannot run on the local in-process executor (see
- * ../../../components/driver.ts's `DriverGateUnsupportedError` and
- * docs/components/orchestration.mdx's "Temporal is optional" aside: "gates ...
- * require the durable (Temporal) execution backend").
- *
- * The component contract has no per-component backend/executor field (the
- * backend is chosen per *run*, via `chant run --temporal`, per epic #551 §8 —
- * intentionally not part of the declaration, so the same component graduates
- * to Temporal without changing its definition). That means lint cannot tell,
- * from the declaration alone, whether a given `gate` will actually run under
- * Temporal when this component is deployed — every `gate` is a standing
- * "this component needs the durable backend" fact worth surfacing, not a
- * mistake to silently allow. Acknowledge it explicitly with a **file-level**
- * disable directive once the durable backend is genuinely intended (see
- * lint-rules/disable-directives.mdx) — a COMP* diagnostic carries no real
- * line/column (it is reported for the whole component; see
- * ../../component-checks.ts), so only the file-level `chant-disable` form is
- * honored for these rules — `-line`/`-next-line` do not suppress a COMP*
- * diagnostic (see ../../../cli/commands/lint.ts's
- * `runComponentCheckDiagnostics`):
- *
- * ```ts
- * // chant-disable COMP004 -- graduates to --temporal for the human approval wait
- * ```
- *
- * Triggers on: any `gate` step in `deploy`/`rollback` with no matching
- * file-level disable directive.
- * OK: a component with no `gate` steps at all, or a `gate` whose file-level
- * disable directive documents the Temporal graduation.
- */
-import type { ComponentCheck } from "../../component-checks.js";
-export declare const comp004GateNeedsTemporalRule: ComponentCheck;
-//# sourceMappingURL=comp004-gate-needs-temporal.d.ts.map

package/dist/lint/rules/comp/comp004-gate-needs-temporal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"comp004-gate-needs-temporal.d.ts","sourceRoot":"","sources":["../../../../src/lint/rules/comp/comp004-gate-needs-temporal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAmD,MAAM,wBAAwB,CAAC;AAG9G,eAAO,MAAM,4BAA4B,EAAE,cA2B1C,CAAC"}