@intentius/chant 0.124.13 → 0.124.15

package/dist/fold-provenance.js

@@ -0,0 +1,414 @@
+/**
+ * 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 { isResourceDeclarable } from "./declarable.js";
+import { relative, isAbsolute } from "node:path";
+import { originOfPath, } from "./provenance.js";
+/** True for an ordinary `{}`, false for an array, a class instance, an `AttrRef`. */
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * 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 function emittedFieldPaths(props) {
+    const out = [];
+    const walk = (value, prefix) => {
+        if (value === undefined)
+            return;
+        if (isPlainObject(value)) {
+            const keys = Object.keys(value).sort();
+            if (keys.length === 0) {
+                if (prefix)
+                    out.push(prefix);
+                return;
+            }
+            for (const key of keys)
+                walk(value[key], prefix ? `${prefix}.${key}` : key);
+            return;
+        }
+        if (prefix)
+            out.push(prefix);
+    };
+    walk(props, "");
+    return out;
+}
+/**
+ * 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 function classifyFieldOrigin(origin, provenance) {
+    if (!provenance)
+        return { kind: "unknown", reason: "no-provenance" };
+    const instance = provenance.compositeInstance;
+    const call = provenance.compositeCall;
+    switch (origin?.kind) {
+        case "composite-parameter":
+            return {
+                kind: "composite-parameter",
+                composite: origin.composite,
+                ...(instance ? { instance } : {}),
+                parameters: [...origin.parameters],
+                ...(call ? { call: { ...call } } : {}),
+                ...(origin.arguments ? { arguments: origin.arguments.map((a) => ({ ...a })) } : {}),
+            };
+        case "composite-literal":
+            return {
+                kind: "composite-literal",
+                composite: origin.composite,
+                ...(instance ? { instance } : {}),
+                ...(call ? { call: { ...call } } : {}),
+            };
+        case "composite":
+            // The coarse kind: a composite expanded this, and nothing said which
+            // parameter. Not a parameter, not a fixed literal, and above all not a
+            // direct declaration.
+            return { kind: "unknown", reason: "composite-not-interpreted" };
+        case "authored":
+            // chant#3608 — `authored` is the file's own root record, and it reaches
+            // a path only when nothing finer did. On an entity a composite wrote (a
+            // member destructured from a composite the fold invoked) that means the
+            // fold could not attribute the path, which is `unknown`, never `direct`.
+            return provenance.composite
+                ? { kind: "unknown", reason: "composite-not-interpreted" }
+                : { kind: "direct" };
+        case "host":
+            // INTENTIUS/typescript-as-data#248 — host code produced the value, so
+            // editing the declaration edits a call, not the value it returned.
+            return { kind: "unknown", reason: origin.reason };
+        case "build-param":
+            // A build parameter governs the expression the AUTHOR wrote in their own
+            // source, so the declaration is still theirs to edit.
+            return { kind: "direct" };
+        case undefined:
+            return provenance.composite
+                ? { kind: "unknown", reason: "composite-not-interpreted" }
+                : { kind: "direct" };
+    }
+}
+/** One entity's fold provenance, or `undefined` when it emits no properties at all. */
+export function foldProvenanceOfEntity(entity, provenance) {
+    if (!isResourceDeclarable(entity))
+        return undefined;
+    const paths = emittedFieldPaths(entity.props);
+    if (paths.length === 0)
+        return undefined;
+    const fields = {};
+    for (const path of paths) {
+        fields[path] = classifyFieldOrigin(originOfPath(provenance?.paths, path), provenance);
+    }
+    return {
+        ...(provenance?.sourceFile ? { sourceFile: provenance.sourceFile } : {}),
+        ...(provenance?.composite ? { composite: provenance.composite } : {}),
+        ...(provenance?.compositeInstance ? { instance: provenance.compositeInstance } : {}),
+        ...(provenance?.compositeCall ? { compositeCall: { ...provenance.compositeCall } } : {}),
+        fields,
+    };
+}
+/**
+ * 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 function foldProvenanceOfEntities(entities, provenanceOf) {
+    const out = {};
+    for (const name of [...entities.keys()].sort()) {
+        const entity = entities.get(name);
+        const record = foldProvenanceOfEntity(entity, provenanceOf(entity));
+        if (record)
+            out[name] = record;
+    }
+    return out;
+}
+/** One-line rendering of a field origin, for a report. */
+export function describeFoldFieldOrigin(origin) {
+    switch (origin.kind) {
+        case "composite-parameter":
+            return `parameter ${origin.parameters.join(", ")} of ${compositeCall(origin.composite, origin.instance)}`;
+        case "composite-literal":
+            return `fixed by ${compositeCall(origin.composite, origin.instance)}`;
+        case "direct":
+            return "declared directly";
+        case "unknown":
+            return `origin unknown (${unknownOriginText(origin.reason)})`;
+    }
+}
+/** Why an origin could not be determined, in words a report can print. */
+export function unknownOriginText(reason) {
+    switch (reason) {
+        case "composite-not-interpreted":
+            return "expanded by a composite whose factory this build did not interpret";
+        case "no-provenance":
+            return "this build recorded no provenance for the entity";
+        case "host-call":
+            return "the value is what a host call returned";
+        case "host-value":
+            return "the value is one a host package exports";
+    }
+}
+/** `AutoscaledService composite call \`api\``, or just the composite when the call has no name. */
+function compositeCall(composite, instance) {
+    return instance ? `the \`${instance}\` call of composite ${composite}` : `composite ${composite}`;
+}
+/** A file as a report prints it: relative to `root` when it is inside it, otherwise as recorded. */
+function displayFile(file, root) {
+    if (!root || !isAbsolute(file))
+        return file;
+    const rel = relative(root, file);
+    return rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : file;
+}
+/** `src/app.ts:12`, relative to `root` when it is inside it. */
+export function formatSourceLocation(location, root) {
+    return `${displayFile(location.file, root)}:${location.line}`;
+}
+/** ` in src/app.infra.ts`, or nothing when the build recorded no file. */
+function inFile(sourceFile, root) {
+    return sourceFile ? ` in ${displayFile(sourceFile, root)}` : "";
+}
+/**
+ * The composite call as the author wrote the arguments that govern a field:
+ * `WebApp({ replicas: 3 })`, or `WebApp({ iam: { path: "/service/" } })` for a
+ * nested parameter. Only arguments actually written at the call appear; when
+ * none is, the call is shown as `WebApp(...)`.
+ */
+export function describeCompositeArguments(composite, locations) {
+    const written = locations.filter((a) => a.text !== undefined);
+    if (written.length === 0)
+        return `${composite}(...)`;
+    const parts = written.map((a) => {
+        const outer = a.parameter.split(".").slice(0, -1);
+        return outer.reduceRight((inner, key) => `${key}: { ${inner} }`, a.text);
+    });
+    return `${composite}({ ${parts.join(", ")} })`;
+}
+/**
+ * Where a composite-parameter field was set, as `at src/app.ts:12`: the first
+ * argument written at the call, else the call, else the declaring file.
+ */
+function parameterSite(origin, sourceFile, root) {
+    const written = origin.arguments?.find((a) => a.text !== undefined);
+    const location = written ?? origin.call ?? origin.arguments?.[0];
+    if (location)
+        return ` at ${formatSourceLocation(location, root)}`;
+    return inFile(sourceFile, root);
+}
+/** ` at src/app.ts:10` for the composite call, else the declaring file. */
+function callSite(call, sourceFile, root) {
+    return call ? ` at ${formatSourceLocation(call, root)}` : inFile(sourceFile, root);
+}
+/** A value as a report prints it. */
+function renderValue(value) {
+    if (value === undefined)
+        return "unset";
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/**
+ * 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.
+ *
+ * `entityType` names the resource in the summary line, and `root` (the
+ * project directory) makes the file names in it relative. Both are optional;
+ * without them the summary uses the entity name alone and absolute files.
+ */
+export function resolveDriftedField(input) {
+    const origin = classifyFieldOrigin(input.origin, input.provenance);
+    const sourceFile = input.provenance?.sourceFile;
+    const root = input.root;
+    const move = `${renderValue(input.declared)} to ${renderValue(input.live)}`;
+    const subject = `${input.path} on ${input.entityType ? `${input.entityType} ` : ""}${input.entity}`;
+    const summary = (() => {
+        switch (origin.kind) {
+            case "composite-parameter":
+                return (`${subject} comes from ${describeCompositeArguments(origin.composite, origin.arguments ?? [])}` +
+                    `${parameterSite(origin, sourceFile, root)}` +
+                    (origin.arguments?.some((a) => a.text !== undefined)
+                        ? ""
+                        : ` (parameter ${origin.parameters.join(", ")}, not written at the call)`));
+            case "composite-literal":
+                return (`${subject} is fixed inside composite ${origin.composite}; ` +
+                    `no argument to the call${callSite(origin.call, sourceFile, root)} moves it`);
+            case "direct":
+                return `${subject} is declared directly${inFile(sourceFile, root)}`;
+            case "unknown":
+                return `${subject} has an unknown origin: ${unknownOriginText(origin.reason)}`;
+        }
+    })();
+    const resolution = (() => {
+        switch (origin.kind) {
+            case "composite-parameter": {
+                const parameters = origin.parameters;
+                return {
+                    kind: "propose-parameter",
+                    composite: origin.composite,
+                    ...(origin.instance ? { instance: origin.instance } : {}),
+                    ...(sourceFile ? { sourceFile } : {}),
+                    parameters: [...parameters],
+                    description: `change ${parameters.length === 1 ? "parameter" : "parameters"} ` +
+                        `${parameters.map((p) => `\`${p}\``).join(", ")} of ` +
+                        `${compositeCall(origin.composite, origin.instance)}${parameterSite(origin, sourceFile, root)} ` +
+                        `so \`${input.path}\` moves from ${move}. The composite stays.`,
+                };
+            }
+            case "composite-literal":
+                return {
+                    kind: "refuse-fixed",
+                    composite: origin.composite,
+                    ...(origin.instance ? { instance: origin.instance } : {}),
+                    ...(sourceFile ? { sourceFile } : {}),
+                    description: `refused: \`${input.path}\` is fixed by ${compositeCall(origin.composite, origin.instance)}` +
+                        `${callSite(origin.call, sourceFile, root)}, so no argument at the call site moves it. ` +
+                        `Parameterize the field in composite ${origin.composite}, or stop using the composite here.`,
+                };
+            case "direct":
+                return {
+                    kind: "edit-declaration",
+                    ...(sourceFile ? { sourceFile } : {}),
+                    description: `change the declared value of \`${input.path}\`${inFile(sourceFile, root)} from ${move}.`,
+                };
+            case "unknown":
+                return {
+                    kind: "fall-back",
+                    reason: origin.reason,
+                    ...(sourceFile ? { sourceFile } : {}),
+                    description: `origin unknown (${unknownOriginText(origin.reason)}), so falling back to changing the ` +
+                        `declared value of \`${input.path}\`${inFile(sourceFile, root)} from ${move}.`,
+                };
+        }
+    })();
+    return {
+        entity: input.entity,
+        path: input.path,
+        ...("declared" in input ? { declared: input.declared } : {}),
+        ...("live" in input ? { live: input.live } : {}),
+        origin,
+        summary,
+        resolution,
+    };
+}
+/**
+ * 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 function resolveDeepDrift(drifted, provenanceOf, options = {}) {
+    const out = [];
+    for (const entity of drifted) {
+        const provenance = provenanceOf(entity.name);
+        for (const change of entity.changes) {
+            out.push(resolveDriftedField({
+                entity: entity.name,
+                entityType: entity.type,
+                path: change.path,
+                ...("declared" in change ? { declared: change.declared } : {}),
+                ...("live" in change ? { live: change.live } : {}),
+                ...(change.origin ? { origin: change.origin } : {}),
+                ...(provenance ? { provenance } : {}),
+                ...(options.root ? { root: options.root } : {}),
+            }));
+        }
+    }
+    return out;
+}

package/dist/gate-decision.d.ts

@@ -18,8 +18,9 @@
  *
  * A gate the declaration at base names under `identity.gates` counts only a
  * sealed approval from its class: {@link identityGateAdmissionAt} reads that
- * rule from a bare clone at base and judges by `admitApprover`, the function
- * chant's `gateAdmission` judges by (#3862); pass its `refuses` to
+ * rule from a bare clone at base, with the principal classes the pinned
+ * packages supply read as data (#3888), and judges by `admitApprover`, the
+ * function chant's `gateAdmission` judges by (#3862); pass its `refuses` to
  * {@link decideGateApproval}.
  *
  * With `spend` (#3784), an approval a wave already applied under is spent and
@@ -27,8 +28,9 @@
  * the lines of `_gates/<op>/applied.jsonl` ({@link parseAppliedGateLines}).
  *
  * The module reads the ledger lines and the review it is handed; reading
- * them is the caller's. It imports no TypeScript, esbuild, zod, lint, fold or
- * codegen module, and none of chant's git ledger code, which
+ * them is the caller's. It imports no TypeScript, esbuild, zod, ajv, lint,
+ * fold or codegen module, no package's code, and none of chant's git ledger
+ * code, which
  * `gate-decision-bundle.test.ts` holds it to. Its rules are chant's own:
  * `./lifecycle/gate-ledger-select.ts` is what `evaluateGate` decides by, and
  * `gate-decision.test.ts` decides the same ledgers both ways.
@@ -90,15 +92,24 @@ export interface IdentityGateAdmission {
  * class, the role grants in `.chant/trust.json` at base put the approver in
  * it. Both judge with the same function ({@link admitApprover}).
  *
- * The classes are the four core ones, then `classes`, the domain classes the
- * caller read from the pinned packages (`./workspace-principals`), in pin
- * order. This reader loads no package. A gate whose class is in neither
- * refuses every approval, and when the declaration at base pins anything the
- * reason says the pins were not read, since one of them may supply it.
+ * The classes are the four core ones, then the domain classes the
+ * declaration's pins supply, in pin order (#3888), read as chant reads them:
+ * a path pin's `./workspace-principals` file at `base`, and a package pin's
+ * from the package installed under `packages` (default `repo`) at the
+ * pinned version. A bare clone has no `node_modules`, so a caller that reads
+ * one passes the directory its packages are installed under. Only data is
+ * read; no package is imported. `classes`, when given, stands for every
+ * domain class instead and no pin is read.
+ *
+ * When a pin can't be read (its package is not installed, or not at the
+ * pinned version), a gate whose class it could change (a domain class, or
+ * `human`) refuses every approval and says which pins were not read; a gate
+ * naming `agent`, `runner` or `service`, or no class, is judged as usual.
  * Throws when the declaration at base cannot be parsed.
  */
 export declare function identityGateAdmissionAt(repo: string, base: string, gate: string, opts?: {
     classes?: readonly ClassGrant[];
+    packages?: string;
 }): IdentityGateAdmission | null;
 /** What a pull request's review says about a wave, under `pr-review`. */
 export interface ReviewApproval {

package/dist/gate-decision.d.ts.map

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