@intentius/chant 0.57.0 → 0.59.0

package/dist/discovery/param-deps.d.ts

@@ -14,4 +14,37 @@ import type { PathOrigin } from "../provenance.js";
  * contributes is not knowable here.
  */
 export declare function collectParamDependencies(props: ts.ObjectLiteralExpression, consts: ReadonlyMap<string, ts.Expression>, paramLocals: ReadonlySet<string>): Record<string, PathOrigin>;
+/**
+ * The factory-parameter names in scope inside one composite body (chant #2161).
+ *
+ * A `Composite()` factory takes at most one argument, so a parameter path is a
+ * path INTO that argument: `props.scaling.max` is the parameter path
+ * `scaling.max`. Two binding forms reach the same place — `(props) => …` binds
+ * the whole object under one name, `({ name, port }) => …` binds leaves — so
+ * the scope carries both.
+ */
+export interface CompositeParamScope {
+    /** Local names bound to the whole props object (`(props) => …`). */
+    whole: ReadonlySet<string>;
+    /** Local name → the parameter path it was destructured from (`({ name }) => …`). */
+    destructured: ReadonlyMap<string, string>;
+}
+/**
+ * Path → composite origin for one `new Type({...})` inside an interpreted
+ * composite factory body (chant #2161).
+ *
+ * Same walk, same path grammar and the same under-reporting posture as
+ * {@link collectParamDependencies}, with one added answer: a path whose
+ * expression reads NO parameter is recorded as `composite-literal` rather than
+ * left silent, because "the composite fixes this" is a finding in its own
+ * right — it is what the reconcile refuses on.
+ *
+ * A spread is the one place nothing is recorded when no parameter is found.
+ * Which keys it contributes is not knowable here, so `composite-parameter` at
+ * the containing object is a safe over-approximation of "a parameter governs
+ * something under here", while `composite-literal` would be a claim that every
+ * key it brings is fixed. That claim is left unmade, and those paths come back
+ * `unknown` from ../fold-provenance.ts instead.
+ */
+export declare function collectCompositeOrigins(props: ts.ObjectLiteralExpression, consts: ReadonlyMap<string, ts.Expression>, scope: CompositeParamScope, composite: string): Record<string, PathOrigin>;
 //# sourceMappingURL=param-deps.d.ts.map

package/dist/discovery/param-deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"param-deps.d.ts","sourceRoot":"","sources":["../../src/discovery/param-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AA+GhD;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,EAAE,CAAC,uBAAuB,EACjC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,EAC1C,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAC/B,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAwC5B"}
+{"version":3,"file":"param-deps.d.ts","sourceRoot":"","sources":["../../src/discovery/param-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAsHhD;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,EAAE,CAAC,uBAAuB,EACjC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,EAC1C,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAC/B,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAwC5B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B,oFAAoF;IACpF,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAkGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,EAAE,CAAC,uBAAuB,EACjC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,EAC1C,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAkD5B"}

package/dist/discovery/sandbox/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/discovery/sandbox/bundle.ts"],"names":[],"mappings":"AA4KA,MAAM,WAAW,YAAY;IAC3B,uSAAuS;IACvS,UAAU,EAAE,MAAM,CAAC;IACnB,kJAAkJ;IAClJ,SAAS,EAAE,MAAM,CAAC;IAClB,uQAAuQ;IACvQ,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,uGAAuG;IACvG,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA4B9E"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/discovery/sandbox/bundle.ts"],"names":[],"mappings":"AA0LA,MAAM,WAAW,YAAY;IAC3B,uSAAuS;IACvS,UAAU,EAAE,MAAM,CAAC;IACnB,kJAAkJ;IAClJ,SAAS,EAAE,MAAM,CAAC;IAClB,uQAAuQ;IACvQ,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,uGAAuG;IACvG,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA4B9E"}

package/dist/discovery/sandbox/config-wire.d.ts

@@ -39,8 +39,8 @@
  *
  * The one way to get there is `ChantConfigSchema`'s `.passthrough()`, which
  * accepts unknown extra keys of any type (that is how a lexicon extends the
- * config — `temporal:` in the temporal lexicon's `TemporalChantConfig`, itself
- * pure data). A project that parks a function under such a key gets a clear
+ * config — a lexicon's own namespace key, itself pure data). A project that
+ * parks a function under such a key gets a clear
  * error naming it, rather than a config that silently lost it.
  *
  * ## The one accepted lossy case: `undefined` object properties

package/dist/fold/foldable-helpers.d.ts

@@ -66,7 +66,11 @@
  *     `fold()` already rejects a nested `new Type(...)` used as a value for a
  *     real, differential-caught reason (the envelope leaks into
  *     serialization); a factory that returns one is the same hazard wearing a
- *     call.
+ *     call. Still true after #2171, which registered the ConvergeOp RULE
+ *     builders below. Those return plain data that an Op carries; `Op()`
+ *     itself returns the entity, and a top-level `export const x = Op({...})`
+ *     folds through the composite spine in `../discovery/fold-import.ts`
+ *     rather than through this list, which is why it needs no entry here.
  *   - `propagate()`, `withDefaults()`, `resource()`, `mergeDefaults()`
  *     (`../composite.ts`) are composite *definition* helpers, not value-position
  *     helpers. `propagate()` in particular mutates its argument in place, and

package/dist/fold/foldable-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foldable-helpers.d.ts","sourceRoot":"","sources":["../../src/fold/foldable-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,iBAAiB,EA0BlE,CAAC;AAIF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAeD,+FAA+F;AAC/F,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAIhE"}
+{"version":3,"file":"foldable-helpers.d.ts","sourceRoot":"","sources":["../../src/fold/foldable-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,iBAAiB,EAsGlE,CAAC;AAIF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAeD,+FAA+F;AAC/F,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAIhE"}

package/dist/fold-provenance.d.ts

@@ -0,0 +1,236 @@
+/**
+ * Fold provenance (#2161) — which composite parameter produced which emitted field.
+ *
+ * A composite is the one lossy thing chant emits. It takes a few typed
+ * arguments and expands to several resources, so a return leg that regenerates
+ * source from live produces flat typed resources and the composite is gone. The
+ * projection is not invertible from its output alone, which is the view-update
+ * problem landing on chant's record.
+ *
+ * chant can answer it where a general generator cannot, and for one reason: the
+ * evaluated subset is restricted on purpose. `discovery/fold-import.ts` already
+ * interprets an admissible factory body rather than calling it, so the
+ * expression each member property was WRITTEN as is in hand at build time. The
+ * same pass records where the field came from, in `discovery/param-deps.ts`'s
+ * {@link import("./discovery/param-deps.js").collectCompositeOrigins}.
+ *
+ * ## Four answers, and the fourth is a real one
+ *
+ * Every emitted path gets one of {@link FoldFieldOrigin}'s four kinds. Three of
+ * them are findings; `unknown` is the fourth, and it is a legal answer rather
+ * than a gap. A build that expanded a composite without interpreting its body
+ * (the run path, a factory outside the admissible subset, a sandboxed child
+ * whose provenance did not survive the wire) knows the field came from a
+ * composite and cannot say which parameter. Recording that is the whole point:
+ * an unknown must never fall through to `direct`, because `direct` licenses
+ * editing the field in the user's source and an unattributed composite field is
+ * exactly the case where that produces a flattened resource.
+ *
+ * `direct` is claimed only where the build has a provenance record AND that
+ * record says no composite expanded the entity. Absence of a record is
+ * `unknown`, never `direct`.
+ *
+ * ## Beside the output, never in it
+ *
+ * The record is build metadata, not declared configuration, and it must not
+ * reach the document an applier writes. It rides two channels, both outside the
+ * apply-bound document, and neither is a new mechanism:
+ *
+ *  - per entity, the non-enumerable symbol-keyed side channel `./provenance.ts`
+ *    already owns, invisible to every serializer and to every spread;
+ *  - per build, {@link import("./build.js").BuildResult.foldProvenance}, a sibling
+ *    of `buildParams` and `lexiconVersions`.
+ *
+ * Nothing is added to `SerializeContext`. That is the same posture
+ * `./effect-receipt.ts` takes at the same seam, one notch stricter: a receipt
+ * rides `SerializeContext.receipts` so a lexicon MAY render it outside
+ * `Resources`, whereas provenance has no rendering and is simply never handed
+ * to a serializer at all. `fold-provenance-exclusion.test.ts` drives a real
+ * build through a spy serializer and a mock applier to hold that line.
+ *
+ * ## The return leg
+ *
+ * {@link resolveDriftedField} is the consumer. #2160 has already ruled out the
+ * fields nobody declared, so a drifted field reaching it is one source actually
+ * declared, and the origin decides what may be proposed:
+ *
+ *  - a composite parameter: propose changing that parameter, naming the file,
+ *    the composite call and the parameter path. One line, composite intact.
+ *  - a literal the composite fixes: refuse by name. The choice is to
+ *    parameterize the field or stop using the composite there, and neither is
+ *    something chant may pick.
+ *  - a direct declaration: today's behaviour, unchanged.
+ *  - unknown: today's behaviour, and say that is what happened.
+ *
+ * Proposing is as far as this goes. Rewriting a parameter in the user's source
+ * is a source-edit problem (the generator half of `chant import` emits whole
+ * files and nothing maps a property path back to a location in a `.ts` file),
+ * so a proposal here is a described action: it names the file, the composite
+ * call and the parameter path, and performs no edit.
+ */
+import { type Declarable } from "./declarable.js";
+import { type EntityProvenance, type PathOrigin } from "./provenance.js";
+import type { DeepEntityDrift } from "./lifecycle/deep-diff.js";
+/** Why a field's origin could not be determined. Both are facts about the BUILD, not about the field. */
+export type UnknownOriginReason = 
+/**
+ * A composite expanded the entity and this build did not interpret its body,
+ * so parameter and fixed literal are indistinguishable. The run path, a
+ * factory outside `fold-import.ts`'s admissible subset, and a `propagate()`
+ * key both sides wrote all land here.
+ */
+"composite-not-interpreted"
+/**
+ * The build recorded no provenance for this entity at all, so not even "did a
+ * composite make it" is answerable. A sandboxed child's entities arrive this
+ * way: `discovery/entity-wire-codec.ts` drops build metadata over the wire.
+ */
+ | "no-provenance";
+/**
+ * What produced one emitted property path.
+ *
+ * The composite kinds carry `instance` — the export name every member of one
+ * composite call shares — because "the `AutoscaledService` composite" is not an
+ * address and "the `api` call of `AutoscaledService`" is.
+ */
+export type FoldFieldOrigin = {
+    kind: "composite-parameter";
+    composite: string;
+    instance?: string;
+    parameters: string[];
+} | {
+    kind: "composite-literal";
+    composite: string;
+    instance?: string;
+} | {
+    kind: "direct";
+} | {
+    kind: "unknown";
+    reason: UnknownOriginReason;
+};
+/** One entity's fold provenance: where it was declared, and an origin for every field it emits. */
+export interface EntityFoldProvenance {
+    /** The source file that declared the entity, when the build recorded one. */
+    sourceFile?: string;
+    /** The composite type that expanded it, when one did. */
+    composite?: string;
+    /** The composite call (export name) it belongs to, when one expanded it. */
+    instance?: string;
+    /**
+     * Emitted property path to origin, in sorted key order. Every path the entity
+     * emits is present: a path with no attribution carries an `unknown` origin
+     * rather than being left out, so a consumer iterating fields never has to
+     * decide what a missing key meant.
+     */
+    fields: Record<string, FoldFieldOrigin>;
+}
+/** A whole build's fold provenance, keyed by chant entity name. */
+export type FoldProvenance = Record<string, EntityFoldProvenance>;
+/**
+ * Every property path an entity's `props` emits, in `EntityProvenance.paths`'
+ * grammar: dotted names only, plain objects descended into, everything else
+ * attributed whole at its own path.
+ *
+ * Arrays are deliberately not indexed. An index-shaped key would not survive an
+ * element moving, and the recorder that produces origins cannot index either,
+ * so indexing here would manufacture paths nothing can ever attribute. The diff
+ * addresses array elements with `[#key]`/`[n]` and `originOfPath` resolves
+ * those against the dotted key that covers them, which is the join between the
+ * two grammars.
+ *
+ * An empty object is a value, and a leaf. An `undefined` value is not emitted
+ * and yields no path.
+ */
+export declare function emittedFieldPaths(props: unknown): string[];
+/**
+ * The four-way answer for one path, from the recorded {@link PathOrigin} and
+ * the entity's own provenance.
+ *
+ * `origin` is what {@link originOfPath} resolved for the path, so a coarse key
+ * recorded at an ancestor governs a leaf, exactly as it does everywhere else.
+ */
+export declare function classifyFieldOrigin(origin: PathOrigin | undefined, provenance: EntityProvenance | undefined): FoldFieldOrigin;
+/** One entity's fold provenance, or `undefined` when it emits no properties at all. */
+export declare function foldProvenanceOfEntity(entity: Declarable, provenance: EntityProvenance | undefined): EntityFoldProvenance | undefined;
+/**
+ * A whole build's fold provenance.
+ *
+ * `provenanceOf` is injected rather than read off the entity here so the same
+ * function serves a build (where it is `getProvenance`) and a test with a
+ * hand-written record. Entities with no properties are absent; sorted, because
+ * a build's outputs are compared byte for byte.
+ */
+export declare function foldProvenanceOfEntities(entities: ReadonlyMap<string, Declarable>, provenanceOf: (entity: Declarable) => EntityProvenance | undefined): FoldProvenance;
+/** One-line rendering of a field origin, for a report. */
+export declare function describeFoldFieldOrigin(origin: FoldFieldOrigin): string;
+/** Why an origin could not be determined, in words a report can print. */
+export declare function unknownOriginText(reason: UnknownOriginReason): string;
+/**
+ * What the return leg may do about one drifted field.
+ *
+ * Every arm is a DESCRIBED action. Nothing here edits a file, and
+ * `propose-parameter` deliberately stops at naming the edit: the source-edit
+ * half is the generator side of `chant import` and does not exist yet.
+ */
+export type DriftResolution = {
+    kind: "propose-parameter";
+    composite: string;
+    instance?: string;
+    sourceFile?: string;
+    /** The factory parameter paths that govern the field. */
+    parameters: string[];
+    description: string;
+} | {
+    kind: "refuse-fixed";
+    composite: string;
+    instance?: string;
+    sourceFile?: string;
+    description: string;
+} | {
+    kind: "edit-declaration";
+    sourceFile?: string;
+    description: string;
+} | {
+    kind: "fall-back";
+    reason: UnknownOriginReason;
+    sourceFile?: string;
+    description: string;
+};
+/** One drifted field and what may be done about it. */
+export interface FieldReconcile {
+    entity: string;
+    path: string;
+    declared?: unknown;
+    live?: unknown;
+    origin: FoldFieldOrigin;
+    resolution: DriftResolution;
+}
+/**
+ * Classify one drifted field by its origin.
+ *
+ * The caller has already established this is drift in #2160's sense: a path
+ * source declared, whose live value moved. Undeclared fields are held
+ * elsewhere and never reach here, so the only question left is which of the
+ * four origins produced the field.
+ */
+export declare function resolveDriftedField(input: {
+    entity: string;
+    path: string;
+    declared?: unknown;
+    live?: unknown;
+    origin?: PathOrigin;
+    provenance?: EntityProvenance;
+}): FieldReconcile;
+/**
+ * Every drifted field in a deep diff, classified.
+ *
+ * Reads `drifted` only. `unclaimed` is somebody else's field and
+ * `accepted` is a difference the baseline holds back, and neither may become an
+ * update, so neither is offered a resolution.
+ *
+ * A drift row of kind `absent` has no live value: the field is declared and the
+ * cloud does not have it. That is still drift on a declared path, and the same
+ * four origins decide what may be proposed about it.
+ */
+export declare function resolveDeepDrift(drifted: readonly DeepEntityDrift[], provenanceOf: (entity: string) => EntityProvenance | undefined): FieldReconcile[];
+//# sourceMappingURL=fold-provenance.d.ts.map

package/dist/fold-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold-provenance.d.ts","sourceRoot":"","sources":["../src/fold-provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAEH,OAAO,EAAwB,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAgB,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,uBAAuB,CAAC;AAE5E,yGAAyG;AACzG,MAAM,MAAM,mBAAmB;AAC7B;;;;;GAKG;AACD,2BAA2B;AAC7B;;;;GAIG;GACD,eAAe,CAAC;AAEpB;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,qBAAqB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GAC3F;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GACnE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAErD,mGAAmG;AACnG,MAAM,WAAW,oBAAoB;IACnC,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACzC;AAED,mEAAmE;AACnE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AASlE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAmB1D;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,UAAU,EAAE,gBAAgB,GAAG,SAAS,GACvC,eAAe,CA6BjB;AAED,uFAAuF;AACvF,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,gBAAgB,GAAG,SAAS,GACvC,oBAAoB,GAAG,SAAS,CAgBlC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,EACzC,YAAY,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,gBAAgB,GAAG,SAAS,GACjE,cAAc,CAQhB;AAED,0DAA0D;AAC1D,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAWvE;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAOrE;AAsBD;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,mBAAmB,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACtE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjG,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,eAAe,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B,GAAG,cAAc,CA2DjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,gBAAgB,GAAG,SAAS,GAC7D,cAAc,EAAE,CAkBlB"}

package/dist/graph-ops.d.ts

@@ -5,7 +5,7 @@ import type { Declarable } from "./declarable.js";
  * root beside `sourceDir: "src"`), and `chant op` / `chant graph` find them via
  * {@link discoverOps}, which scans from the git root. Join the two scopes: every
  * Op `discoverOps` finds that discovery did not already load becomes a
- * `Temporal::Op` entity in the map, keyed the way discovery keys a default
+ * `Chant::Op` entity in the map, keyed the way discovery keys a default
  * export (the file's basename sans `.op.ts`), so the IR carries the declared
  * DAG whatever the layout. Ops discovery already loaded (same file) are left
  * alone. Returns the op-discovery errors for the caller to surface.

package/dist/held-elsewhere.d.ts

@@ -0,0 +1,85 @@
+/**
+ * `heldElsewhere` — a typed, per-property declaration that a field belongs to
+ * something else once the first apply happens (chant #2162).
+ *
+ * An autoscaler owns a Deployment's `replicas` after the first apply. A
+ * controller writes an annotation on every sync. An operator was granted one
+ * knob deliberately. None of these are drift, and reconciling them back to
+ * whatever chant last declared would fight the thing that is actually
+ * supposed to own the field.
+ *
+ * Terraform's answer is `lifecycle { ignore_changes = [...] }`: a list of
+ * strings, carrying no reason, invisible once written. This is the typed
+ * alternative — a marker written where the property's value would go, so a
+ * lexicon's generated types check it the same way they check any other value,
+ * and it cannot be attached to a property that does not exist.
+ *
+ * This is not a suppression comment. `chant-ignore` (#2111) hides a *lint*
+ * finding about source; a `heldElsewhere` marker is a fact about who operates
+ * a field at *runtime*, so it lives in the typed declaration, where
+ * `chant lifecycle plan` and `chant lifecycle diff --live` can render it,
+ * rather than in a comment only a linter reads.
+ */
+/**
+ * Runtime-only marker, symbol-keyed so it never collides with a real
+ * property actually named `by` or `reason` and never serializes by accident
+ * through `JSON.stringify` or `Object.entries` (which do not visit symbol
+ * keys) — the two places a stray plain-object marker would otherwise leak
+ * into a snapshot or a wire payload unnoticed.
+ */
+export declare const HELD_ELSEWHERE_MARKER: unique symbol;
+export interface HeldElsewhereOptions {
+    /** Who holds the field at runtime — the autoscaler, the controller, the operator. Free text: whatever names the holder on this substrate ("hpa", "cluster-autoscaler", "the on-call operator who set this by hand"). */
+    by: string;
+    /** Why chant does not reconcile this field after the first apply. */
+    reason: string;
+}
+/** The runtime shape a `heldElsewhere()` call actually produces. */
+export interface HeldElsewhereMarker extends HeldElsewhereOptions {
+    readonly [HELD_ELSEWHERE_MARKER]: true;
+}
+/**
+ * Declare a property held by something else after the first apply.
+ *
+ * Typed `T` — the property's own declared type — rather than
+ * `HeldElsewhereMarker`, so it type-checks in exactly the position the
+ * property's real value would go: `replicas: heldElsewhere({ by: "hpa",
+ * reason: "the autoscaler owns replicas after the first apply" })` against a
+ * generated `replicas?: number` typechecks the same way `replicas: 3` does,
+ * and writing it against a property that does not exist on the resource's
+ * props is an excess-property error like any other.
+ *
+ * The runtime value is the marker object, not a `T` — this function tells
+ * TypeScript otherwise on purpose. Every consumer that must tell the two
+ * apart checks {@link isHeldElsewhere} before trusting a declared value's
+ * real shape: the synth-time serializer (`serializer-walker.ts`, which omits
+ * the field from the applied payload so the property is never sent — the
+ * provider defaults it once at creation, and the holder owns it from there)
+ * and the deep-diff declared side (`deep-observation.ts`/`deep-diff.ts`,
+ * which reports a live difference as held rather than as drift).
+ */
+export declare function heldElsewhere<T>(opts: HeldElsewhereOptions): T;
+/**
+ * True when `value` is a {@link HeldElsewhereMarker} — the runtime shape a
+ * `heldElsewhere()` call produces, wherever it ends up (a resource's own
+ * prop, nested inside a property-kind Declarable's props).
+ */
+export declare function isHeldElsewhere(value: unknown): value is HeldElsewhereMarker;
+/**
+ * JSON-safe tag a held marker normalizes to (see `deep-observation.ts`) so
+ * its identity survives normalization, `flattenDeepProperties`, and a
+ * `--json` round-trip. The symbol marker above does not serialize and
+ * `Object.entries` does not enumerate it, so without a JSON-safe stand-in the
+ * normalization pass would flatten `{ by, reason }` into two ordinary leaf
+ * paths instead of keeping the marker recognizable as one value.
+ */
+export declare const HELD_ELSEWHERE_TAG: "chant:heldElsewhere";
+/** The normalized, JSON-safe form of a {@link HeldElsewhereMarker}. */
+export interface NormalizedHeldElsewhere extends HeldElsewhereOptions {
+    readonly heldElsewhere: typeof HELD_ELSEWHERE_TAG;
+}
+/** Normalize a runtime marker to its JSON-safe tagged form. */
+export declare function normalizeHeldElsewhere(marker: HeldElsewhereMarker): NormalizedHeldElsewhere;
+/** True when `value` is the normalized, JSON-safe tagged form of a held marker. */
+export declare function isNormalizedHeldElsewhere(value: unknown): value is NormalizedHeldElsewhere;
+//# sourceMappingURL=held-elsewhere.d.ts.map

package/dist/held-elsewhere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"held-elsewhere.d.ts","sourceRoot":"","sources":["../src/held-elsewhere.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,eAAoC,CAAC;AAEvE,MAAM,WAAW,oBAAoB;IACnC,wNAAwN;IACxN,EAAE,EAAE,MAAM,CAAC;IACX,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,oEAAoE;AACpE,MAAM,WAAW,mBAAoB,SAAQ,oBAAoB;IAC/D,QAAQ,CAAC,CAAC,qBAAqB,CAAC,EAAE,IAAI,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,oBAAoB,GAAG,CAAC,CAO9D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAM5E;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAG,qBAA8B,CAAC;AAEjE,uEAAuE;AACvE,MAAM,WAAW,uBAAwB,SAAQ,oBAAoB;IACnE,QAAQ,CAAC,aAAa,EAAE,OAAO,kBAAkB,CAAC;CACnD;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,mBAAmB,GAAG,uBAAuB,CAE3F;AAED,mFAAmF;AACnF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,uBAAuB,CAM1F"}

package/dist/index.d.ts

@@ -4,6 +4,7 @@
  * Lexicon-agnostic declarative specification system
  */
 export * from "./declarable.js";
+export * from "./held-elsewhere.js";
 export * from "./composite.js";
 export * from "./provenance.js";
 export * from "./secret-provenance.js";
@@ -55,6 +56,8 @@ export * from "./observation.js";
 export * from "./identity.js";
 export * from "./apply.js";
 export * from "./deep-observation.js";
+export * from "./claimed-fields.js";
+export * from "./fold-provenance.js";
 export * from "./owner-chain.js";
 export * from "./lexicon-integrity.js";
 export * from "./lexicon-manifest.js";

package/dist/index.d.ts.map

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

package/dist/kubectl-context.d.ts

@@ -3,7 +3,7 @@
  *
  * Every cloud lexicon binds an environment to a scope: AWS resolves `<env>`
  * to a CloudFormation stack, Azure treats `<env>` as the resource group,
- * Temporal looks up `temporal.profiles.<env>` in `chant.config.ts`. K8s (and
+ * Fly resolves it to an app. K8s (and
  * GCP-via-Config-Connector, which observes through the same kubectl path)
  * bound nothing — `describeResources` shelled out to `kubectl get` with no
  * `--context`, so it read whatever cluster `kubectl config current-context`
@@ -78,8 +78,8 @@ export interface ResolveClusterTargetOptions {
  * Resolve the kubectl context an environment should be observed/applied
  * against, reading `k8s.profiles.<environment>.context` from `chant.config.ts`
  * (the `config` passed in is the passthrough `ChantConfig`, cast loosely since
- * the `k8s` key isn't declared on the core schema — same pattern as
- * `temporal.profiles`).
+ * the `k8s` key isn't declared on the core schema — the same pattern every
+ * lexicon namespace follows).
  *
  * - No binding declared: returns `{ source: "ambient" }` — unchanged
  *   behavior — but logs a visible warning identifying the caller and

package/dist/lexicon-config.d.ts

@@ -2,7 +2,7 @@
  * The config namespace a lexicon owns (#1344).
  *
  * Three lexicons read a top-level `chant.config.ts` key named after themselves —
- * `k8s.profiles.<env>.context`, `temporal.profiles`, `forgejo.runnerLabels` and
+ * `k8s.profiles.<env>.context`, `forgejo.runnerLabels` and
  * `forgejo.actionsRoot` — all documented for users, none declared anywhere.
  * `ChantConfigSchema` is `.passthrough()`, so at runtime any key is accepted and
  * a typo is silently ignored: write `runnerLabel` and the Forgejo dialect just
@@ -12,9 +12,9 @@
  *     error TS2353: Object literal may only specify known properties,
  *     and 'forgejo' does not exist in type 'ChantConfig'.
  *
- * Three lexicons had arrived at three different workarounds: temporal exported
- * its own widened `TemporalChantConfig`, k8s's docs dropped `satisfies`, and
- * forgejo's kept it and were wrong.
+ * The lexicons had arrived at different workarounds: one exported its own
+ * widened config type, k8s's docs dropped `satisfies`, and forgejo's kept it
+ * and were wrong.
  *
  * A lexicon now declares the shape of its namespace. The declaration is both
  * halves of the fix at once: core validates against it at load, and the lexicon

package/dist/lexicon-plugin-helpers.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shared helpers for lexicon plugin implementations.
  *
- * Eliminates boilerplate across the 8 lexicon plugins by providing
+ * Eliminates boilerplate across the 15 lexicon plugins that use it by providing
  * factory functions for common plugin methods: skills loading,
  * MCP diff tool, and MCP catalog resource.
  */