@telorun/analyzer 0.65.0 → 0.66.0

package/dist/schema-projection.d.ts.map

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

package/dist/schema-projection.js

@@ -34,6 +34,7 @@
  * row shape lives in one instance's own `columns:`, which no definition-level
  * derivation can reach.
  */
+import { isRefSentinel } from "@telorun/templating";
 function isObject(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -55,6 +56,20 @@ export function readSchemaProjection(definition) {
         nameField: typeof raw.name === "string" ? raw.name : undefined,
         nullable: typeof raw.nullable === "string" ? raw.nullable : undefined,
         array: typeof raw.array === "string" ? raw.array : undefined,
+        reference: readProjectionReference(raw.reference),
+    };
+}
+function readProjectionReference(raw) {
+    if (!isObject(raw))
+        return undefined;
+    const { from, keyword, base, baseFrom } = raw;
+    if (typeof from !== "string" || typeof keyword !== "string")
+        return undefined;
+    return {
+        from,
+        keyword,
+        base: isObject(base) ? base : undefined,
+        baseFrom: typeof baseFrom === "string" ? baseFrom : undefined,
     };
 }
 /** The annotation as written, from either position — the document (canonical)
@@ -79,7 +94,37 @@ export function schemaProjectionIsMisplaced(definition) {
     const schema = definition.schema;
     return isObject(schema) && schema["x-telo-schema-projection"] !== undefined;
 }
+/**
+ * The schema node that CARRIES the value vocabulary — the node itself, or the
+ * branch of a union that declares the map.
+ *
+ * A slot unioning a closed value vocabulary with a reference keeps its map on the
+ * value branch, exactly as the ref-slot reader peels the same union for its
+ * constraint. Exported because the strict half checks the map against the same
+ * branch's `enum`, and two implementations of "which branch is the value one"
+ * would eventually disagree — silently, since the failure of missing one is a
+ * completeness check that quietly stops running.
+ */
+export function schemaMapBranch(node) {
+    if (!isObject(node))
+        return undefined;
+    if (node["x-telo-schema-map"] !== undefined)
+        return node;
+    for (const key of ["oneOf", "anyOf"]) {
+        const branches = node[key];
+        if (!Array.isArray(branches))
+            continue;
+        for (const branch of branches) {
+            if (isObject(branch) && branch["x-telo-schema-map"] !== undefined)
+                return branch;
+        }
+    }
+    return undefined;
+}
 export function readSchemaMap(node) {
+    return ownSchemaMap(schemaMapBranch(node));
+}
+function ownSchemaMap(node) {
     if (!isObject(node))
         return undefined;
     const raw = node["x-telo-schema-map"];
@@ -134,6 +179,66 @@ export function projectionKeyMap(kindSchema, projection) {
         return undefined;
     return readSchemaMap(entry.properties[projection.key]);
 }
+/**
+ * The node an entry whose keyed field holds a REFERENCE projects to.
+ *
+ * This is the one place a projection crosses to another declaration, and it is
+ * a deliberate exception to the projection's lossiness: length, precision and
+ * collation stop at the boundary because the database enforces them, while a
+ * domain crosses because it IS the type at the granularity a consumer acts on —
+ * the enum in a CRUD model's OpenAPI operation, a completion list in the editor,
+ * a filter a repository can reject before the query.
+ *
+ * **A reference that cannot be read projects OPEN, never to nothing**, and that
+ * is the opposite of the rule an unmapped VALUE follows. The two failures are
+ * not the same failure: an unmapped value is a gap in the kind's own vocabulary,
+ * so there is no entry to speak of, while an unreadable reference names an entry
+ * the declaration plainly HAS and only leaves its type unknown. Dropping it made
+ * the projection deny the entry exists — a table whose enum reference had a typo
+ * reported `'status' is not allowed` against a column declared three lines up,
+ * blaming the seed row for the reference's mistake. Open is the honest
+ * under-approximation, and the reason is reported alongside.
+ */
+function referencedNode(value, entryName, projection, map, options) {
+    const reference = projection.reference;
+    if (!reference || !isObject(value))
+        return undefined;
+    // Through the single reader, so the name in the diagnostic is the one the
+    // author wrote whichever shape the slot holds — reading `value.name` here
+    // reported `<unnamed>` for an unresolved `!ref`, which is precisely the case
+    // that produces the diagnostic.
+    const name = readProjectionRef(value)?.name ?? "<unnamed>";
+    const report = () => {
+        options?.failures?.push({
+            reason: "entry-reference",
+            // The EMPTY pointer means the projected declaration is the one carrying
+            // the diagnostic, so the entry's own path is a real anchor in that file —
+            // the column, not the document root. Any other pointer names a slot
+            // holding a reference to a DIFFERENT manifest, whose entry paths mean
+            // nothing here, so the slot stays the anchor.
+            pointer: options?.pointer === ""
+                ? `${projection.entries}/${entryName}`
+                : (options?.pointer ?? projection.entries),
+            entry: entryName,
+            name,
+        });
+        return {};
+    };
+    const found = options?.scope?.resolveManifest(value);
+    if (!found || "ambiguous" in found)
+        return report();
+    const values = found.manifest[reference.from];
+    if (!Array.isArray(values) || values.length === 0)
+        return report();
+    let base = reference.base;
+    if (reference.baseFrom !== undefined) {
+        const declared = found.manifest[reference.baseFrom];
+        base = typeof declared === "string" ? map[declared] : undefined;
+    }
+    if (!base)
+        return report();
+    return { ...base, [reference.keyword]: values };
+}
 /**
  * Project one declaration to an object schema.
  *
@@ -148,7 +253,12 @@ export function projectionKeyMap(kindSchema, projection) {
  * enough to double as a validator would move the domain's semantics into the
  * type layer.
  */
-export function projectEntries(manifest, projection, map) {
+export function projectEntries(manifest, projection, map, 
+/** What a REFERENCE at the keyed field is resolved through, and where a
+ *  failure to resolve one is reported. A caller with no scope cannot resolve
+ *  one, so such an entry projects OPEN — present, untyped — rather than
+ *  vanishing from the row. */
+options) {
     const entries = navigate(manifest, projection.entries);
     if (entries === undefined)
         return undefined;
@@ -157,7 +267,9 @@ export function projectEntries(manifest, projection, map) {
         if (!isObject(entry) || name === undefined)
             return;
         const key = entry[projection.key];
-        const mapped = typeof key === "string" ? map[key] : undefined;
+        const mapped = typeof key === "string"
+            ? map[key]
+            : referencedNode(key, name, projection, map, options);
         // A value with no map entry projects to nothing rather than to `any`: the
         // vocabulary is the kind's own enum, so an unmapped value is a gap in the
         // kind's declaration, not a shape to guess at.
@@ -193,11 +305,26 @@ export function projectEntries(manifest, projection, map) {
         additionalProperties: false,
     };
 }
-/** The `{kind, name, alias?}` reference a value holds, or undefined. Exported so
- *  a host whose slot may hold EITHER shape can fall back to this reading. */
+/**
+ * The `{kind, name, alias?}` reference a value holds, or undefined. Exported so
+ * a host whose slot may hold EITHER shape can fall back to this reading.
+ *
+ * The unresolved `!ref` SENTINEL is read too. `resolveRefSentinels` normally
+ * rewrites one before this pass, but not when the reference names nothing — and
+ * that is exactly when a projection failure is reported, so reading only the
+ * resolved shape made the diagnostic name the target `<unnamed>`, which is the
+ * one fact the author needed from it. A round-trip host (`compile` off) carries
+ * the sentinel for every reference, resolved or not.
+ */
 export function readProjectionRef(value) {
     if (!isObject(value))
         return undefined;
+    if (isRefSentinel(value)) {
+        const dot = value.source.indexOf(".");
+        return dot > 0
+            ? { name: value.source.slice(dot + 1), alias: value.source.slice(0, dot) }
+            : { name: value.source };
+    }
     const name = value.name;
     if (typeof name !== "string")
         return undefined;
@@ -258,10 +385,22 @@ function refTarget(value, scope, pointer) {
         return { reason: "no-projection", pointer, kind: manifest.kind };
     return { manifest, definition };
 }
+/** The declaration the annotation is written on, as a projection target. */
+function ownTarget(manifest, scope) {
+    if (typeof manifest.kind !== "string") {
+        return { reason: "no-ref", pointer: "" };
+    }
+    const definition = scope.resolveDefinition(manifest.kind);
+    if (!definition)
+        return { reason: "no-projection", pointer: "", kind: manifest.kind };
+    return { manifest, definition };
+}
 export function describeProjectionFailure(failure) {
     switch (failure.reason) {
         case "no-ref":
-            return `'${failure.pointer}' does not hold a reference, so there is no declaration to project.`;
+            return failure.pointer === ""
+                ? "this resource declares no 'kind:', so there is no definition to project it through."
+                : `'${failure.pointer}' does not hold a reference, so there is no declaration to project.`;
         case "unresolved":
             return `'${failure.pointer}' references '${failure.name}', which resolves to no resource.`;
         case "ambiguous":
@@ -270,6 +409,17 @@ export function describeProjectionFailure(failure) {
         case "no-projection":
             return (`'${failure.pointer}' references a resource of kind '${failure.kind}', which declares no ` +
                 `'x-telo-schema-projection' — so there is nothing for this slot to be typed from.`);
+        case "no-projection-map":
+            return (`kind '${failure.kind}' declares an 'x-telo-schema-projection' whose key field carries ` +
+                `no 'x-telo-schema-map', so there is no vocabulary to project its entries through and ` +
+                `'${failure.pointer || "this declaration"}' cannot be typed from it.`);
+        case "no-entries":
+            return (`'${failure.entries}' holds no entry collection on this ${failure.kind}, so the ` +
+                `projection has nothing to type '${failure.pointer || "this declaration"}' from.`);
+        case "entry-reference":
+            return (`entry '${failure.entry}' at '${failure.pointer}' references '${failure.name}', which ` +
+                `resolves to no declaration this analysis can read — so that entry is projected as an ` +
+                `open value and nothing typed from it is checked against the shape it was meant to have.`);
     }
 }
 /**
@@ -282,36 +432,74 @@ export function describeProjectionFailure(failure) {
  * `failures`, because degrading SILENTLY is the failure this whole mechanism
  * exists to move earlier: the consumer's contract quietly reopens and a
  * misspelled field passes `telo check` exactly as it did before.
+ *
+ * **A node that projected NOTHING is returned by IDENTITY**, and that is a
+ * correctness property of the caller rather than a micro-optimization:
+ * `DefinitionRegistry` memoizes a compiled AJV validator per schema OBJECT,
+ * because every resource of a kind is checked against the same one at keystroke
+ * time. Rebuilding each node unconditionally — which this did — misses that memo
+ * for every resource in the analysis, so AJV recompiled the whole kind schema
+ * once per resource: on `apps/hub` that was 197 compiles instead of 54, and 723
+ * ms instead of 97. Returning the input where nothing changed restores it for
+ * every kind that declares no projection at all, which is nearly all of them.
  */
 export function resolveSchemaProjections(schema, manifest, scope, failures) {
     if (Array.isArray(schema)) {
-        return schema.map((item) => resolveSchemaProjections(item, manifest, scope, failures));
+        let moved = false;
+        const items = schema.map((item) => {
+            const next = resolveSchemaProjections(item, manifest, scope, failures);
+            if (next !== item)
+                moved = true;
+            return next;
+        });
+        return moved ? items : schema;
     }
     if (!isObject(schema))
         return schema;
     const pointer = readProjectionFrom(schema);
-    if (pointer && manifest) {
-        const target = refTarget(navigate(manifest, pointer), scope, pointer);
+    if (pointer !== undefined && manifest) {
+        // The EMPTY pointer names the declaration this annotation is written on,
+        // rather than a slot holding a reference to another. Resolution is skipped
+        // because the declaration is already in hand — which is what lets a kind
+        // type its own data against its own entries (a table's seed rows against its
+        // columns), something no reference could reach.
+        const target = pointer === ""
+            ? ownTarget(manifest, scope)
+            : refTarget(navigate(manifest, pointer), scope, pointer);
         if ("reason" in target) {
             failures?.push(target);
         }
         else {
+            const kind = String(target.manifest.kind ?? "<unknown>");
             const projection = readSchemaProjection(target.definition);
             const map = projection && projectionKeyMap(target.definition.schema, projection);
-            const projected = projection && map ? projectEntries(target.manifest, projection, map) : undefined;
+            const projected = projection && map
+                ? projectEntries(target.manifest, projection, map, { scope, pointer, failures })
+                : undefined;
             if (projected) {
                 const { ["x-telo-schema-projection-from"]: _dropped, ...rest } = schema;
                 return { ...rest, ...projected };
             }
-            failures?.push({
-                reason: "no-projection",
-                pointer,
-                kind: String(target.manifest.kind ?? "<unknown>"),
-            });
+            // Three distinct omissions, three repairs by three different authors: the
+            // kind declares no projection, the kind declares one the key field has no
+            // vocabulary for, or this DECLARATION simply lists no entries.
+            if (!projection)
+                failures?.push({ reason: "no-projection", pointer, kind });
+            else if (!map)
+                failures?.push({ reason: "no-projection-map", pointer, kind });
+            else {
+                failures?.push({ reason: "no-entries", pointer, kind, entries: projection.entries });
+            }
         }
     }
-    return Object.fromEntries(Object.entries(schema).map(([key, value]) => [
-        key,
-        key.startsWith("x-telo-") ? value : resolveSchemaProjections(value, manifest, scope, failures),
-    ]));
+    let moved = false;
+    const entries = Object.entries(schema).map(([key, value]) => {
+        const next = key.startsWith("x-telo-")
+            ? value
+            : resolveSchemaProjections(value, manifest, scope, failures);
+        if (next !== value)
+            moved = true;
+        return [key, next];
+    });
+    return moved ? Object.fromEntries(entries) : schema;
 }

package/dist/telo-version.d.ts

@@ -1,3 +1,3 @@
 /** The surface generation this analyzer implements. */
-export declare const TELO_SURFACE_VERSION = "0.82.0";
+export declare const TELO_SURFACE_VERSION = "0.82.1";
 //# sourceMappingURL=telo-version.d.ts.map

package/dist/telo-version.js

@@ -5,4 +5,4 @@
 // its release identity, this is the scale a module's `requires.telo` range is
 // written against, and every kernel in every language reports the same scale.
 /** The surface generation this analyzer implements. */
-export const TELO_SURFACE_VERSION = "0.82.0";
+export const TELO_SURFACE_VERSION = "0.82.1";

package/dist/validate-cel-context.d.ts

@@ -1,4 +1,5 @@
 export { extractAccessChains, validateChainAgainstSchema } from "@telorun/templating";
+export { extractCelRegionScopes, pathMatchesScope } from "./eval-paths.js";
 export interface ContextResolveOpts {
     /** When provided, used to resolve `x-telo-context-from-root` annotations against the
      *  root manifest. When omitted, defaults to `manifestItem`. */
@@ -15,14 +16,6 @@ export interface ContextResolveOpts {
     allManifests?: Record<string, any>[];
 }
 export declare function resolveTypeFieldToSchema(value: unknown, allManifests: Record<string, any>[], ancestry?: ReadonlySet<string>): Record<string, any> | undefined;
-/**
- * Returns true when a CEL expression path (from walkCelExpressions, e.g. "routes[0].inputs.q")
- * falls within the scope of a context (e.g. "$.routes[*].inputs").
- *
- * The scope is matched directly (no sibling sharing): a context at "$.routes[*].inputs" only
- * applies to expressions whose path starts with "routes[N].inputs", not to other sibling fields.
- */
-export declare function pathMatchesScope(exprPath: string, scope: string): boolean;
 /**
  * Resolves `x-telo-context-*` annotations in a context schema using the concrete
  * manifest item (per-scope) and the manifest root.
@@ -91,13 +84,4 @@ export declare function extractContextsFromSchema(schema: Record<string, any>, p
     scope: string;
     schema: Record<string, any>;
 }>;
-/**
- * Walk a JSON Schema tree and collect the JSONPath scopes of every field that
- * declares a CEL-bearing region (`x-telo-context` / `x-telo-step-context` /
- * `x-telo-error-context`). Used — alongside `x-telo-eval` paths — to decide
- * whether a `!cel` expression sits in a slot the runtime actually evaluates.
- * Scopes use the same `$.a.b[*]` form as `extractContextsFromSchema`, matched
- * against expression paths with `pathMatchesScope`.
- */
-export declare function extractCelRegionScopes(schema: Record<string, any>, path?: string): string[];
 //# sourceMappingURL=validate-cel-context.d.ts.map

package/dist/validate-cel-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-cel-context.d.ts","sourceRoot":"","sources":["../src/validate-cel-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAWtF,MAAM,WAAW,kBAAkB;IACjC;mEAC+D;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnC;;kDAE8C;IAC9C,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;KACxD,CAAC;IACF,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;KAC/C,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;CACtC;AA4CD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EACnC,QAAQ,GAAE,WAAW,CAAC,MAAM,CAAa,GACxC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CA0EjC;AAyID;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAoBzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjC,IAAI,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAChD,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAyKrB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQrB;AAWD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,IAAI,SAAM,GACT,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC,CAGvD;AAYD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,SAAM,GAAG,MAAM,EAAE,CAqBxF"}
+{"version":3,"file":"validate-cel-context.d.ts","sourceRoot":"","sources":["../src/validate-cel-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAatF,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAG3E,MAAM,WAAW,kBAAkB;IACjC;mEAC+D;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnC;;kDAE8C;IAC9C,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;KACxD,CAAC;IACF,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;KAC/C,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;CACtC;AA4CD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EACnC,QAAQ,GAAE,WAAW,CAAC,MAAM,CAAa,GACxC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CA0EjC;AAyID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjC,IAAI,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAChD,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAyKrB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQrB;AAWD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,IAAI,SAAM,GACT,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC,CAGvD"}

package/dist/validate-cel-context.js

@@ -1,8 +1,12 @@
 export { extractAccessChains, validateChainAgainstSchema } from "@telorun/templating";
 import { elementSchemaOf, isLiveSlot, mergeTypeSchemas, parseCanonicalTypeSchemaId, } from "@telorun/sdk";
 import { KERNEL_BUILTINS } from "./builtins.js";
-import { isStepSlot } from "./step-slot.js";
 import { withRefSlotsAsReadings } from "./ref-slot-reading.js";
+// Where CEL is evaluated is one reader (`eval-paths.ts`), and the region half of
+// it moved there so the scope walk and the `x-telo-eval` walk answer the same
+// question in one place. Re-exported: this module is where every existing
+// consumer imports them from.
+export { extractCelRegionScopes, pathMatchesScope } from "./eval-paths.js";
 /**
  * Resolve a type field value (string name, inline type, or raw schema) to a JSON Schema.
  * - String: look up the named type in allManifests (Type.JsonSchema resources)
@@ -229,36 +233,6 @@ function collectionBindingWithheld(schema, manifestRoot, allManifests) {
         return false;
     return isLiveSlot(resolveCollectionSchema(manifestRoot, from, allManifests));
 }
-/**
- * Returns true when a CEL expression path (from walkCelExpressions, e.g. "routes[0].inputs.q")
- * falls within the scope of a context (e.g. "$.routes[*].inputs").
- *
- * The scope is matched directly (no sibling sharing): a context at "$.routes[*].inputs" only
- * applies to expressions whose path starts with "routes[N].inputs", not to other sibling fields.
- */
-export function pathMatchesScope(exprPath, scope) {
-    const stripped = scope.startsWith("$.") ? scope.slice(2) : scope;
-    if (!stripped)
-        return false;
-    // Split on wildcard array segments; each [*] must match a concrete [N] in exprPath
-    const parts = stripped.split("[*]");
-    let remaining = exprPath;
-    for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        if (!remaining.startsWith(part))
-            return false;
-        remaining = remaining.slice(part.length);
-        if (i < parts.length - 1) {
-            // Expect a concrete array index like [0], [12], ...
-            const m = remaining.match(/^\[\d+\]/);
-            if (!m)
-                return false;
-            remaining = remaining.slice(m[0].length);
-        }
-    }
-    // Expression must end here or continue into a child path
-    return remaining === "" || remaining[0] === "." || remaining[0] === "[";
-}
 /**
  * Resolves `x-telo-context-*` annotations in a context schema using the concrete
  * manifest item (per-scope) and the manifest root.
@@ -496,45 +470,6 @@ export function extractContextsFromSchema(schema, path = "$") {
     const all = collectContexts(schema, path);
     return all.sort((a, b) => b.scope.length - a.scope.length);
 }
-/** Schema keys that declare a CEL-bearing region: a field carrying any of these
- *  is evaluated at runtime, so a `!cel` inside it (or a descendant) is live. A
- *  STEP BODY is one too, and says so through the grammar its items point at
- *  rather than through a key — {@link isStepSlot} reads either spelling. */
-const CEL_REGION_KEYS = [
-    "x-telo-context",
-    "x-telo-step-context",
-    "x-telo-error-context",
-];
-/**
- * Walk a JSON Schema tree and collect the JSONPath scopes of every field that
- * declares a CEL-bearing region (`x-telo-context` / `x-telo-step-context` /
- * `x-telo-error-context`). Used — alongside `x-telo-eval` paths — to decide
- * whether a `!cel` expression sits in a slot the runtime actually evaluates.
- * Scopes use the same `$.a.b[*]` form as `extractContextsFromSchema`, matched
- * against expression paths with `pathMatchesScope`.
- */
-export function extractCelRegionScopes(schema, path = "$") {
-    if (!schema || typeof schema !== "object")
-        return [];
-    const out = [];
-    if (CEL_REGION_KEYS.some((k) => schema[k]) || isStepSlot(schema))
-        out.push(path);
-    if (schema.properties) {
-        for (const [key, value] of Object.entries(schema.properties)) {
-            out.push(...extractCelRegionScopes(value, `${path}.${key}`));
-        }
-    }
-    if (schema.items && typeof schema.items === "object") {
-        out.push(...extractCelRegionScopes(schema.items, `${path}[*]`));
-    }
-    for (const key of ["oneOf", "anyOf", "allOf"]) {
-        if (Array.isArray(schema[key])) {
-            for (const subschema of schema[key])
-                out.push(...extractCelRegionScopes(subschema, path));
-        }
-    }
-    return out;
-}
 function collectContexts(schema, path) {
     if (!schema || typeof schema !== "object")
         return [];

package/dist/validate-reference-forms.d.ts

@@ -23,6 +23,16 @@ import { type AnalysisDiagnostic } from "./types.js";
  * Rejected, each with an actionable diagnostic pointing at `!ref`:
  *   - the object form `{ kind, name }` (the old reference object), and
  *   - a bare string (the old name / dotted-FQN reference).
+ *
+ * **A value-or-reference union slot is the one exception**, and it is decided by
+ * the value rather than by a new spelling: where the reference constraint is a
+ * *branch* of a union (`type:` on a column, holding either a storage class or a
+ * `!ref` to a declared enum), a SCALAR is a value and is left to that branch,
+ * while an object is still checked for the removed `{kind, name}` form unless a
+ * branch describes it. The rule guards a REMOVED spelling — a bare string is
+ * simply not a reference in Telo — so admitting one takes nothing away: what it
+ * costs is the answer when an author meant a reference and wrote a bare name,
+ * which against a closed branch AJV reports as an unknown value.
  */
 export declare function validateReferenceForms(resources: ResourceManifest[], registry: DefinitionRegistry, aliases?: AliasResolver, aliasesByModule?: Map<string, AliasResolver>): AnalysisDiagnostic[];
 //# sourceMappingURL=validate-reference-forms.d.ts.map

package/dist/validate-reference-forms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-reference-forms.d.ts","sourceRoot":"","sources":["../src/validate-reference-forms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIzE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAC3C,kBAAkB,EAAE,CA+DtB"}
+{"version":3,"file":"validate-reference-forms.d.ts","sourceRoot":"","sources":["../src/validate-reference-forms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAInE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAC3C,kBAAkB,EAAE,CA0EtB"}

package/dist/validate-reference-forms.js

@@ -1,5 +1,6 @@
 import { isTaggedSentinel } from "@telorun/templating";
 import { visitManifest } from "./manifest-visitor.js";
+import { satisfiesValueBranch } from "./reference-field-map.js";
 import { REF_VALIDATION_SKIP_KINDS as SYSTEM_KINDS } from "./system-kinds.js";
 import { DiagnosticSeverity } from "./types.js";
 const SOURCE = "telo-analyzer";
@@ -24,6 +25,16 @@ const SOURCE = "telo-analyzer";
  * Rejected, each with an actionable diagnostic pointing at `!ref`:
  *   - the object form `{ kind, name }` (the old reference object), and
  *   - a bare string (the old name / dotted-FQN reference).
+ *
+ * **A value-or-reference union slot is the one exception**, and it is decided by
+ * the value rather than by a new spelling: where the reference constraint is a
+ * *branch* of a union (`type:` on a column, holding either a storage class or a
+ * `!ref` to a declared enum), a SCALAR is a value and is left to that branch,
+ * while an object is still checked for the removed `{kind, name}` form unless a
+ * branch describes it. The rule guards a REMOVED spelling — a bare string is
+ * simply not a reference in Telo — so admitting one takes nothing away: what it
+ * costs is the answer when an author meant a reference and wrote a bare name,
+ * which against a closed branch AJV reports as an unknown value.
  */
 export function validateReferenceForms(resources, registry, aliases, aliasesByModule) {
     if (!aliases)
@@ -37,6 +48,18 @@ export function validateReferenceForms(resources, registry, aliases, aliasesByMo
             // `!ref` and `!cel`/`${{ }}` sentinels are the supported shapes.
             if (isTaggedSentinel(value))
                 return;
+            // A SCALAR at a slot whose union has a value branch is a value, and the
+            // value branch is what judges it. Reporting a mistyped storage class as
+            // a malformed reference — "write it as '!ref txt'" — instructs the author
+            // to convert a typo into a reference, and AJV has already said what the
+            // value must be one of. The object form below is not ambiguous the same
+            // way: `{kind, name}` is the removed reference object, so it is still
+            // reported unless a branch genuinely describes that shape.
+            const hasValueBranch = (e.entry.valueBranches?.length ?? 0) > 0;
+            if (hasValueBranch && typeof value !== "object")
+                return;
+            if (satisfiesValueBranch(value, e.entry.valueBranches, registry))
+                return;
             const r = e.source;
             const resourceLabel = `${r.kind}/${r.metadata.name}`;
             const resourceData = { kind: r.kind, name: r.metadata.name };

package/dist/validate-references.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAOrD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAuD/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CAogBtB"}
+{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAarD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAuD/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CA2gBtB"}

package/dist/validate-references.js

@@ -1,6 +1,6 @@
 import { isRefSentinel } from "@telorun/templating";
 import { visitManifest } from "./manifest-visitor.js";
-import { isInlineResource, resolveFieldEntries, resolveFieldValues } from "./reference-field-map.js";
+import { isInlineResource, resolveFieldEntries, resolveFieldValues, satisfiesValueBranch, } from "./reference-field-map.js";
 import { navigateJsonPointer, substituteCelFields } from "./schema-compat.js";
 import { REF_VALIDATION_SKIP_KINDS as SYSTEM_KINDS } from "./system-kinds.js";
 import { resolveTypeFieldToSchema } from "./validate-cel-context.js";
@@ -91,7 +91,7 @@ export function validateReferences(resources, context) {
     // Group manifests by name to detect collisions. Two subtleties:
     //
     //   1. Some analyzer hosts emit the SAME physical document twice through
-    //      their pipeline — e.g. the telo-editor's `toAnalysisManifests` walks
+    //      their pipeline — e.g. telo studio's `toAnalysisManifests` walks
     //      each workspace module's documents independently, and a file
     //      reachable from two angles (entry module + `include:` partial)
     //      shows up twice. The fingerprint includes `sourceLine` so identical
@@ -278,6 +278,13 @@ export function validateReferences(resources, context) {
             if (typeof val !== "object")
                 return;
             const refVal = val;
+            // A value the slot's own union describes is a value, not a reference —
+            // the same narrowing `validateReferenceForms` applies, through the same
+            // function, because it has to be applied here too: an OBJECT-shaped value
+            // branch would otherwise reach the structural check below and be reported
+            // as a reference missing 'kind' and 'name'.
+            if (satisfiesValueBranch(val, entry.valueBranches, registry))
+                return;
             // Skip inline resources — Phase 2 normalization hasn't run yet.
             if (isInlineResource(refVal))
                 return;