@telorun/analyzer 0.56.1 → 0.58.0

package/dist/schema-region.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Where author-written JSON Schema lives in a manifest — one definition, read by
+ * every surface that has to bound itself to schema.
+ *
+ * The keys are the KERNEL's own schema-valued manifest keys, which no resource
+ * kind owns. That is what makes the rule generic: a surface using it learns no
+ * resource kind, and a module that invents a schema-bearing field of its own
+ * reaches it through one of these or not at all — against the topology-driven
+ * constraint, an enumeration of the standard library's kinds would be both
+ * incomplete and knowledge the analyzer must not hold.
+ *
+ * A schema fragment is NOT confined to kind documents. An inline `inputType:` /
+ * `outputType:` sits on any kind that declares one, an API route carries
+ * `request.schema.body`, a `Telo.JsonSchema` carries `schema`. So a check that
+ * walks a manifest's ROOT keys covers a fraction of the sites an author writes —
+ * which is a silent hole in exactly the checks that exist to stop a silent
+ * degrade. Containment is by ANCESTRY instead: a node is in a schema region when
+ * some key on the path to it is one of these.
+ *
+ * Browser-safe: no Node built-ins.
+ */
+/** The kernel's schema-valued manifest keys. */
+export declare const SCHEMA_REGION_KEYS: readonly string[];
+/**
+ * True when `path` reaches into a schema region — some ANCESTOR segment is a
+ * schema-valued key.
+ *
+ * Ancestors only, so a rule keyed on a region key itself still means "inside a
+ * schema" rather than "is one". `path` is the walk's own segment list; numeric
+ * segments (array indices) never equal a key name, so they need no special case.
+ */
+export declare function isInSchemaRegion(path: readonly (string | number)[]): boolean;
+//# sourceMappingURL=schema-region.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-region.d.ts","sourceRoot":"","sources":["../src/schema-region.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,gDAAgD;AAChD,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAM/C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,OAAO,CAM5E"}

package/dist/schema-region.js

@@ -0,0 +1,45 @@
+/**
+ * Where author-written JSON Schema lives in a manifest — one definition, read by
+ * every surface that has to bound itself to schema.
+ *
+ * The keys are the KERNEL's own schema-valued manifest keys, which no resource
+ * kind owns. That is what makes the rule generic: a surface using it learns no
+ * resource kind, and a module that invents a schema-bearing field of its own
+ * reaches it through one of these or not at all — against the topology-driven
+ * constraint, an enumeration of the standard library's kinds would be both
+ * incomplete and knowledge the analyzer must not hold.
+ *
+ * A schema fragment is NOT confined to kind documents. An inline `inputType:` /
+ * `outputType:` sits on any kind that declares one, an API route carries
+ * `request.schema.body`, a `Telo.JsonSchema` carries `schema`. So a check that
+ * walks a manifest's ROOT keys covers a fraction of the sites an author writes —
+ * which is a silent hole in exactly the checks that exist to stop a silent
+ * degrade. Containment is by ANCESTRY instead: a node is in a schema region when
+ * some key on the path to it is one of these.
+ *
+ * Browser-safe: no Node built-ins.
+ */
+/** The kernel's schema-valued manifest keys. */
+export const SCHEMA_REGION_KEYS = [
+    "schema",
+    "status",
+    "inputType",
+    "outputType",
+    "itemType",
+];
+/**
+ * True when `path` reaches into a schema region — some ANCESTOR segment is a
+ * schema-valued key.
+ *
+ * Ancestors only, so a rule keyed on a region key itself still means "inside a
+ * schema" rather than "is one". `path` is the walk's own segment list; numeric
+ * segments (array indices) never equal a key name, so they need no special case.
+ */
+export function isInSchemaRegion(path) {
+    for (let i = 0; i < path.length - 1; i++) {
+        const segment = path[i];
+        if (typeof segment === "string" && SCHEMA_REGION_KEYS.includes(segment))
+            return true;
+    }
+    return false;
+}

package/dist/types.d.ts

@@ -26,6 +26,37 @@ export interface Range {
 export type PositionIndex = Map<string, Range>;
 /** LSP-compatible Diagnostic shape. range is optional because parsed YAML may not carry
  *  position info when only the parsed object (not raw text) is available. */
+/** A mechanically applicable repair, carried unchanged from whatever produced
+ *  it (a templating engine, a kind-name suggestion) to every consumer: CLI
+ *  JSON, IDE CodeActions, an agent applying it without re-deriving it from
+ *  prose.
+ *
+ *  `replacement` is the **whole** value at the diagnostic's `path`, corrected —
+ *  never a fragment — so applying it needs no knowledge of the language inside.
+ *  There is deliberately no sub-range: carrying one beside a whole-value
+ *  replacement gives the field two readings, and the minimal-edit reading
+ *  (splice `replacement` at `range`) produces garbage because the two measure
+ *  different strings.
+ *
+ *  One shape rather than one per producer: a `fix` field beside a
+ *  `suggestedKind` field beside a CEL-specific one would leave every host
+ *  wiring a separate action path for what is the same gesture. */
+export interface DiagnosticFix {
+    readonly replacement: string;
+}
+/** The `data` stamp diagnostics carry. Loose by design — passes bolt their own
+ *  keys on — but the fields every consumer reads are declared. */
+export interface DiagnosticData {
+    resource?: {
+        kind: string;
+        name: string;
+    };
+    filePath?: string;
+    /** Dotted path of the offending value within its resource. */
+    path?: string;
+    fix?: DiagnosticFix;
+    [key: string]: unknown;
+}
 export interface AnalysisDiagnostic {
     range?: Range;
     severity?: DiagnosticSeverity;
@@ -36,6 +67,9 @@ export interface AnalysisDiagnostic {
     /** Telo-specific extras such as { resource: { kind, name }, path } */
     data?: unknown;
 }
+/** Single reader for a diagnostic's fix, so no consumer re-derives the shape
+ *  by hand-casting `data`. */
+export declare function diagnosticFix(d: AnalysisDiagnostic): DiagnosticFix | undefined;
 export interface ManifestSource {
     supports(url: string): boolean;
     read(url: string): Promise<{
@@ -67,11 +101,28 @@ export interface LoadOptions {
      *  pairs manifests to YAML nodes by index. Folded into the file cache key so a
      *  desugared and a raw load of the same file never collide. */
     desugarImports?: boolean;
+    /** When true, the loader's migration phase rewrites legacy spellings in each
+     *  parsed document before anything else reads the tree. On for every resolved
+     *  consumer — the kernel's analysis and runtime loads, `telo check`, the
+     *  analyzer — so one rewrite serves the definition registry, the runtime and
+     *  the editor's analysis alike.
+     *
+     *  **Off for a round-trip view.** The editor pairs manifests to YAML nodes by
+     *  index and writes the pair back on save; migrating one half of that pair
+     *  would silently change the author's file. `telo migrate` is likewise a raw
+     *  consumer — it rewrites the YAML itself and must see the legacy spelling to
+     *  find it. Folded into the file cache key so a migrated and a raw load of
+     *  the same file never collide. */
+    migrate?: boolean;
 }
 export interface LoaderInitOptions {
     /** Handlers for CEL stdlib functions (e.g. `sha256`). Analyzer-only callers may
      *  omit this and get throwing stubs; runtime callers (kernel) must supply real impls. */
     celHandlers?: import("./cel-environment.js").CelHandlers;
+    /** Migration set for `LoadOptions.migrate` loads. Defaults to the analyzer's
+     *  own `CORE_MIGRATIONS`. A host supplies its own once module-shipped entries
+     *  are aggregated alongside the core ones. */
+    migrations?: readonly import("./migrations/types.js").MigrationEntry[];
 }
 export interface AnalysisOptions {
     strictContexts?: boolean;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE;qHACqH;AACrH,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AACX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE9F,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,cAAc,CAAC;AAErD,MAAM,WAAW,QAAQ;IACvB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,QAAQ,CAAC;CACf;AAED;;oDAEoD;AACpD,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAE/C;6EAC6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAExD;;qEAEiE;IACjE,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEjE;;qEAEiE;IACjE,cAAc,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,WAAW;IAC1B;;;+EAG2E;IAC3E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;mEAO+D;IAC/D,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC;6FACyF;IACzF,WAAW,CAAC,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;CAC1D;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;oCAKgC;IAChC,eAAe,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACxC;;;;;;;;;;sDAUkD;IAClD,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;gEAKgE;AAChE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC;IACtD,WAAW,CAAC,EAAE,OAAO,0BAA0B,EAAE,kBAAkB,CAAC;IACpE;;;;+EAI2E;IAC3E,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC,CAAC;CAC5E"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -8,3 +8,9 @@ export const DiagnosticSeverity = {
 };
 /** Default entry-point filename when a directory is given instead of a file. */
 export const DEFAULT_MANIFEST_FILENAME = "telo.yaml";
+/** Single reader for a diagnostic's fix, so no consumer re-derives the shape
+ *  by hand-casting `data`. */
+export function diagnosticFix(d) {
+    const fix = d.data?.fix;
+    return fix && typeof fix.replacement === "string" ? fix : undefined;
+}

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;AAItF,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,CAyCjC;AAuFD;;;;;;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,CAiJrB;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;AAUD;;;;;;;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;AAItF,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;AAuFD;;;;;;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,CAiJrB;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;AAUD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,SAAM,GAAG,MAAM,EAAE,CAqBxF"}

package/dist/validate-cel-context.js

@@ -1,5 +1,5 @@
 export { extractAccessChains, validateChainAgainstSchema } from "@telorun/templating";
-import { mergeTypeSchemas } from "@telorun/sdk";
+import { mergeTypeSchemas, parseCanonicalTypeSchemaId } from "@telorun/sdk";
 import { KERNEL_BUILTINS } from "./builtins.js";
 /**
  * Resolve a type field value (string name, inline type, or raw schema) to a JSON Schema.
@@ -63,6 +63,31 @@ export function resolveTypeFieldToSchema(value, allManifests, ancestry = new Set
     }
     if (typeof value === "object" && value !== null) {
         const obj = value;
+        // A canonical, module-scoped id — what `resolveSchemaTypeRefs` normalizes
+        // both the reference tag and the legacy `telo://` authority form into.
+        //
+        // This is the ALIAS-AWARE path, and it is why the canonical form exists:
+        // the id names the OWNING MODULE, so two libraries declaring a shape of the
+        // same name stay distinct. The bare-name lookup below cannot do that — it
+        // matches the first manifest with that `metadata.name` in a flattened list,
+        // which is how an alias got silently dropped.
+        const canonical = parseCanonicalTypeSchemaId(obj.$ref);
+        if (canonical) {
+            if (ancestry.has(obj.$ref))
+                return undefined;
+            const owned = allManifests.find((m) => m.metadata?.name === canonical.typeName &&
+                m.metadata?.module === canonical.moduleName &&
+                isTypeKind(m.kind, allManifests) &&
+                typeof m.schema === "object" &&
+                m.schema !== null);
+            if (owned) {
+                return applyExtends(owned.schema, owned.extends, allManifests, new Set(ancestry).add(obj.$ref));
+            }
+            // A module that is not in this set — a single-file analysis, or an import
+            // whose library was not forwarded. Fall through to the bare name, which is
+            // what this resolved before the canonical form existed.
+            return resolveTypeFieldToSchema(canonical.typeName, allManifests, ancestry);
+        }
         // Inline type resource: { kind: "Type.JsonSchema", schema: {...} }
         if (obj.schema && typeof obj.schema === "object") {
             return applyExtends(obj.schema, obj.extends, allManifests, ancestry);
@@ -71,8 +96,9 @@ export function resolveTypeFieldToSchema(value, allManifests, ancestry = new Set
         if (obj.type || obj.properties) {
             return obj;
         }
-        // Named type reference resolved from a `!ref` → { kind, name } — resolve the
-        // named Telo.Type the same way as the bare-string form.
+        // Named type reference resolved from a `!ref` → { kind, name }. Reached only
+        // where the canonical rewrite could not run (a scope whose aliases are not in
+        // hand); resolves by bare name, as it always has.
         if (typeof obj.name === "string") {
             return resolveTypeFieldToSchema(obj.name, allManifests, ancestry);
         }

package/dist/validate-include-placement.d.ts

@@ -0,0 +1,26 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import { type AnalysisDiagnostic } from "./types.js";
+/**
+ * An `!include-text` / `!include-bytes` in a doc that is never instantiated is
+ * never read.
+ *
+ * The two tags resolve when the resource owning them is created — deferred so
+ * that loading a manifest does not pull payload layers, which is the property
+ * the artifact spec protects by giving `telo.yaml` a layer of its own. The cost
+ * of that choice is this dead spot: a doc with no `create()` has no moment at
+ * which the file would be read, so the value stays an unresolved marker and
+ * whatever reads it sees a sentinel object instead of the file's contents.
+ *
+ * Nothing else would report it. There is no controller to validate against a
+ * schema and no runtime consumer to fail, so the manifest ships looking correct
+ * — exactly the silent-no-op failure mode that makes a descriptive field worth
+ * checking. Hence an error at the one place that can see it.
+ *
+ * Deliberately narrow: it reports only where the argument is complete ("this
+ * doc is never instantiated"). A JSON-Schema region *inside* a definition —
+ * `schema:`, `inputType:` — is equally unreadable, but that is a general
+ * question about tags in schema metadata rather than one about these two, and
+ * no pass answers it for any tag today.
+ */
+export declare function validateIncludePlacement(manifests: ResourceManifest[]): AnalysisDiagnostic[];
+//# sourceMappingURL=validate-include-placement.d.ts.map

package/dist/validate-include-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-include-placement.d.ts","sourceRoot":"","sources":["../src/validate-include-placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAmBzE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,gBAAgB,EAAE,GAAG,kBAAkB,EAAE,CA0B5F"}

package/dist/validate-include-placement.js

@@ -0,0 +1,67 @@
+import { INCLUDE_ENGINE_NAMES, walkCelExpressions } from "@telorun/templating";
+import { DiagnosticSeverity } from "./types.js";
+const SOURCE = "telo-analyzer";
+/**
+ * Docs that are never instantiated as resources.
+ *
+ * `Telo.Application` / `Telo.Library` are module declarations, and `Telo.Import`
+ * is a dependency edge — none of the three reaches a controller's `create()`.
+ * `Telo.Definition` and `Telo.Abstract` are deliberately absent: a definition's
+ * template body (`resources:` / `invoke:` / `run:` / `provide:`) DOES become
+ * resources, so an embed there resolves normally.
+ */
+const NEVER_INSTANTIATED = new Set([
+    "Telo.Application",
+    "Telo.Library",
+    "Telo.Import",
+]);
+/**
+ * An `!include-text` / `!include-bytes` in a doc that is never instantiated is
+ * never read.
+ *
+ * The two tags resolve when the resource owning them is created — deferred so
+ * that loading a manifest does not pull payload layers, which is the property
+ * the artifact spec protects by giving `telo.yaml` a layer of its own. The cost
+ * of that choice is this dead spot: a doc with no `create()` has no moment at
+ * which the file would be read, so the value stays an unresolved marker and
+ * whatever reads it sees a sentinel object instead of the file's contents.
+ *
+ * Nothing else would report it. There is no controller to validate against a
+ * schema and no runtime consumer to fail, so the manifest ships looking correct
+ * — exactly the silent-no-op failure mode that makes a descriptive field worth
+ * checking. Hence an error at the one place that can see it.
+ *
+ * Deliberately narrow: it reports only where the argument is complete ("this
+ * doc is never instantiated"). A JSON-Schema region *inside* a definition —
+ * `schema:`, `inputType:` — is equally unreadable, but that is a general
+ * question about tags in schema metadata rather than one about these two, and
+ * no pass answers it for any tag today.
+ */
+export function validateIncludePlacement(manifests) {
+    const out = [];
+    for (const manifest of manifests) {
+        if (!NEVER_INSTANTIATED.has(manifest.kind))
+            continue;
+        const name = manifest.metadata?.name;
+        const filePath = manifest.metadata?.source;
+        walkCelExpressions(manifest, "", (source, path, engineName) => {
+            if (!INCLUDE_ENGINE_NAMES.has(engineName))
+                return;
+            out.push({
+                severity: DiagnosticSeverity.Error,
+                code: "INCLUDE_OUTSIDE_RESOURCE",
+                source: SOURCE,
+                message: `${manifest.kind}${name ? `/${name}` : ""}: \`!${engineName} ${source}\` at '${path}' is ` +
+                    `never read — a ${manifest.kind} doc is not instantiated, and a file embed is resolved ` +
+                    `when the resource holding it is created. Move it onto the resource that needs the ` +
+                    `file, or read the file at runtime with Fs.File.`,
+                data: {
+                    resource: { kind: manifest.kind, name: name ?? "" },
+                    filePath,
+                    path,
+                },
+            });
+        });
+    }
+    return out;
+}

package/dist/validate-step-inputs.d.ts

@@ -4,6 +4,9 @@ export interface StepInputIssue {
     path: string;
     targetLabel: string;
     message: string;
+    /** Set when the issue is a type-argument disagreement rather than a contract
+     *  shape violation — the two read differently and deserve their own code. */
+    code?: "CEL_TYPE_ARGUMENT_MISMATCH";
 }
 /**
  * Validate every step's `inputs:` against the invoked target's declared input
@@ -20,5 +23,9 @@ export interface StepInputIssue {
  * from `x-telo-step-context`, and the paired inputs field from whichever sibling
  * property carries `x-telo-topology-role: inputs`.
  */
-export declare function collectStepInputIssues(manifest: Record<string, any>, defSchema: Record<string, any>, allManifests: Record<string, any>[], defs: DefinitionRegistry, aliases: AliasResolver, scopes: ModuleScopes): StepInputIssue[];
+export declare function collectStepInputIssues(manifest: Record<string, any>, defSchema: Record<string, any>, allManifests: Record<string, any>[], defs: DefinitionRegistry, aliases: AliasResolver, scopes: ModuleScopes, 
+/** The typed `steps.<name>.result` context for this resource. Supplied by the
+ *  caller because building it is analyzer state; without it the contract check
+ *  still runs and only the type-argument comparison is skipped. */
+stepContext?: Record<string, any>): StepInputIssue[];
 //# sourceMappingURL=validate-step-inputs.d.ts.map

package/dist/validate-step-inputs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-step-inputs.d.ts","sourceRoot":"","sources":["../src/validate-step-inputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAanE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC9B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EACnC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,YAAY,GACnB,cAAc,EAAE,CAyElB"}
+{"version":3,"file":"validate-step-inputs.d.ts","sourceRoot":"","sources":["../src/validate-step-inputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAoBnE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB;iFAC6E;IAC7E,IAAI,CAAC,EAAE,4BAA4B,CAAC;CACrC;AAGD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC9B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EACnC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,YAAY;AACpB;;mEAEmE;AACnE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAChC,cAAc,EAAE,CAiHlB"}

package/dist/validate-step-inputs.js

@@ -1,5 +1,7 @@
 import { resolveContract } from "./invocation-contract.js";
-import { substituteCelFields, validateAgainstSchema } from "./schema-compat.js";
+import { checkSchemaCompatibility, navigateSchemaToExprPath, substituteCelFields, validateAgainstSchema, } from "./schema-compat.js";
+import { plainChainOf } from "@telorun/templating";
+import { valueTypeOf } from "@telorun/sdk";
 import { analyzerContractScope, containerOf, gatherPropertySchemas, missingRequired, resolveLocalRef, walkStepArray, } from "./analyzer.js";
 /**
  * Validate every step's `inputs:` against the invoked target's declared input
@@ -16,7 +18,11 @@ import { analyzerContractScope, containerOf, gatherPropertySchemas, missingRequi
  * from `x-telo-step-context`, and the paired inputs field from whichever sibling
  * property carries `x-telo-topology-role: inputs`.
  */
-export function collectStepInputIssues(manifest, defSchema, allManifests, defs, aliases, scopes) {
+export function collectStepInputIssues(manifest, defSchema, allManifests, defs, aliases, scopes, 
+/** The typed `steps.<name>.result` context for this resource. Supplied by the
+ *  caller because building it is analyzer state; without it the contract check
+ *  still runs and only the type-argument comparison is skipped. */
+stepContext) {
     const out = [];
     const props = defSchema.properties;
     if (!props)
@@ -67,6 +73,45 @@ export function collectStepInputIssues(manifest, defSchema, allManifests, defs,
             // container and survive the filter.
             const celPaths = new Set();
             const substituted = substituteCelFields(values, contract.schema, undefined, (p) => celPaths.add(p));
+            // The type-argument check, at the one site where a produced value's schema
+            // meets a consuming slot's. A CEL leaf's placeholder says nothing about
+            // what the expression yields, so AJV above is silent here by design — and
+            // that silence is exactly where a stream of the wrong element used to
+            // flow. The comparison is covariant and gradual: an omitted argument is
+            // *any* in both directions, so only a definite conflict is reported.
+            if (stepContext) {
+                for (const [inputName, inputValue] of Object.entries(values)) {
+                    const chain = plainChainOf(inputValue);
+                    // The step context is rooted at the STEP MAP, so a `steps.` prefix is
+                    // the namespace name and not a property of it. Only that namespace is
+                    // navigated: `inputs.` and a named binding resolve elsewhere, and
+                    // guessing at a root this does not hold would compare the wrong schema.
+                    if (!chain?.startsWith("steps."))
+                        continue;
+                    const produced = navigateSchemaToExprPath(stepContext, chain.slice("steps.".length));
+                    const slotSchema = contract.schema.properties?.[inputName];
+                    if (!produced || !slotSchema)
+                        continue;
+                    // ONLY a type-argument disagreement, which is what the code says. The
+                    // comparator is a general structural comparison, so running it on any
+                    // pair would report a missing required property as "disagreeing type
+                    // arguments" — and would turn every plain-chain wiring site into a
+                    // broad new Error-severity check hidden behind an argument-specific
+                    // name. Both sides must declare a value type for the question to be
+                    // about arguments at all.
+                    if (!valueTypeOf(produced) || !valueTypeOf(slotSchema))
+                        continue;
+                    const { compatible, issues } = checkSchemaCompatibility(produced, slotSchema, (ref) => defs.schemaForId(ref));
+                    if (compatible)
+                        continue;
+                    out.push({
+                        path: `${stepPath}.${inputsField}.${inputName}`,
+                        targetLabel: invokedName ?? invokedKind ?? "the invoked resource",
+                        message: issues.join("; "),
+                        code: "CEL_TYPE_ARGUMENT_MISMATCH",
+                    });
+                }
+            }
             for (const issue of validateAgainstSchema(substituted, contract.schema)) {
                 if (celPaths.has(issue.path))
                     continue;

package/dist/validate-throws-coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-throws-coverage.d.ts","sourceRoot":"","sources":["../src/validate-throws-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAOnE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AA0ezE,oDAAoD;AACpD,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,WAAW,EAChB,eAAe,GAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAa,EACvD,WAAW,GAAE,GAAG,CAAC,MAAM,CAAa,GACnC,kBAAkB,EAAE,CAkDtB"}
+{"version":3,"file":"validate-throws-coverage.d.ts","sourceRoot":"","sources":["../src/validate-throws-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAOnE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AA+ezE,oDAAoD;AACpD,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,WAAW,EAChB,eAAe,GAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAa,EACvD,WAAW,GAAE,GAAG,CAAC,MAAM,CAAa,GACnC,kBAAkB,EAAE,CAkDtB"}

package/dist/validate-throws-coverage.js

@@ -171,7 +171,7 @@ function checkCatchAllPlacement(entries, resource, channel, filePath, arrayPath)
  *  in coverage-proving `when:` clauses. Phase 2 accepts inherit/passthrough
  *  handler unions too — when the resolved union is unbounded, a catch-all is
  *  required (rule 4 extension). */
-function checkCatchesCoverage(entries, union, resource, filePath, arrayPath, env) {
+function checkCatchesCoverage(entries, union, resource, filePath, arrayPath, env, handler) {
     const diagnostics = [];
     const declaredCodes = new Set(union.codes.keys());
     const covered = new Set();
@@ -221,16 +221,19 @@ function checkCatchesCoverage(entries, union, resource, filePath, arrayPath, env
         });
     }
     if (!hasCatchAll) {
-        for (const code of declaredCodes) {
-            if (!covered.has(code)) {
-                diagnostics.push({
-                    severity: DiagnosticSeverity.Error,
-                    code: "UNCOVERED_THROW_CODE",
-                    source: SOURCE,
-                    message: `Code '${code}' is declared by the handler but not covered by any catches: entry (no matching \`when:\` and no catch-all).`,
-                    data: { resource, filePath, path: arrayPath },
-                });
-            }
+        // One diagnostic per block, not per code: every uncovered code sits at the
+        // same `catches:` array, and one catch-all answers all of them at once. A
+        // diagnostic each repeated the same location and the same fix N times.
+        const uncovered = [...declaredCodes].filter((c) => !covered.has(c)).sort();
+        if (uncovered.length > 0) {
+            diagnostics.push({
+                severity: DiagnosticSeverity.Error,
+                code: "UNCOVERED_THROW_CODE",
+                source: SOURCE,
+                message: `handler ${handler?.name ? `\`!ref ${handler.name}\`` : `\`${handler?.kind ?? "?"}\``} can throw ${uncovered.length} code${uncovered.length === 1 ? "" : "s"} that no catches: entry handles: ${uncovered.map((c) => `'${c}'`).join(", ")}. ` +
+                    `Give each a matching \`when:\` (e.g. \`when: !cel "error.code == '${uncovered[0]}'"\`), or add a catch-all entry — one with no \`when:\`, placed last.`,
+                data: { resource, filePath, path: arrayPath, uncovered },
+            });
         }
     }
     return diagnostics;
@@ -447,7 +450,7 @@ export function validateThrowsCoverage(manifests, defs, aliases, env, aliasesByM
             diagnostics.push(...checkCatchAllPlacement(entries, resource, "catches", filePath, arrayPath));
             const handlerRef = resolveHandlerRef(siblingData[catchesFor]);
             const union = handlerRefUnion(handlerRef, manifests, resolveCtx, scopeResolver);
-            diagnostics.push(...checkCatchesCoverage(entries, union, resource, filePath, arrayPath, env));
+            diagnostics.push(...checkCatchesCoverage(entries, union, resource, filePath, arrayPath, env, handlerRef));
             diagnostics.push(...checkTypedErrorData(entries, union, resource, filePath, arrayPath, env));
         });
     }

package/dist/validate-value-type-slots.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Static validation of the `x-telo-type` annotation itself — the strict half of
+ * the accessor split, and the `validate-ref-slots.ts` precedent.
+ *
+ * `readValueTypeSlot` is deliberately lenient: it reports whatever it can read,
+ * returning a slot with no `entry` for a name it does not know. That leniency is
+ * what lets every surface keep working; this pass is what stops it becoming
+ * silence. Before the unification an unrecognized brand simply resolved to
+ * `undefined` and the slot quietly lost its identity — the same class of failure
+ * `X_TELO_REF_INVALID_USE` exists to prevent for `use` tokens.
+ *
+ * The vocabulary is CLOSED and `Telo.`-qualified, so there is nothing here to
+ * resolve against an alias scope: a name is a built-in or it is a mistake. A
+ * SHAPE is a different thing entirely and is named with the reference tag, which
+ * carries its own resolution and its own diagnostics — this pass never sees one,
+ * because `resolveSchemaTypeRefs` has already turned it into a `$ref`.
+ *
+ * Scoping follows `X_TELO_REF_UNRESOLVED`: reported only for manifests in the
+ * entry's own modules, since a published dependency is not the consumer's to fix.
+ *
+ * Browser-safe: no Node built-ins.
+ */
+import { type ResourceManifest } from "@telorun/sdk";
+export interface ValueTypeSlotIssue {
+    code: "X_TELO_TYPE_UNKNOWN" | "X_TELO_TYPE_ARGUMENT_UNKNOWN";
+    manifest: ResourceManifest;
+    /** Dotted path to the annotated schema node, e.g. `schema.properties.body`. */
+    path: string;
+    message: string;
+    /** The whole-value replacement that repairs it, when one is derivable. A
+     *  misspelled name has a single correct spelling and the annotation's value is
+     *  that name, so the repair is the primitive `DiagnosticFix` already carries —
+     *  computing a suggestion and printing it in prose alone leaves the author to
+     *  retype what the analyzer already knows. Only for the bare-name spelling: the
+     *  object form's name is nested, and a whole-value replacement there would
+     *  discard the type arguments beside it. */
+    fix?: {
+        replacement: string;
+    };
+}
+/** Every `x-telo-type` problem in one manifest, wherever a schema is written. */
+export declare function validateValueTypeSlots(manifest: ResourceManifest): ValueTypeSlotIssue[];
+//# sourceMappingURL=validate-value-type-slots.d.ts.map

package/dist/validate-value-type-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-value-type-slots.d.ts","sourceRoot":"","sources":["../src/validate-value-type-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAA+C,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIlG,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,qBAAqB,GAAG,8BAA8B,CAAC;IAC7D,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;gDAM4C;IAC5C,GAAG,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/B;AAwID,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,kBAAkB,EAAE,CAIvF"}