@beehexa/hexasync-template-context 2608.15.1

package/dist/shape.d.ts

@@ -0,0 +1,68 @@
+/**
+ * What an author may legally reference at one caret — and nothing else.
+ *
+ * ### Why a shape rather than a list of strings
+ *
+ * Four surfaces answer *"what can this path be"* — completion, hover, diagnostics and the agent tool — and every one
+ * of them needs a different slice of the same answer: completion needs the keys, hover needs the provenance,
+ * diagnostics needs to know a path is absent, and the agent needs the whole thing as data. A list of strings serves
+ * the first and lies to the other three.
+ *
+ * ⛔ **`unknown` carries its reason.** G-8: an alphabet the engine could not enumerate is stated, never silently
+ * empty. The distinction is the whole difference between *"this transformation contributes no fields"* and *"this
+ * transformation is a `SELECT *` and its fields cannot be known from the document"* — the first invites an author to
+ * stop looking, the second tells them where to look. Measured: `SELECT *` is 4.3% of authored SQL (210 of 4,832
+ * blocks), so the unknown case is the exception that must be visible, not the default that can be ignored.
+ */
+export type ShapeKind = 'object' | 'array' | 'scalar' | 'unknown';
+/** Where a field came from, so hover can say it and an author can go read it. */
+export type Provenance = {
+    readonly kind: 'column';
+    readonly table?: string;
+    readonly dataType?: string;
+} | {
+    readonly kind: 'transformation';
+    readonly type: string;
+    readonly index: number;
+} | {
+    readonly kind: 'step';
+    readonly stepKey: string;
+    readonly phase?: string;
+} | {
+    readonly kind: 'hint';
+    readonly declaredOn?: string;
+} | {
+    readonly kind: 'builtin';
+    readonly note?: string;
+};
+export interface Shape {
+    readonly kind: ShapeKind;
+    /** Present on `object`: the fields, by name. */
+    readonly fields?: ReadonlyMap<string, Field>;
+    /** Present on `array`: the shape of one element, so `[0].` resolves. */
+    readonly element?: Shape;
+    /**
+     * Present on `unknown`, ALWAYS — G-8. A shape that cannot say why it is unknown is indistinguishable from a bug in
+     * the engine, and an author reading "unknown" with no reason learns nothing they did not already know.
+     */
+    readonly reason?: string;
+    /** Present on `scalar` where the document declares one: `string`, `number`, `boolean`, `date`… */
+    readonly scalarType?: string;
+}
+export interface Field {
+    readonly name: string;
+    readonly shape: Shape;
+    readonly provenance: Provenance;
+    /** The author-facing prose, where the document carries any — a column description, a step's own docs. */
+    readonly description?: string;
+}
+export declare const objectShape: (fields: Iterable<Field>) => Shape;
+export declare const arrayShape: (element: Shape) => Shape;
+export declare const scalarShape: (scalarType?: string) => Shape;
+/**
+ * ⛔ The reason is REQUIRED by the signature, not by a convention. An optional reason is one a caller forgets, and
+ * the forgetting is invisible: the shape still reads `unknown` and the surface still renders it.
+ */
+export declare const unknownShape: (reason: string) => Shape;
+export declare const field: (name: string, shape: Shape, provenance: Provenance, description?: string) => Field;
+//# sourceMappingURL=shape.d.ts.map

package/dist/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../src/shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAElE,iFAAiF;AACjF,MAAM,MAAM,UAAU,GAClB;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,gDAAgD;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC7C,wEAAwE;IACxE,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC;IACzB;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,kGAAkG;IAClG,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,yGAAyG;IACzG,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,eAAO,MAAM,WAAW,GAAI,QAAQ,QAAQ,CAAC,KAAK,CAAC,KAAG,KAGpD,CAAC;AAEH,eAAO,MAAM,UAAU,GAAI,SAAS,KAAK,KAAG,KAG1C,CAAC;AAEH,eAAO,MAAM,WAAW,GAAI,aAAa,MAAM,KAAG,KAGd,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,KAAG,KAG5C,CAAC;AAEH,eAAO,MAAM,KAAK,GAChB,MAAM,MAAM,EACZ,OAAO,KAAK,EACZ,YAAY,UAAU,EACtB,cAAc,MAAM,KACnB,KAG2C,CAAC"}

package/dist/shape.js

@@ -0,0 +1,23 @@
+export const objectShape = (fields) => ({
+    kind: 'object',
+    fields: new Map([...fields].map((field) => [field.name, field])),
+});
+export const arrayShape = (element) => ({
+    kind: 'array',
+    element,
+});
+export const scalarShape = (scalarType) => scalarType === undefined
+    ? { kind: 'scalar' }
+    : { kind: 'scalar', scalarType };
+/**
+ * ⛔ The reason is REQUIRED by the signature, not by a convention. An optional reason is one a caller forgets, and
+ * the forgetting is invisible: the shape still reads `unknown` and the surface still renders it.
+ */
+export const unknownShape = (reason) => ({
+    kind: 'unknown',
+    reason,
+});
+export const field = (name, shape, provenance, description) => description === undefined
+    ? { name, shape, provenance }
+    : { name, shape, provenance, description };
+//# sourceMappingURL=shape.js.map

package/dist/shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","sourceRoot":"","sources":["../src/shape.ts"],"names":[],"mappings":"AAyDA,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,MAAuB,EAAS,EAAE,CAAC,CAAC;IAC9D,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;CACjE,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,OAAc,EAAS,EAAE,CAAC,CAAC;IACpD,IAAI,EAAE,OAAO;IACb,OAAO;CACR,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,UAAmB,EAAS,EAAE,CACxD,UAAU,KAAK,SAAS;IACtB,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE;IACpB,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;AAErC;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAc,EAAS,EAAE,CAAC,CAAC;IACtD,IAAI,EAAE,SAAS;IACf,MAAM;CACP,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,IAAY,EACZ,KAAY,EACZ,UAAsB,EACtB,WAAoB,EACb,EAAE,CACT,WAAW,KAAK,SAAS;IACvB,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;IAC7B,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC"}

package/dist/stepOutputs.d.ts

@@ -0,0 +1,52 @@
+import { type Field, type Shape } from './shape.js';
+/**
+ * A step's own outputs are EXACTLY its response-filter keys — `CONTEXT-MODEL.md` §7.
+ *
+ * This is the fact that makes `puller.current.STEP_X.<field>` exact rather than heuristic:
+ * `ResponseFilterEngine.HandleResponse` merges every engine block's parsed output into one flat result, so the step's
+ * output key set is the union of the keys across its four engine blocks — written in the same file, twenty lines
+ * above the caret.
+ *
+ * ⛔ **Engine order is fixed and asymmetric.** Non-scriban engines run first, in declaration order, each merged into
+ * `filters.<engine>.<key>`; **scriban always runs last**. So a scriban expression may read `filters.jsonata.items` —
+ * the corpus does — while a jsonata expression may only read an engine declared before it. Getting this backwards
+ * would offer an author a `filters.*` path that is empty at the moment their expression runs.
+ */
+export declare const ENGINES: readonly ["jsonata", "jsonpath", "xpath", "scriban"];
+export type Engine = (typeof ENGINES)[number];
+/** Scriban last, everything else in declaration order. The ordering rule, as data. */
+export declare function engineOrder(declared: readonly string[]): readonly string[];
+/**
+ * The literal keys of a JSONata object constructor, and whether it yields an array.
+ *
+ * Measured: **34 of 54** authored `Jsonata` blocks (62%) are object constructors with literal keys, and a trailing
+ * `[]` forces an array. So `$.{ "id": id, "order_id": orderId }[]` fully determines
+ * `…PULL_DATA.items[0].order_id` — the path the corpus actually uses.
+ *
+ * ⚠️ Deliberately shallow: it reads the literal keys of ONE constructor, and makes no attempt to evaluate the
+ * expressions behind them. A key whose value is itself a constructor resolves to `unknown` with its reason, which is
+ * the honest answer — the alternative is a parser for a language we do not own.
+ */
+export declare function jsonataShape(expression: string): Shape | undefined;
+export interface StepOutputs {
+    /** The step's own output keys, merged across engines — what `…current.STEP_X.` offers. */
+    readonly shape: Shape;
+    /** `filters.<engine>.<key>`, available only INSIDE a response filter. */
+    readonly filters: Field;
+    /** Keys declared in more than one engine block. Last writer wins, silently — §7. */
+    readonly collisions: readonly {
+        readonly key: string;
+        readonly engines: readonly string[];
+    }[];
+}
+/**
+ * Read one step's `responseFilters` into the shapes four surfaces need.
+ *
+ * ⛔ `collisions` is not a nicety. `results.Merge` is last-writer-wins, so a key declared in two engine blocks
+ * silently loses one of its two values — a diagnostic nobody has today (Story 8.6), and it can only be seen by
+ * comparing the blocks, which is what this does once for everyone.
+ */
+export declare function stepOutputs(step: unknown): StepOutputs;
+/** The response headers, a root available only inside a response filter. */
+export declare const HEADERS_ROOT: Field;
+//# sourceMappingURL=stepOutputs.d.ts.map

package/dist/stepOutputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepOutputs.d.ts","sourceRoot":"","sources":["../src/stepOutputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,KAAK,EACV,KAAK,KAAK,EACX,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,sDAAuD,CAAC;AAC5E,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9C,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAG1E;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CA2BlE;AAED,MAAM,WAAW,WAAW;IAC1B,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB,oFAAoF;IACpF,QAAQ,CAAC,UAAU,EAAE,SAAS;QAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;KACrC,EAAE,CAAC;CACL;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,WAAW,CA4EtD;AAED,4EAA4E;AAC5E,eAAO,MAAM,YAAY,OAMxB,CAAC"}

package/dist/stepOutputs.js

@@ -0,0 +1,102 @@
+import { arrayShape, field, objectShape, unknownShape, } from './shape.js';
+/**
+ * A step's own outputs are EXACTLY its response-filter keys — `CONTEXT-MODEL.md` §7.
+ *
+ * This is the fact that makes `puller.current.STEP_X.<field>` exact rather than heuristic:
+ * `ResponseFilterEngine.HandleResponse` merges every engine block's parsed output into one flat result, so the step's
+ * output key set is the union of the keys across its four engine blocks — written in the same file, twenty lines
+ * above the caret.
+ *
+ * ⛔ **Engine order is fixed and asymmetric.** Non-scriban engines run first, in declaration order, each merged into
+ * `filters.<engine>.<key>`; **scriban always runs last**. So a scriban expression may read `filters.jsonata.items` —
+ * the corpus does — while a jsonata expression may only read an engine declared before it. Getting this backwards
+ * would offer an author a `filters.*` path that is empty at the moment their expression runs.
+ */
+export const ENGINES = ['jsonata', 'jsonpath', 'xpath', 'scriban'];
+/** Scriban last, everything else in declaration order. The ordering rule, as data. */
+export function engineOrder(declared) {
+    const nonScriban = declared.filter((engine) => engine !== 'scriban');
+    return declared.includes('scriban') ? [...nonScriban, 'scriban'] : nonScriban;
+}
+const record = (value) => typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? value
+    : undefined;
+/**
+ * The literal keys of a JSONata object constructor, and whether it yields an array.
+ *
+ * Measured: **34 of 54** authored `Jsonata` blocks (62%) are object constructors with literal keys, and a trailing
+ * `[]` forces an array. So `$.{ "id": id, "order_id": orderId }[]` fully determines
+ * `…PULL_DATA.items[0].order_id` — the path the corpus actually uses.
+ *
+ * ⚠️ Deliberately shallow: it reads the literal keys of ONE constructor, and makes no attempt to evaluate the
+ * expressions behind them. A key whose value is itself a constructor resolves to `unknown` with its reason, which is
+ * the honest answer — the alternative is a parser for a language we do not own.
+ */
+export function jsonataShape(expression) {
+    const open = expression.indexOf('{');
+    if (open === -1)
+        return undefined;
+    const close = expression.lastIndexOf('}');
+    if (close <= open)
+        return undefined;
+    const body = expression.slice(open + 1, close);
+    const keys = [...body.matchAll(/"([^"]+)"\s*:/g)].map((match) => match[1]);
+    if (keys.length === 0)
+        return undefined;
+    const shape = objectShape(keys.map((key) => field(key, unknownShape('A JSONata expression — its key is declared here, its value is computed at run time.'), {
+        kind: 'builtin',
+    })));
+    // A trailing `[]` after the constructor forces an array, which is what gives the path its index.
+    return /\}\s*\[\s*\]\s*;?\s*$/.test(expression.trimEnd())
+        ? arrayShape(shape)
+        : shape;
+}
+/**
+ * Read one step's `responseFilters` into the shapes four surfaces need.
+ *
+ * ⛔ `collisions` is not a nicety. `results.Merge` is last-writer-wins, so a key declared in two engine blocks
+ * silently loses one of its two values — a diagnostic nobody has today (Story 8.6), and it can only be seen by
+ * comparing the blocks, which is what this does once for everyone.
+ */
+export function stepOutputs(step) {
+    const filters = record(record(step)?.['responseFilters']);
+    const declared = Object.keys(filters ?? {}).filter((name) => ENGINES.includes(name));
+    const perEngine = new Map();
+    const owners = new Map();
+    for (const engine of engineOrder(declared)) {
+        const block = record(filters?.[engine]);
+        const keys = new Map();
+        for (const [key, value] of Object.entries(block ?? {})) {
+            const expression = record(value)?.['expression'];
+            const shape = engine === 'jsonata' && typeof expression === 'string'
+                ? (jsonataShape(expression) ??
+                    unknownShape(`\`${key}\` is a JSONata expression that is not an object constructor, so its keys are computed at run time.`))
+                : unknownShape(`\`${key}\` is produced by a ${engine} expression, so its shape is not declared in this document.`);
+            keys.set(key, shape);
+            owners.set(key, [...(owners.get(key) ?? []), engine]);
+        }
+        perEngine.set(engine, keys);
+    }
+    const merged = [];
+    for (const [engine, keys] of perEngine) {
+        for (const [key, shape] of keys) {
+            merged.push(field(key, shape, { kind: 'step', stepKey: key }, `From the ${engine} block.`));
+        }
+    }
+    return {
+        shape: merged.length > 0
+            ? objectShape(merged)
+            : unknownShape('This step declares no response filters, so its output keys are not in this document.'),
+        filters: field('filters', objectShape([...perEngine].map(([engine, keys]) => field(engine, objectShape([...keys].map(([key, shape]) => field(key, shape, { kind: 'step', stepKey: key }))), { kind: 'builtin', note: `The ${engine} block's own results.` }))), {
+            kind: 'builtin',
+            note: 'Available only inside a response filter. Non-scriban engines run first in declaration order; scriban ' +
+                'always runs last, so only scriban can read every other engine.',
+        }),
+        collisions: [...owners]
+            .filter(([, engines]) => engines.length > 1)
+            .map(([key, engines]) => ({ key, engines })),
+    };
+}
+/** The response headers, a root available only inside a response filter. */
+export const HEADERS_ROOT = field('__headers', unknownShape("The response's headers, keyed as the source system returned them."), { kind: 'builtin' });
+//# sourceMappingURL=stepOutputs.js.map

package/dist/stepOutputs.js.map

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

package/dist/survival.d.ts

@@ -0,0 +1,47 @@
+import type { Shape } from './shape.js';
+/**
+ * Fields that will not survive the pull — Story 8.7.
+ *
+ * A puller can produce a field the task has no column for. It is written into the raw payload and it is readable
+ * there, so nothing fails — until someone tries to reference it as a column, or a customer asks why it is missing
+ * from the destination. The author learns this the slow way today.
+ *
+ * ⚠️ The finding is *"this survives only inside the raw payload"*, not *"this is wrong"*. Pulling a field you do not
+ * store is a legitimate choice — it may exist to be read by a transformation in the same run. What is never
+ * legitimate is believing it became a column.
+ */
+export interface SurvivalFinding {
+    readonly field: string;
+    readonly reason: string;
+    /** The fix an editor can offer: the column this field would need. */
+    readonly addColumn?: {
+        readonly table: string;
+        readonly name: string;
+        readonly dataType: string;
+    };
+}
+/**
+ * Compare what a puller produces against the columns its task declares.
+ *
+ * `produced` is the union of the puller's step output keys — Story 8.3 derives it — and `columns` is what
+ * `tables[*].columns` declares. A produced key with no column survives only in `__raw`.
+ */
+export declare function fieldsThatWillNotSurvive(input: {
+    readonly produced: readonly string[];
+    readonly columns: readonly string[];
+    readonly table?: string;
+}): readonly SurvivalFinding[];
+/**
+ * A validation naming a field that is HINTED rather than declared — Story 8.7 AC-3.
+ *
+ * ⛔ A validation cannot address a non-column at all. `BuildConditionsAsync` interpolates the field name directly
+ * into SQL against the task's table, so a hinted field produces a query naming a column that does not exist; and
+ * `ValidateAsync` does a flat `TryGetValue`, which reports *"the field is missing from the item"*. Two halves, two
+ * different failures, neither of them a message that points at the real cause.
+ */
+export declare function validationAgainstNonColumn(input: {
+    readonly fieldName: string;
+    readonly columns: readonly string[];
+    readonly item?: Shape;
+}): SurvivalFinding | undefined;
+//# sourceMappingURL=survival.d.ts.map

package/dist/survival.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"survival.d.ts","sourceRoot":"","sources":["../src/survival.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,SAAS,eAAe,EAAE,CAiB7B;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;CACvB,GAAG,eAAe,GAAG,SAAS,CAsB9B"}

package/dist/survival.js

@@ -0,0 +1,50 @@
+/**
+ * Compare what a puller produces against the columns its task declares.
+ *
+ * `produced` is the union of the puller's step output keys — Story 8.3 derives it — and `columns` is what
+ * `tables[*].columns` declares. A produced key with no column survives only in `__raw`.
+ */
+export function fieldsThatWillNotSurvive(input) {
+    const declared = new Set(input.columns);
+    return (input.produced
+        // ⛔ A `__`-prefixed key is the platform's own — `__raw`, `__headers`, `__last_seen`. Reporting those would fire
+        // on every puller in the corpus and teach an author to ignore the whole class.
+        .filter((name) => !declared.has(name) && !name.startsWith('__'))
+        .map((name) => ({
+        field: name,
+        reason: `\`${name}\` is pulled but has no column on this task, so it survives only inside the raw payload. A ` +
+            'transformation in the same run can read it; a validation cannot, and it will never reach the destination.',
+        ...(input.table === undefined
+            ? {}
+            : { addColumn: { table: input.table, name, dataType: 'text' } }),
+    })));
+}
+/**
+ * A validation naming a field that is HINTED rather than declared — Story 8.7 AC-3.
+ *
+ * ⛔ A validation cannot address a non-column at all. `BuildConditionsAsync` interpolates the field name directly
+ * into SQL against the task's table, so a hinted field produces a query naming a column that does not exist; and
+ * `ValidateAsync` does a flat `TryGetValue`, which reports *"the field is missing from the item"*. Two halves, two
+ * different failures, neither of them a message that points at the real cause.
+ */
+export function validationAgainstNonColumn(input) {
+    if (input.columns.includes(input.fieldName))
+        return undefined;
+    const known = input.item?.kind === 'object'
+        ? input.item.fields?.get(input.fieldName)
+        : undefined;
+    if (!known)
+        return undefined; // Not a column and not on the item either — Story 8.6's rule owns that case.
+    const source = known.provenance.kind === 'hint'
+        ? 'declared as a data hint'
+        : known.provenance.kind === 'transformation'
+            ? `produced by the ${known.provenance.type} transformation at index ${known.provenance.index}`
+            : 'not a column';
+    return {
+        field: input.fieldName,
+        reason: `\`${input.fieldName}\` is ${source}, not a column on this task. A validation's field is interpolated ` +
+            'directly into SQL against the table, so this names a column that does not exist — and the item lookup is ' +
+            'flat, so it reports "the field is missing" rather than pointing here.',
+    };
+}
+//# sourceMappingURL=survival.js.map

package/dist/survival.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"survival.js","sourceRoot":"","sources":["../src/survival.ts"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAIxC;IACC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACxC,OAAO,CACL,KAAK,CAAC,QAAQ;QACZ,gHAAgH;QAChH,+EAA+E;SAC9E,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SAC/D,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACd,KAAK,EAAE,IAAI;QACX,MAAM,EACJ,KAAK,IAAI,6FAA6F;YACtG,2GAA2G;QAC7G,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS;YAC3B,CAAC,CAAC,EAAE;YACJ,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;KACnE,CAAC,CAAC,CACN,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CAAC,KAI1C;IACC,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC;QAAE,OAAO,SAAS,CAAC;IAE9D,MAAM,KAAK,GACT,KAAK,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ;QAC3B,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC;QACzC,CAAC,CAAC,SAAS,CAAC;IAChB,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC,CAAC,6EAA6E;IAE3G,MAAM,MAAM,GACV,KAAK,CAAC,UAAU,CAAC,IAAI,KAAK,MAAM;QAC9B,CAAC,CAAC,yBAAyB;QAC3B,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,KAAK,gBAAgB;YAC1C,CAAC,CAAC,mBAAmB,KAAK,CAAC,UAAU,CAAC,IAAI,4BAA4B,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE;YAC9F,CAAC,CAAC,cAAc,CAAC;IACvB,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,SAAS;QACtB,MAAM,EACJ,KAAK,KAAK,CAAC,SAAS,SAAS,MAAM,oEAAoE;YACvG,2GAA2G;YAC3G,uEAAuE;KAC1E,CAAC;AACJ,CAAC"}

package/dist/walk.d.ts

@@ -0,0 +1,36 @@
+/**
+ * One walk over a composed component's steps, yielding every context finding in it — Story 8.13.
+ *
+ * ### Why this exists rather than living in the rule
+ *
+ * Story 8.6 measured `checkPath` and `unknownStepKey` against the corpus from a walk written inside its own spec, and
+ * Story 8.13 needs the same walk inside a validation rule. Two walks would be two chances to disagree about which
+ * stage key a pusher uses or where a webhook keeps its steps — and the 8.6 measurement had **exactly that bug**: it
+ * special-cased only `current` for pushers, so `pusher.before.*` was checked against `beforePullSteps`, a key a pusher
+ * does not have. It surfaced as 84 false findings the moment the rule widened.
+ *
+ * So the walk is here, both callers use it, and the corpus parity in 8.13 is structural rather than re-asserted.
+ */
+import { type ReferenceFinding } from './references.js';
+/** The four context phases, and the stage key each one is spelled with per collection. */
+export declare const PHASE_STAGE: Readonly<Record<'pullers' | 'pushers', Readonly<Record<string, string>>>>;
+export type ContextRuleId = 'root-has-no-child' | 'unknown-step-key';
+export interface ContextFinding extends ReferenceFinding {
+    /** Which of the two checks produced it, so a caller can choose a severity per rule. */
+    readonly rule: ContextRuleId;
+    /** The phase whose steps were being read, for the message and for locating the step. */
+    readonly phase: string;
+    /** The step the expression was authored in. `(step)` when the key is absent or not a scalar. */
+    readonly stepKey: string;
+    readonly stepIndex: number;
+}
+/**
+ * Every context finding in one component.
+ *
+ * ⚠️ Silent about two things by design, and the silences are load-bearing: an unknown ROOT may be a local variable or
+ * a loop binding, and a segment deeper than the step key may be composed at run time. A rule that reported those
+ * would fire on nearly every template in the corpus and be switched off within a day, taking the real findings with
+ * it.
+ */
+export declare function contextFindingsFor(component: unknown, collection: 'pullers' | 'pushers'): readonly ContextFinding[];
+//# sourceMappingURL=walk.d.ts.map

package/dist/walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../src/walk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAKL,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC;AAIzB,0FAA0F;AAC1F,eAAO,MAAM,WAAW,EAAE,QAAQ,CAChC,MAAM,CAAC,SAAS,GAAG,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CA4BhE,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG,kBAAkB,CAAC;AAErE,MAAM,WAAW,cAAe,SAAQ,gBAAgB;IACtD,uFAAuF;IACvF,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,wFAAwF;IACxF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gGAAgG;IAChG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAQD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,SAAS,GAAG,SAAS,GAChC,SAAS,cAAc,EAAE,CAmH3B"}

package/dist/walk.js

@@ -0,0 +1,162 @@
+/**
+ * One walk over a composed component's steps, yielding every context finding in it — Story 8.13.
+ *
+ * ### Why this exists rather than living in the rule
+ *
+ * Story 8.6 measured `checkPath` and `unknownStepKey` against the corpus from a walk written inside its own spec, and
+ * Story 8.13 needs the same walk inside a validation rule. Two walks would be two chances to disagree about which
+ * stage key a pusher uses or where a webhook keeps its steps — and the 8.6 measurement had **exactly that bug**: it
+ * special-cased only `current` for pushers, so `pusher.before.*` was checked against `beforePullSteps`, a key a pusher
+ * does not have. It surfaced as 84 false findings the moment the rule widened.
+ *
+ * So the walk is here, both callers use it, and the corpus parity in 8.13 is structural rather than re-asserted.
+ */
+import { checkPath, expressionsIn, pathsIn, unknownStepKey, } from './references.js';
+import { resolveEnvironment, stepFactsFrom } from './environment.js';
+import { isNewKindPuller } from './detect.js';
+/** The four context phases, and the stage key each one is spelled with per collection. */
+export const PHASE_STAGE = {
+    pullers: {
+        before: 'beforePullSteps',
+        current: 'pullSteps',
+        after: 'afterPullSteps',
+        final: 'finalSteps',
+    },
+    /**
+     * ⛔ A pusher spells its phases `…PushSteps`. Measured 2026-08-14 across the corpus, counting KEY-LINE OCCURRENCES
+     * (`grep -rhoE '^\s+[a-zA-Z]+Steps:'`, which counts a key once per authored and per composed file):
+     * `beforePushSteps` 1,688 · `afterPushSteps` 1,654 · `pushSteps` 1,941.
+     *
+     * ⚠️ The BASIS matters and was missing when these were first recorded. Counting distinct components that declare
+     * the array instead gives ~1,612 / 1,625 / 1,939, and the Epic 8 review re-derived the occurrence figures as
+     * 1,661 / 1,630 / 1,914 with a slightly different expression — three methods, three answers, all defensible. The
+     * numbers are here to show the two spellings are of the same order, nothing finer; do not treat a small drift as
+     * a regression without re-running the exact command above.
+     *
+     * `finalSteps` appears **nowhere**, in either collection, on every method — so `final` is an empty phase by
+     * construction rather than by accident. That is the load-bearing part, and it is the one that reproduces exactly.
+     */
+    pushers: {
+        before: 'beforePushSteps',
+        current: 'pushSteps',
+        after: 'afterPushSteps',
+        final: 'finalSteps',
+    },
+};
+const arrayAt = (value, key) => {
+    const holder = value;
+    const at = holder?.[key];
+    return Array.isArray(at) ? at : [];
+};
+/**
+ * Every context finding in one component.
+ *
+ * ⚠️ Silent about two things by design, and the silences are load-bearing: an unknown ROOT may be a local variable or
+ * a loop binding, and a segment deeper than the step key may be composed at run time. A rule that reported those
+ * would fire on nearly every template in the corpus and be switched off within a day, taking the real findings with
+ * it.
+ */
+export function contextFindingsFor(component, collection) {
+    const holder = component;
+    if (!holder || typeof holder !== 'object')
+        return [];
+    const stages = PHASE_STAGE[collection];
+    const newKind = collection === 'pullers' && isNewKindPuller(holder);
+    const phases = {};
+    for (const phase of Object.keys(stages)) {
+        phases[phase] = arrayAt(holder, stages[phase]).map((step) => stepFactsFrom(step));
+    }
+    const keysByPhase = Object.fromEntries(Object.keys(stages).map((phase) => [
+        phase,
+        phases[phase].map((facts) => facts.key),
+    ]));
+    const position = (collection === 'pushers'
+        ? 'pusher-step'
+        : newKind
+            ? 'new-kind-puller-step'
+            : 'legacy-puller-step');
+    const findings = [];
+    for (const phase of Object.keys(stages)) {
+        arrayAt(holder, stages[phase]).forEach((step, stepIndex) => {
+            const environment = resolveEnvironment({
+                position,
+                component: { collection, hasStepsArray: newKind, phases },
+                phase,
+                stepIndex,
+            });
+            const raw = step?.['key'];
+            const stepKey = typeof raw === 'string' || typeof raw === 'number'
+                ? String(raw)
+                : '(step)';
+            /**
+             * ⛔ A step that will not serialize must not silence the whole family.
+             *
+             * `JSON.stringify` throws on a cyclic object, and `runValidation` swallows a throwing rule with a
+             * `console.warn` — so ONE such component would discard every CTX finding in the project, including the good
+             * ones already computed. The `yaml` parser does build cyclic objects from a recursive anchor
+             * (`a: &x { self: *x }`) and the cycle survives the CLI's parse/stringify round trip, so this is reachable
+             * rather than theoretical, even though no corpus file uses anchors today. Skipping one step is a bounded loss;
+             * losing the rule is not.
+             */
+            let serialized;
+            try {
+                serialized = JSON.stringify(step) ?? '';
+            }
+            catch {
+                return;
+            }
+            const seen = new Set();
+            for (const expression of expressionsIn(serialized)) {
+                for (const path of pathsIn(expression)) {
+                    /**
+                     * ⛔ Deduplicated PER STEP. One authored expression is commonly repeated across a step's fields — the
+                     * corpus's worst case reads the same broken watermark path seven times in one step — and seven identical
+                     * findings on one line is a report an author scrolls past. The measurement counts occurrences; a report
+                     * addresses lines.
+                     */
+                    if (seen.has(path))
+                        continue;
+                    seen.add(path);
+                    const rootFinding = checkPath(path, environment);
+                    if (rootFinding) {
+                        findings.push({
+                            ...rootFinding,
+                            rule: 'root-has-no-child',
+                            phase,
+                            stepKey,
+                            stepIndex,
+                        });
+                        continue;
+                    }
+                    /**
+                     * ⛔ The step-key check runs ONLY under a root this position actually has.
+                     *
+                     * `unknownStepKey` matches the segment name (`current`, `history`, …) wherever it appears; it does not
+                     * know whose context it is in. So a NEW-KIND puller — which shares no `puller.*` root at all (§3) —
+                     * produced `current has no step called X` for a path whose real problem is that `puller` does not exist
+                     * there. The corpus reported 0 such findings, which read like proof and was luck: no new-kind component
+                     * in it happens to carry a stale `puller.*` path. A unit test found it in one run.
+                     *
+                     * An unknown root stays SILENT rather than becoming a finding of its own — it may be a local variable or
+                     * a loop binding, which is the same reason `checkPath` leaves it alone.
+                     */
+                    const root = path.split('.')[0];
+                    if (!root || !environment.roots.has(root))
+                        continue;
+                    const stepFinding = unknownStepKey(path, keysByPhase);
+                    if (stepFinding) {
+                        findings.push({
+                            ...stepFinding,
+                            rule: 'unknown-step-key',
+                            phase,
+                            stepKey,
+                            stepIndex,
+                        });
+                    }
+                }
+            }
+        });
+    }
+    return findings;
+}
+//# sourceMappingURL=walk.js.map

package/dist/walk.js.map

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

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@beehexa/hexasync-template-context",
+  "version": "2608.15.1",
+  "description": "The authoring context engine — given a component and a caret, what an author may legally reference.",
+  "license": "SEE LICENSE IN ../../LICENSE",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "hexasync": {
+    "layer": "core"
+  },
+  "devDependencies": {
+    "yaml": "^2.8.0"
+  }
+}