@intentius/chant 0.57.0 → 0.59.0

package/src/terraform/graph.ts

@@ -11,7 +11,8 @@
  * graph building stays unit-testable on hand-written fixtures.
  */
 
-import { identityAttrOf } from "./tier-map";
+import { shapeSourcePaths } from "./data-source-shape";
+import { dataSourceShapeOf, identityAttrOf } from "./tier-map";
 import type { Hcl2JsonTree, TfEdge, TfGraph, TfNode } from "./types";
 
 /**
@@ -142,16 +143,14 @@ function blockHasMeta(block: unknown, key: string): boolean {
 }
 
 /**
- * The resource's physical name, if its identity attribute is a plain literal
- * (not interpolated). A dotted identity attribute walks nested blocks —
+ * The literal string at a dotted path into a block, or undefined when the path
+ * misses or lands on an interpolation. A dotted path walks nested blocks —
  * hcl2json renders a nested block as a one-element array, so arrays step
  * through their first element (`manifest.metadata.name`).
  */
-function literalIdentity(block: unknown, type: string): string | undefined {
-  const attr = identityAttrOf(type);
-  if (!attr || !block || typeof block !== "object") return undefined;
+function literalAt(block: unknown, path: string): string | undefined {
   let value: unknown = block;
-  for (const segment of attr.split(".")) {
+  for (const segment of path.split(".")) {
     if (Array.isArray(value)) value = value[0];
     if (!value || typeof value !== "object") return undefined;
     value = (value as Record<string, unknown>)[segment];
@@ -160,6 +159,34 @@ function literalIdentity(block: unknown, type: string): string | undefined {
   return value;
 }
 
+/**
+ * The resource's physical name, if its identity attribute is a plain literal
+ * (not interpolated).
+ */
+function literalIdentity(block: unknown, type: string): string | undefined {
+  const attr = identityAttrOf(type);
+  if (!attr || !block || typeof block !== "object") return undefined;
+  return literalAt(block, attr);
+}
+
+/**
+ * The literals the type's data-source shape reads out of the carved block
+ * (#2034), keyed by the shape field's source path. `carve bridge` renders the
+ * data-source body from these; a required field missing here is what makes it
+ * write a TODO instead of a block Terraform would reject.
+ */
+function dataSourceValues(block: unknown, type: string): Record<string, string> | undefined {
+  if (!block || typeof block !== "object") return undefined;
+  const shape = dataSourceShapeOf(type);
+  if (!shape) return undefined;
+  const values: Record<string, string> = {};
+  for (const path of shapeSourcePaths(shape)) {
+    const value = literalAt(block, path);
+    if (value !== undefined) values[path] = value;
+  }
+  return Object.keys(values).length ? values : undefined;
+}
+
 /**
  * Build the dependency graph from a merged hcl2json tree.
  *
@@ -202,6 +229,7 @@ export function buildGraph(tree: Hcl2JsonTree, exprRefs: ExpressionRefs): TfGrap
         instances: 1,
         hasDynamic: dynamic || touchesData,
         identity: literalIdentity(block, type),
+        dataSourceValues: dataSourceValues(block, type),
       });
     }
   }

package/src/terraform/providers/kubernetes.ts

@@ -18,6 +18,11 @@
  * can only name the family, and `adopt` reads the body to learn the rest —
  * which is also why one rule here covers every CRD.
  *
+ * It has no `kubernetes_manifest` data source either, so it does not read back
+ * as its own type. `MANIFEST_READ_BACK` below is the shape `carve bridge` uses
+ * instead: `data "kubernetes_resource"`, built from the manifest's own
+ * apiVersion/kind/metadata (#2034).
+ *
  * It has no live adoption path. `carve emit --env` filters a live export by a
  * native type, and there is no type to filter by until the body is read; state
  * is where the body is. `liveSelectorType` therefore returns undefined and
@@ -26,6 +31,7 @@
  */
 
 import type { AdoptedSource, CarveProvider, DeferredParam, TierInfo } from "../carve-provider";
+import type { DataSourceShape } from "../data-source-shape";
 import type { StateResource } from "../state";
 
 /** The chant lexicon the emitted source imports from. */
@@ -208,14 +214,54 @@ function adoptManifestFromState(resource: StateResource, params: DeferredParam[]
   };
 }
 
+/**
+ * How `carve bridge` reads a carved `kubernetes_manifest` back (#2034).
+ *
+ * The provider ships no `kubernetes_manifest` data source — checked against
+ * hashicorp/kubernetes v3.2.1, whose 27 data sources include no manifest. The
+ * generic read is `data "kubernetes_resource"`, which asks for the GVK and the
+ * name rather than taking them from a body: `api_version`, `kind`, and a
+ * nested `metadata` block with `name` and an optional `namespace`. All three
+ * come out of the manifest the resource declared.
+ *
+ * Survivors read the object back through `object`, and only through `object`:
+ * the resource exposes both `manifest` (the declared body) and `object` (the
+ * API server's read-back), the data source exposes just the latter. So both
+ * map to `object`, and a reference to `.manifest.data.log_level` lands on
+ * `.object.data.log_level` rather than an attribute that does not exist.
+ *
+ * A namespace-less manifest (a ClusterRole, a CRD) simply omits `namespace`,
+ * which the data source allows. A manifest whose name is interpolated resolves
+ * no literal and falls back to the bridge's TODO body, as an AWS type with an
+ * interpolated bucket name does.
+ */
+const MANIFEST_READ_BACK: DataSourceShape = {
+  type: "kubernetes_resource",
+  args: [
+    { name: "api_version", from: "manifest.apiVersion", required: true },
+    { name: "kind", from: "manifest.kind", required: true },
+  ],
+  blocks: [
+    {
+      name: "metadata",
+      fields: [
+        { name: "name", from: "manifest.metadata.name", required: true },
+        { name: "namespace", from: "manifest.metadata.namespace" },
+      ],
+    },
+  ],
+  readAttrs: { manifest: "object", object: "object" },
+};
+
 export const kubernetesCarveProvider: CarveProvider = {
   name: "kubernetes",
   tfTypePrefixes: ["kubernetes_"],
   lexicon: "k8s",
   tiers: TIERS,
-  // A dotted path into nested blocks: the graph walks it for identity, and
-  // `carve bridge` refuses the type because a data-source body cannot express it.
+  // A dotted path into the manifest body: the graph walks it for identity. It
+  // cannot be a data-source argument on its own, so the read-back is a shape.
   identityAttrs: { kubernetes_manifest: "manifest.metadata.name" },
+  dataSourceShapes: { kubernetes_manifest: MANIFEST_READ_BACK },
   emitTypes: ["kubernetes_manifest"],
   adopt: (resource, params) => adoptManifestFromState(resource, params),
   // State only — the kind is in the body, so a live export has nothing to

package/src/terraform/tier-map.ts

@@ -18,14 +18,17 @@
  */
 
 import {
+  carveDataSourceShape,
   carveFoldParent,
   carveIdentityAttr,
   carveTierMap,
   resolveEmitProvider,
   type TierInfo,
 } from "./carve-provider";
+import type { DataSourceShape } from "./data-source-shape";
 
 export { carveEmitTypes, type TierInfo } from "./carve-provider";
+export type { DataSourceShape } from "./data-source-shape";
 
 /** TF resource type → native tier, over every registered provider. Absent = unsupported (score 0). */
 export function tierMap(): Readonly<Record<string, TierInfo>> {
@@ -66,12 +69,24 @@ export function canCarveEmit(tfType: string): boolean {
 }
 
 /**
- * Can `chant carve bridge` render a Terraform `data` source for this type? A
- * dotted identity attribute is a path into nested blocks, and a data source
- * body is flat `attr = value` — `manifest.metadata.name = "x"` is not valid
- * HCL. An absent entry is fine: the bridge writes a TODO comment instead.
+ * How `chant carve bridge` reads this type back as a `data` source: the
+ * data-source type, where each argument comes from in the carved body, and how
+ * a survivor's attribute path translates (#2034). Undefined when the type
+ * cannot be read back at all.
+ */
+export function dataSourceShapeOf(tfType: string): DataSourceShape | undefined {
+  return carveDataSourceShape(tfType);
+}
+
+/**
+ * Can `chant carve bridge` render a Terraform `data` source for this type?
+ * True whenever its provider contributes a shape — declared, or implied by a
+ * plain identity attribute. False for a dotted identity attribute with no
+ * declared shape: that is a path into nested values, and a flat `attr = value`
+ * body cannot express it (`manifest.metadata.name = "x"` is not valid HCL). A
+ * type with no identity attribute at all still bridges; the bridge writes a
+ * TODO comment for the body.
  */
 export function canBridge(tfType: string): boolean {
-  const attr = carveIdentityAttr(tfType);
-  return attr === undefined || !attr.includes(".");
+  return carveDataSourceShape(tfType) !== undefined;
 }

package/src/terraform/types.ts

@@ -34,6 +34,14 @@ export interface TfNode {
    * emit. Undefined when the identity attribute is absent or interpolated.
    */
   identity?: string;
+  /**
+   * The literals the type's data-source shape reads out of the block (#2034),
+   * keyed by the shape field's source path (`manifest.metadata.name`). This is
+   * what `carve bridge` renders the `data` body from — a superset of
+   * `identity`, since a shape can need more than one value (`api_version`,
+   * `kind` and `metadata.name` for a `kubernetes_manifest`).
+   */
+  dataSourceValues?: Record<string, string>;
 }
 
 /**

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"}