@telorun/analyzer 0.63.0 → 0.64.0

package/dist/manifest-analysis.d.ts

@@ -0,0 +1,73 @@
+/**
+ * **One analyzed manifest set, and the questions asked of it.**
+ *
+ * Several answers a host needs require the SAME two things: the registry's
+ * definitions and aliases, and the manifest set they were resolved against. The
+ * registry deliberately holds no manifests — it is populated per analysis and
+ * reused across them — so each such answer would otherwise become another
+ * factory on the registry and another optional parameter on every IDE entry
+ * point. Four of those arrived in short order (CEL scope, step declarations,
+ * context-binding declarations, invocation contracts) and the next one is not
+ * hypothetical.
+ *
+ * So the pairing is named once and the questions hang off it. A host threads ONE
+ * object and gains later questions for free; each facet keeps its own honest
+ * name rather than accreting onto whichever one happened to exist first.
+ *
+ * Nothing here re-implements an answer. `contractFor` is the shared
+ * {@link resolveContract} — the one `telo check` runs and the kernel binds at
+ * dispatch — given the scope to run in; `celScope` is the same
+ * {@link CelScopeQuery} the analysis pass's rule is built from. That is the
+ * whole point: a completion list is a claim about what the checker accepts, and
+ * a second implementation of any of these could not be held to it.
+ */
+import type { ResourceManifest } from "@telorun/sdk";
+import { AliasResolver } from "./alias-resolver.js";
+import { CelScopeQuery, type CelScopeQueryContext } from "./cel-scope-query.js";
+import { DefinitionRegistry } from "./definition-registry.js";
+import type { ContractDirection } from "./extends-resolution.js";
+/**
+ * A reference as the loader leaves it — the internal `{kind, name, alias?}`
+ * shape `resolveRefSentinels` rewrites `!ref` into.
+ */
+export interface ManifestRef {
+    kind?: string;
+    name?: string;
+    alias?: string;
+}
+export declare class ManifestAnalysis {
+    readonly manifests: ResourceManifest[];
+    private readonly ctx;
+    private readonly scopes;
+    private celScopeQuery;
+    constructor(manifests: ResourceManifest[], ctx: CelScopeQueryContext);
+    /** What CEL sees, per site. Built on first use — its indices are a function of
+     *  the whole set, and a host that never opens a CEL body should not pay for
+     *  them. */
+    get celScope(): CelScopeQuery;
+    /** The manifest a `(kind, name)` pair addresses. */
+    resourceFor(kind: string | undefined, name: string | undefined): ResourceManifest | undefined;
+    /**
+     * The invocation contract of the resource a reference names.
+     *
+     * The shared resolver, so an editor offering a target's input keys is offering
+     * exactly what `telo check` validates that call site against and what the
+     * kernel binds at dispatch. Layered instance-first: a resource declaring its
+     * own `inputType:` narrows the kind's, which is the common case for a
+     * `Run.Sequence` used as a handler.
+     */
+    contractFor(ref: ManifestRef, direction: ContractDirection): Record<string, any> | undefined;
+    /**
+     * The manifest a reference names.
+     *
+     * An ALIAS narrows before the name does: a flattened set carries every
+     * imported library's exported instances, so two libraries exporting a `store`
+     * are two manifests with one name. Matching the alias to its target module
+     * picks the right one; where the alias resolves to nothing the name alone is
+     * used, which is what a local reference needs anyway.
+     */
+    private resolveRef;
+    private definitionFor;
+}
+export type { CelScopeQueryContext, AliasResolver, DefinitionRegistry };
+//# sourceMappingURL=manifest-analysis.d.ts.map

package/dist/manifest-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-analysis.d.ts","sourceRoot":"","sources":["../src/manifest-analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAE,aAAa,EAAqB,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAKjE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,gBAAgB;IAKzB,QAAQ,CAAC,SAAS,EAAE,gBAAgB,EAAE;IACtC,OAAO,CAAC,QAAQ,CAAC,GAAG;IALtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,aAAa,CAA4B;gBAGtC,SAAS,EAAE,gBAAgB,EAAE,EACrB,GAAG,EAAE,oBAAoB;IAS5C;;gBAEY;IACZ,IAAI,QAAQ,IAAI,aAAa,CAE5B;IAED,oDAAoD;IACpD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,GAAG,SAAS;IAI7F;;;;;;;;OAQG;IACH,WAAW,CAAC,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS;IAiB5F;;;;;;;;OAQG;IACH,OAAO,CAAC,UAAU;IAqBlB,OAAO,CAAC,aAAa;CAItB;AAED,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/manifest-analysis.js

@@ -0,0 +1,78 @@
+import { CelScopeQuery } from "./cel-scope-query.js";
+import { analyzerContractScope, resolveContract } from "./invocation-contract.js";
+import { findManifest } from "./find-manifest.js";
+import { isModuleKind } from "./module-kinds.js";
+export class ManifestAnalysis {
+    manifests;
+    ctx;
+    scopes;
+    celScopeQuery;
+    constructor(manifests, ctx) {
+        this.manifests = manifests;
+        this.ctx = ctx;
+        const rootModules = new Set();
+        for (const m of manifests) {
+            if (isModuleKind(m.kind) && m.metadata?.name)
+                rootModules.add(m.metadata.name);
+        }
+        this.scopes = { aliasesByModule: ctx.aliasesByModule, rootModules };
+    }
+    /** What CEL sees, per site. Built on first use — its indices are a function of
+     *  the whole set, and a host that never opens a CEL body should not pay for
+     *  them. */
+    get celScope() {
+        return (this.celScopeQuery ??= new CelScopeQuery(this.manifests, this.ctx));
+    }
+    /** The manifest a `(kind, name)` pair addresses. */
+    resourceFor(kind, name) {
+        return findManifest(this.manifests, kind, name);
+    }
+    /**
+     * The invocation contract of the resource a reference names.
+     *
+     * The shared resolver, so an editor offering a target's input keys is offering
+     * exactly what `telo check` validates that call site against and what the
+     * kernel binds at dispatch. Layered instance-first: a resource declaring its
+     * own `inputType:` narrows the kind's, which is the common case for a
+     * `Run.Sequence` used as a handler.
+     */
+    contractFor(ref, direction) {
+        const target = this.resolveRef(ref);
+        const definition = ref.kind ? this.definitionFor(ref.kind) : undefined;
+        if (!target && !definition)
+            return undefined;
+        return resolveContract(direction, target, definition, analyzerContractScope(this.ctx.defs, this.ctx.aliases, this.scopes, this.manifests))?.schema;
+    }
+    /**
+     * The manifest a reference names.
+     *
+     * An ALIAS narrows before the name does: a flattened set carries every
+     * imported library's exported instances, so two libraries exporting a `store`
+     * are two manifests with one name. Matching the alias to its target module
+     * picks the right one; where the alias resolves to nothing the name alone is
+     * used, which is what a local reference needs anyway.
+     */
+    resolveRef(ref) {
+        if (!ref.name)
+            return undefined;
+        const byName = this.manifests.filter((m) => m.metadata?.name === ref.name);
+        if (byName.length === 0)
+            return undefined;
+        if (byName.length === 1)
+            return byName[0];
+        const targetModule = ref.alias ? this.ctx.aliases.moduleForAlias?.(ref.alias) : undefined;
+        if (targetModule) {
+            const scoped = byName.find((m) => m.metadata?.module === targetModule);
+            if (scoped)
+                return scoped;
+        }
+        // Several candidates and nothing to choose between them: refusing is the
+        // honest answer, since typing a call site against the wrong resource's
+        // contract is worse than typing it against none.
+        return ref.kind ? byName.find((m) => m.kind === ref.kind) : undefined;
+    }
+    definitionFor(kind) {
+        const canonical = this.ctx.aliases.resolveKind(kind);
+        return this.ctx.defs.resolve(kind) ?? (canonical ? this.ctx.defs.resolve(canonical) : undefined);
+    }
+}

package/dist/manifest-path.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Navigating a MANIFEST by a concrete path (`routes[0].request.schema.query`).
+ *
+ * The counterpart to `schema-walk.ts`, which navigates a schema: this addresses
+ * the author's own document, indices and all. Its own module because three
+ * places needed it independently — the CEL scope query resolving a context
+ * binding's declaration, the call-site checker resolving an argument map, and
+ * the IDE resolving the same map for completion — and three copies of one
+ * traversal is exactly what the shared-answer rule exists to prevent.
+ */
+/**
+ * The value at `path`, or `undefined` when any segment is absent.
+ *
+ * Absence is what makes a candidate path a CHECK rather than a guess: a caller
+ * offering several possible shapes can try each and know a hit is a real node.
+ */
+export declare function navigateConcretePath(root: Record<string, any>, path: string): unknown;
+//# sourceMappingURL=manifest-path.d.ts.map

package/dist/manifest-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-path.d.ts","sourceRoot":"","sources":["../src/manifest-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAgBrF"}

package/dist/manifest-path.js

@@ -0,0 +1,37 @@
+/**
+ * Navigating a MANIFEST by a concrete path (`routes[0].request.schema.query`).
+ *
+ * The counterpart to `schema-walk.ts`, which navigates a schema: this addresses
+ * the author's own document, indices and all. Its own module because three
+ * places needed it independently — the CEL scope query resolving a context
+ * binding's declaration, the call-site checker resolving an argument map, and
+ * the IDE resolving the same map for completion — and three copies of one
+ * traversal is exactly what the shared-answer rule exists to prevent.
+ */
+/**
+ * The value at `path`, or `undefined` when any segment is absent.
+ *
+ * Absence is what makes a candidate path a CHECK rather than a guess: a caller
+ * offering several possible shapes can try each and know a hit is a real node.
+ */
+export function navigateConcretePath(root, path) {
+    let current = root;
+    for (const segment of path.split(".")) {
+        if (!segment)
+            continue;
+        const match = segment.match(/^([^[]*)((?:\[\d+\])*)$/);
+        if (!match)
+            return undefined;
+        if (match[1]) {
+            if (current === null || typeof current !== "object")
+                return undefined;
+            current = current[match[1]];
+        }
+        for (const index of match[2].matchAll(/\[(\d+)\]/g)) {
+            if (!Array.isArray(current))
+                return undefined;
+            current = current[Number(index[1])];
+        }
+    }
+    return current;
+}

package/dist/schema-walk.d.ts

@@ -0,0 +1,25 @@
+/** Resolve a local `$ref` (only `#/$defs/<name>` form) against the root schema.
+ *  Non-refs and unresolved refs pass through unchanged. */
+export declare function resolveLocalRef(schema: Record<string, any> | undefined, root: Record<string, any>): Record<string, any> | undefined;
+/** Gather property schemas from a (possibly variant-bearing) object schema:
+ *  top-level `properties` plus every `oneOf` / `anyOf` / `allOf` branch.
+ *
+ *  Each branch is resolved through {@link resolveLocalRef} first, so a branch
+ *  that points at a shared shape — a `oneOf` arm that IS the kernel's dispatch
+ *  site — contributes its properties like an inline one. Without that, pointing a
+ *  composer at a shared shape would silently empty every role-driven lookup that
+ *  reads this (the inputs slot, the retry policy, the eval paths), which is a
+ *  failure with no diagnostic attached to it. */
+export declare function gatherPropertySchemas(schema: Record<string, any>, root?: Record<string, any>): Array<[string, Record<string, any>]>;
+/**
+ * Generic, role-driven walk over a step array. Calls
+ * `visit(step, stepPath)` for every step — top-level and nested through the
+ * `x-telo-topology-role` forms (`branch`, `branch-list`, `case-map`). This is
+ * the single definition of how steps nest, shared by `buildStepContextSchema`
+ * (which types `steps.<name>.result`) and `validateStepInvokeReferences` (which
+ * checks invoke refs), so the topology contract lives in one place — adding a
+ * role or nesting form updates both consumers at once. No resource kind is
+ * hardcoded; recursion is driven entirely by the schema annotations.
+ */
+export declare function walkStepArray(steps: unknown[], stepItemSchema: Record<string, any> | undefined, rootSchema: Record<string, any>, basePath: string, visit: (step: Record<string, any>, stepPath: string) => void): void;
+//# sourceMappingURL=schema-walk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-walk.d.ts","sourceRoot":"","sources":["../src/schema-walk.ts"],"names":[],"mappings":"AAYA;2DAC2D;AAC3D,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,EACvC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACxB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAqBjC;AAID;;;;;;;;iDAQiD;AACjD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAsBtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,EAAE,EAChB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,EAC/C,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,GAC3D,IAAI,CAiDN"}

package/dist/schema-walk.js

@@ -0,0 +1,126 @@
+/**
+ * Structural traversal over a kind's JSON Schema and the step arrays it
+ * declares. Nothing here analyzes: these answer "what does this schema node
+ * point at" and "how do steps nest", the two questions every analyzer pass
+ * asks before it can say anything.
+ *
+ * Its own file so the CEL scope rule (`cel-scope.ts`) and the analysis pass
+ * (`analyzer.ts`) can both reach it without either importing the other — the
+ * scope rule is consumed by the IDE, which must not pull the pass in behind it.
+ */
+import { MANIFEST_SCHEMA_URI, ManifestRootSchema } from "./manifest-schemas.js";
+/** Resolve a local `$ref` (only `#/$defs/<name>` form) against the root schema.
+ *  Non-refs and unresolved refs pass through unchanged. */
+export function resolveLocalRef(schema, root) {
+    if (!schema)
+        return undefined;
+    const ref = schema.$ref;
+    if (typeof ref === "string" && ref.startsWith("#/$defs/")) {
+        const defName = ref.slice("#/$defs/".length);
+        const resolved = root.$defs?.[defName];
+        if (resolved && typeof resolved === "object")
+            return resolved;
+    }
+    // A kernel-owned structural fragment (`telo://manifest#/$defs/InvokeStep`).
+    // Resolved HERE rather than by each walker: this is the one chokepoint every
+    // structural walk already goes through — the step-array walks, the call graph,
+    // the zone projection, the eval-path collector — so a composer that points at a
+    // shared shape stays legible to all of them at once. Nothing is inlined into
+    // the stored schema, which keeps validator-cache identity stable and matches
+    // what `resolveSchemaTypeRefs` does for a named user type.
+    if (typeof ref === "string" && ref.startsWith(BUILTIN_FRAGMENT_PREFIX)) {
+        const defName = ref.slice(BUILTIN_FRAGMENT_PREFIX.length);
+        const resolved = ManifestRootSchema.$defs[defName];
+        if (resolved && typeof resolved === "object")
+            return resolved;
+    }
+    return schema;
+}
+const BUILTIN_FRAGMENT_PREFIX = `${MANIFEST_SCHEMA_URI}#/$defs/`;
+/** Gather property schemas from a (possibly variant-bearing) object schema:
+ *  top-level `properties` plus every `oneOf` / `anyOf` / `allOf` branch.
+ *
+ *  Each branch is resolved through {@link resolveLocalRef} first, so a branch
+ *  that points at a shared shape — a `oneOf` arm that IS the kernel's dispatch
+ *  site — contributes its properties like an inline one. Without that, pointing a
+ *  composer at a shared shape would silently empty every role-driven lookup that
+ *  reads this (the inputs slot, the retry policy, the eval paths), which is a
+ *  failure with no diagnostic attached to it. */
+export function gatherPropertySchemas(schema, root) {
+    const out = [];
+    const base = resolveLocalRef(schema, root ?? schema) ?? schema;
+    if (base.properties && typeof base.properties === "object") {
+        for (const [k, v] of Object.entries(base.properties)) {
+            out.push([k, v]);
+        }
+    }
+    for (const variantKey of ["oneOf", "anyOf", "allOf"]) {
+        const arr = base[variantKey];
+        if (!Array.isArray(arr))
+            continue;
+        for (const raw of arr) {
+            if (!raw || typeof raw !== "object")
+                continue;
+            const variant = resolveLocalRef(raw, root ?? schema) ?? raw;
+            if (variant.properties) {
+                for (const [k, v] of Object.entries(variant.properties)) {
+                    out.push([k, v]);
+                }
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Generic, role-driven walk over a step array. Calls
+ * `visit(step, stepPath)` for every step — top-level and nested through the
+ * `x-telo-topology-role` forms (`branch`, `branch-list`, `case-map`). This is
+ * the single definition of how steps nest, shared by `buildStepContextSchema`
+ * (which types `steps.<name>.result`) and `validateStepInvokeReferences` (which
+ * checks invoke refs), so the topology contract lives in one place — adding a
+ * role or nesting form updates both consumers at once. No resource kind is
+ * hardcoded; recursion is driven entirely by the schema annotations.
+ */
+export function walkStepArray(steps, stepItemSchema, rootSchema, basePath, visit) {
+    const dispatchRole = (data, role, itemsSchema, path) => {
+        if (role === "branch" && Array.isArray(data)) {
+            walkStepArray(data, stepItemSchema, rootSchema, path, visit);
+        }
+        else if (role === "case-map" && data && typeof data === "object" && !Array.isArray(data)) {
+            for (const [caseKey, arr] of Object.entries(data)) {
+                if (Array.isArray(arr))
+                    walkStepArray(arr, stepItemSchema, rootSchema, `${path}.${caseKey}`, visit);
+            }
+        }
+        else if (role === "branch-list" && Array.isArray(data)) {
+            const entrySchema = resolveLocalRef(itemsSchema, rootSchema);
+            if (!entrySchema)
+                return;
+            data.forEach((entry, i) => {
+                if (!entry || typeof entry !== "object")
+                    return;
+                for (const [subKey, subSchema] of gatherPropertySchemas(entrySchema)) {
+                    const subRole = subSchema["x-telo-topology-role"];
+                    if (typeof subRole !== "string")
+                        continue;
+                    dispatchRole(entry[subKey], subRole, subSchema.items, `${path}[${i}].${subKey}`);
+                }
+            });
+        }
+    };
+    steps.forEach((step, i) => {
+        if (!step || typeof step !== "object")
+            return;
+        const s = step;
+        const stepPath = `${basePath}[${i}]`;
+        visit(s, stepPath);
+        if (!stepItemSchema)
+            return;
+        for (const [propKey, propSchema] of gatherPropertySchemas(stepItemSchema)) {
+            const role = propSchema["x-telo-topology-role"];
+            if (typeof role !== "string")
+                continue;
+            dispatchRole(s[propKey], role, propSchema.items, `${stepPath}.${propKey}`);
+        }
+    });
+}

package/dist/telo-version.d.ts

@@ -1,3 +1,3 @@
 /** The surface generation this analyzer implements. */
-export declare const TELO_SURFACE_VERSION = "0.79.0";
+export declare const TELO_SURFACE_VERSION = "0.80.0";
 //# 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.79.0";
+export const TELO_SURFACE_VERSION = "0.80.0";

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

@@ -1,5 +1,6 @@
 import type { AliasResolver, ModuleScopes } from "./alias-resolver.js";
 import type { DefinitionRegistry } from "./definition-registry.js";
+import { type ReferenceFieldMap } from "./reference-field-map.js";
 export interface StepInputIssue {
     path: string;
     targetLabel: string;
@@ -29,4 +30,20 @@ export declare function collectStepInputIssues(manifest: Record<string, any>, de
  *  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[];
+/**
+ * Validate the argument map of every call this resource makes through a
+ * REFERENCE SLOT, as opposed to a step.
+ *
+ * A slot that transfers control names its argument slot on its own `x-telo-ref`
+ * (`inputs:`, a JSON Pointer relative to the object enclosing the slot). That
+ * annotation is the only thing tying an otherwise-open `inputs:` map to the
+ * resource it holds arguments for — an HTTP route's `handler:` + `inputs:` pair
+ * is exactly this shape, and nothing about it is a step.
+ *
+ * Discovery is driven by the annotation rather than by any kind's topology, so
+ * a composer that names its argument slot gets its call sites checked without
+ * the analyzer learning what a route is. It is the same check the step driver
+ * runs, because it is the same question.
+ */
+export declare function collectRefInputIssues(manifest: Record<string, any>, fieldMap: ReferenceFieldMap | undefined, allManifests: Record<string, any>[], defs: DefinitionRegistry, aliases: AliasResolver, scopes: ModuleScopes): 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;AAsBnE,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,GAAG,oBAAoB,CAAC;CAC5D;AAGD;;;;;;;;;;;;;;;GAeG;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,CAsJlB"}
+{"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;AAsBnE,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,0BAA0B,CAAC;AAElC,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,GAAG,oBAAoB,CAAC;CAC5D;AAGD;;;;;;;;;;;;;;;GAeG;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,CA4DlB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EACvC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EACnC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,YAAY,GACnB,cAAc,EAAE,CAoClB"}

package/dist/validate-step-inputs.js

@@ -5,6 +5,8 @@ import { isLiveSlot, valueTypeOf } from "@telorun/sdk";
 import { manifestFragmentOf } from "./manifest-schemas.js";
 import { analyzerContractScope, containerOf, gatherPropertySchemas, missingRequired, resolveLocalRef, walkStepArray, } from "./analyzer.js";
 import { readStepSlot } from "./step-slot.js";
+import { navigateConcretePath } from "./manifest-path.js";
+import { isRefEntry, resolveFieldEntries, } from "./reference-field-map.js";
 /**
  * Validate every step's `inputs:` against the invoked target's declared input
  * contract — the static half of what the kernel enforces at dispatch.
@@ -32,6 +34,14 @@ stepContext) {
         return out;
     const contractScope = analyzerContractScope(defs, aliases, scopes, allManifests);
     const readingModule = manifest.metadata?.module;
+    const ctx = {
+        manifest,
+        allManifests,
+        defs,
+        contractScope,
+        readingModule,
+        stepContext,
+    };
     for (const [fieldName, fieldSchema] of Object.entries(props)) {
         const stepCtx = readStepSlot(fieldSchema);
         if (!stepCtx)
@@ -58,6 +68,87 @@ stepContext) {
                 return;
             if (!values || typeof values !== "object" || Array.isArray(values))
                 return;
+            out.push(...checkCallSite({
+                inputsPath: `${stepPath}.${inputsField}`,
+                values: values,
+                invoke,
+                // Only a step declares a re-attempt policy, so only a step can carry
+                // the live-value-retried finding.
+                declaredRetryFor: (invokedManifest, invokedDef) => declaredRetry(step, stepItemSchema, invokedManifest, invokedDef),
+            }, ctx));
+        });
+    }
+    return out;
+}
+/**
+ * Validate the argument map of every call this resource makes through a
+ * REFERENCE SLOT, as opposed to a step.
+ *
+ * A slot that transfers control names its argument slot on its own `x-telo-ref`
+ * (`inputs:`, a JSON Pointer relative to the object enclosing the slot). That
+ * annotation is the only thing tying an otherwise-open `inputs:` map to the
+ * resource it holds arguments for — an HTTP route's `handler:` + `inputs:` pair
+ * is exactly this shape, and nothing about it is a step.
+ *
+ * Discovery is driven by the annotation rather than by any kind's topology, so
+ * a composer that names its argument slot gets its call sites checked without
+ * the analyzer learning what a route is. It is the same check the step driver
+ * runs, because it is the same question.
+ */
+export function collectRefInputIssues(manifest, fieldMap, allManifests, defs, aliases, scopes) {
+    const out = [];
+    if (!fieldMap)
+        return out;
+    const contractScope = analyzerContractScope(defs, aliases, scopes, allManifests);
+    const ctx = {
+        manifest,
+        allManifests,
+        defs,
+        contractScope,
+        readingModule: manifest.metadata?.module,
+    };
+    for (const [fieldPath, entry] of fieldMap) {
+        if (!isRefEntry(entry) || !entry.inputs)
+            continue;
+        const pointer = pointerSegments(entry.inputs);
+        if (!pointer)
+            continue;
+        for (const { value: invoke, path: slotPath } of resolveFieldEntries(manifest, fieldPath)) {
+            if (!invoke || typeof invoke !== "object" || Array.isArray(invoke))
+                continue;
+            // Relative to the object ENCLOSING the slot, which is the annotation's
+            // documented anchor.
+            const enclosing = slotPath.slice(0, Math.max(0, slotPath.lastIndexOf(".")));
+            const inputsPath = [enclosing, ...pointer].filter(Boolean).join(".");
+            const values = navigateConcretePath(manifest, inputsPath);
+            if (!values || typeof values !== "object" || Array.isArray(values))
+                continue;
+            out.push(...checkCallSite({ inputsPath, values: values, invoke: invoke }, ctx));
+        }
+    }
+    return out;
+}
+/** A JSON Pointer naming a sibling FIELD path. An array index is not a field,
+ *  so a pointer carrying one names nothing this can resolve. */
+function pointerSegments(pointer) {
+    if (!pointer.startsWith("/"))
+        return undefined;
+    const segments = pointer
+        .slice(1)
+        .split("/")
+        .map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+    return segments.every((s) => s.length > 0 && !/^\d+$/.test(s)) ? segments : undefined;
+}
+/**
+ * The check itself, shared by both drivers: the arguments written at a call site
+ * against the contract the target declares.
+ */
+function checkCallSite(site, ctx) {
+    const out = [];
+    const { manifest, allManifests, defs, contractScope, readingModule, stepContext } = ctx;
+    const { invoke, values } = site;
+    {
+        {
             const invokedKind = invoke.kind;
             const invokedName = invoke.name;
             const invokedManifest = invokedName
@@ -68,7 +159,7 @@ stepContext) {
                 : undefined;
             const contract = resolveContract("inputType", invokedManifest, invokedDef, contractScope);
             if (!contract)
-                return;
+                return out;
             // Findings AT a substituted path are about a placeholder, not about
             // anything the author wrote — a `pattern`-constrained string or a `oneOf`
             // of unrelated shapes cannot be satisfied by any stand-in. Structural
@@ -120,10 +211,10 @@ stepContext) {
                     // already declared: the value's liveness by its value type, and the
                     // re-attempt by the retry policy. No kind is named.
                     if (isLiveSlot(produced)) {
-                        const retry = declaredRetry(step, stepItemSchema, invokedManifest, invokedDef);
+                        const retry = site.declaredRetryFor?.(invokedManifest, invokedDef);
                         if (retry !== undefined) {
                             out.push({
-                                path: `${stepPath}.${inputsField}.${inputName}`,
+                                path: `${site.inputsPath}.${inputName}`,
                                 targetLabel: invokedName ?? invokedKind ?? "the invoked resource",
                                 message: `'${inputName}' is a live value, which is consumed by reading and so exists ` +
                                     `once — but ${retry} re-attempts the dispatch, and a re-attempt would pass ` +
@@ -140,7 +231,7 @@ stepContext) {
                     if (compatible)
                         continue;
                     out.push({
-                        path: `${stepPath}.${inputsField}.${inputName}`,
+                        path: `${site.inputsPath}.${inputName}`,
                         targetLabel: invokedName ?? invokedKind ?? "the invoked resource",
                         message: issues.join("; "),
                         code: "CEL_TYPE_ARGUMENT_MISMATCH",
@@ -156,12 +247,12 @@ stepContext) {
                 // container that should have held it, which does exist.
                 const anchor = missingRequired(issue) ? containerOf(issue.path) : issue.path;
                 out.push({
-                    path: anchor ? `${stepPath}.${inputsField}.${anchor}` : `${stepPath}.${inputsField}`,
+                    path: anchor ? `${site.inputsPath}.${anchor}` : site.inputsPath,
                     targetLabel: invokedName ?? invokedKind ?? "the invoked resource",
                     message: issue.message,
                 });
             }
-        });
+        }
     }
     return out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -49,7 +49,7 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.79.0"
+    "@telorun/sdk": "0.80.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/analysis-registry.ts

@@ -1,6 +1,7 @@
 import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
 import { AliasResolver } from "./alias-resolver.js";
 import { KERNEL_BUILTINS } from "./builtins.js";
+import { ManifestAnalysis } from "./manifest-analysis.js";
 import { DefinitionRegistry } from "./definition-registry.js";
 import { computeSuggestKind, computeValidUserFacingKinds } from "./kind-suggest.js";
 import { visitManifest as runVisitManifest, type ManifestVisitor } from "./manifest-visitor.js";
@@ -242,6 +243,42 @@ export class AnalysisRegistry {
     });
   }
 
+  /**
+   * Resolves an `x-telo-schema-from` annotation to the schema node it derives,
+   * in the scope of the kind that DECLARED it — anchors are alias-qualified, and
+   * the declaring definition's module is where those aliases mean something.
+   *
+   * The seam an IDE walks a schema through: a slot shaped entirely by this
+   * annotation (an `Http.Api` route's `request:`) carries no `properties` of its
+   * own, so a walker that only reads `properties` finds nothing there and
+   * silently offers no keys and no hover — a whole field of the standard library
+   * looking like an unknown one.
+   */
+  resolveSchemaFrom(schemaFrom: string, declaringKind: string): Record<string, any> | undefined {
+    const def = this.resolveDefinition(declaringKind);
+    const ownerModule = (def?.metadata as { module?: string } | undefined)?.module;
+    const scope = (ownerModule ? this.aliasesByModule.get(ownerModule) : undefined) ?? this.aliases;
+    return this.defs.resolveSchemaFromNode(schemaFrom, scope);
+  }
+
+  /**
+   * The queries that need this registry AND a manifest set: what CEL sees at a
+   * site, where a binding was declared, what a reference's contract is.
+   *
+   * The seam an IDE reaches all of them through, and one object rather than a
+   * factory per question — each answer has to be the one the analysis pass
+   * computed, or a completion list stops being a claim about what `telo check`
+   * accepts. Built per analysis, not per keystroke: the indices behind it are a
+   * function of the whole manifest set.
+   */
+  analysisOf(manifests: ResourceManifest[]): ManifestAnalysis {
+    return new ManifestAnalysis(manifests, {
+      defs: this.defs,
+      aliases: this.aliases,
+      aliasesByModule: this.aliasesByModule,
+    });
+  }
+
   /**
    * Returns the built-in kernel definitions. The underlying DefinitionRegistry already
    * seeds these on construction; this method exposes them so callers (e.g. the kernel's