@telorun/analyzer 0.62.1 → 0.64.0

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

@@ -0,0 +1,32 @@
+/**
+ * Static validation of the schema-projection annotations themselves — the
+ * strict half of the accessor split, mirroring `validate-ref-slots.ts` and
+ * `validate-zone-slots.ts`.
+ *
+ * `readSchemaProjection` / `readSchemaMap` are deliberately lenient: anything
+ * they cannot read reads as absent. Without this pass that leniency is silent in
+ * the direction that matters — a projection nothing can read does not fail, it
+ * simply stops typing the consumers that were counting on it, so a misspelled
+ * column reaches the database instead of `telo check`. The whole point of the
+ * projection is to move that failure earlier; an unreported malformed
+ * declaration puts it back.
+ *
+ * A map that is merely INCOMPLETE is the same failure per value: a declared type
+ * with no entry projects to nothing, so a column of that type silently vanishes
+ * from every consumer's view of the row.
+ *
+ * Scoping follows `X_TELO_REF_UNRESOLVED`: reported only for definitions in the
+ * entry's own modules — a published dependency's annotation is not the
+ * consumer's to fix.
+ *
+ * Browser-safe: no Node built-ins.
+ */
+import type { ResourceManifest } from "@telorun/sdk";
+export interface SchemaProjectionIssue {
+    code: "SCHEMA_PROJECTION_INVALID" | "SCHEMA_MAP_INCOMPLETE";
+    manifest: ResourceManifest;
+    path: string;
+    message: string;
+}
+export declare function validateSchemaProjection(manifest: ResourceManifest): SchemaProjectionIssue[];
+//# sourceMappingURL=validate-schema-projection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate-schema-projection.d.ts","sourceRoot":"","sources":["../src/validate-schema-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAQrD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,2BAA2B,GAAG,uBAAuB,CAAC;IAC5D,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAQD,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,qBAAqB,EAAE,CA2G5F"}

package/dist/validate-schema-projection.js

@@ -0,0 +1,110 @@
+import { projectionKeyMap, rawSchemaProjection, readSchemaProjection, schemaProjectionIsMisplaced, } from "./schema-projection.js";
+const PROJECTION = "x-telo-schema-projection";
+function isObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function validateSchemaProjection(manifest) {
+    const doc = manifest;
+    const raw = rawSchemaProjection(doc);
+    if (raw === undefined)
+        return [];
+    const misplaced = schemaProjectionIsMisplaced(doc);
+    const base = misplaced ? `schema.${PROJECTION}` : PROJECTION;
+    const issue = (code, path, message) => ({ code, manifest, path, message });
+    const issues = [];
+    // Read from both positions so a misplaced annotation still WORKS, and
+    // reported so it does not stay misplaced. The alternative — reading only the
+    // document — makes the inner spelling silently inert, and the resulting
+    // failure surfaces on a consumer's slot as "this kind declares no projection",
+    // which blames an author who wrote the annotation correctly enough to mean it.
+    if (misplaced) {
+        issues.push(issue("SCHEMA_PROJECTION_INVALID", base, `'${PROJECTION}' belongs on the kind DOCUMENT, beside 'schema:', not inside it — ` +
+            `it describes the whole declaration rather than one field. It is read from here ` +
+            `too, so nothing is broken; move it up a level.`));
+    }
+    if (!isObject(raw)) {
+        return [
+            ...issues,
+            issue("SCHEMA_PROJECTION_INVALID", base, `'${PROJECTION}' must be an object naming the entry collection and the field that keys it.`),
+        ];
+    }
+    const missing = ["entries", "key"].filter((field) => typeof raw[field] !== "string");
+    if (missing.length > 0) {
+        return [
+            ...issues,
+            issue("SCHEMA_PROJECTION_INVALID", base, `'${PROJECTION}' is missing ${missing.map((f) => `'${f}'`).join(" and ")}. ` +
+                `'entries' is a JSON Pointer to the collection, 'key' the entry field whose value ` +
+                `selects an 'x-telo-schema-map' entry.`),
+        ];
+    }
+    const projection = readSchemaProjection(doc);
+    const schema = doc.schema;
+    // An ARRAY-shaped collection has no key to name its entries by, so without
+    // `name` every entry projects to nothing and the whole projection is an object
+    // schema with no properties and `additionalProperties: false` — one that
+    // rejects every value. A keyed map needs no `name`: the map key IS the
+    // identity.
+    if (collectionIsArray(schema, projection.entries) && !projection.nameField) {
+        return [
+            ...issues,
+            issue("SCHEMA_PROJECTION_INVALID", base, `'${PROJECTION}' names '${projection.entries}', which is an array, but declares no ` +
+                `'name'. An array's entries have no key, so 'name' must say which field holds an ` +
+                `entry's identity — without it the projection yields a schema that rejects every value.`),
+        ];
+    }
+    const map = projectionKeyMap(schema, projection);
+    if (!map) {
+        return [
+            ...issues,
+            issue("SCHEMA_PROJECTION_INVALID", base, `'${PROJECTION}' names '${projection.entries}' keyed on '${projection.key}', but that ` +
+                `field carries no 'x-telo-schema-map'. The map declares the JSON Schema each of its ` +
+                `values means, and without it the projection types nothing.`),
+        ];
+    }
+    // An `enum` on the keyed field is the kind's own closed vocabulary, so every
+    // member of it is a value the map has to answer for. Only an enum is checked:
+    // an open string field has no set to be complete against.
+    const keyField = keySchema(schema, projection.entries, projection.key);
+    const values = Array.isArray(keyField?.enum) ? keyField.enum : [];
+    const unmapped = values.filter((value) => typeof value === "string" && !(value in map));
+    if (unmapped.length === 0)
+        return issues;
+    return [
+        ...issues,
+        issue("SCHEMA_MAP_INCOMPLETE", base, `'x-telo-schema-map' has no entry for ${unmapped.map((v) => `'${v}'`).join(", ")}. ` +
+            `An entry declaring an unmapped value projects to nothing, so it disappears from every ` +
+            `consumer's view of the shape.`),
+    ];
+}
+function collectionIsArray(schema, entries) {
+    let node = schema;
+    for (const segment of entries.split("/")) {
+        if (segment === "")
+            continue;
+        if (!isObject(node) || !isObject(node.properties))
+            return false;
+        node = node.properties[segment];
+    }
+    return isObject(node) && isObject(node.items);
+}
+function keySchema(schema, entries, key) {
+    let node = schema;
+    for (const segment of entries.split("/")) {
+        if (segment === "")
+            continue;
+        if (!isObject(node) || !isObject(node.properties))
+            return undefined;
+        node = node.properties[segment];
+    }
+    if (!isObject(node))
+        return undefined;
+    const entry = isObject(node.additionalProperties)
+        ? node.additionalProperties
+        : isObject(node.items)
+            ? node.items
+            : undefined;
+    if (!isObject(entry) || !isObject(entry.properties))
+        return undefined;
+    const field = entry.properties[key];
+    return isObject(field) ? field : undefined;
+}

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;
@@ -20,7 +21,8 @@ export interface StepInputIssue {
  * CEL leaves are replaced by schema-shaped placeholders first (`substituteCelFields`),
  * so an expression is never a false positive — only structural disagreement is
  * reported. Nothing is hardcoded about `Run.Sequence`: the invoke field comes
- * from `x-telo-step-context`, and the paired inputs field from whichever sibling
+ * from the step slot (the shared grammar, or the legacy `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, 
@@ -28,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;AAqBnE,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;;;;;;;;;;;;;;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,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

@@ -4,6 +4,9 @@ import { plainChainOf } from "@telorun/templating";
 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.
@@ -16,7 +19,8 @@ import { analyzerContractScope, containerOf, gatherPropertySchemas, missingRequi
  * CEL leaves are replaced by schema-shaped placeholders first (`substituteCelFields`),
  * so an expression is never a false positive — only structural disagreement is
  * reported. Nothing is hardcoded about `Run.Sequence`: the invoke field comes
- * from `x-telo-step-context`, and the paired inputs field from whichever sibling
+ * from the step slot (the shared grammar, or the legacy `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, 
@@ -30,9 +34,17 @@ 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 = fieldSchema["x-telo-step-context"];
-        if (!stepCtx?.invoke)
+        const stepCtx = readStepSlot(fieldSchema);
+        if (!stepCtx)
             continue;
         const steps = manifest[fieldName];
         if (!Array.isArray(steps))
@@ -56,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
@@ -66,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
@@ -118,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 ` +
@@ -138,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",
@@ -154,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/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;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"}
+{"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;AAsfzE,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

@@ -4,6 +4,7 @@ import { scopeResolverForModule } from "./alias-resolver.js";
 import { createResolveCtx, resolveThrowsUnion, } from "./resolve-throws-union.js";
 import { DiagnosticSeverity } from "./types.js";
 import { extractAccessChains, validateChainAgainstSchema } from "./validate-cel-context.js";
+import { isStepSlot } from "./step-slot.js";
 const SOURCE = "telo-analyzer";
 const TEMPLATE_REGEX = /\$\{\{\s*([^}]+?)\s*\}\}/g;
 /** Walk `definition.schema` and `data` in tandem, invoking `onOutcome` each
@@ -366,9 +367,11 @@ function checkCelChainAgainstDataSchema(entry, dataSchema, resource, filePath, e
     return diagnostics;
 }
 /** Rule 8 extension: `inherit: true` only makes sense on a definition whose
- *  schema contains at least one `x-telo-step-context` array — the annotation
- *  that drives the resolver's generic step traversal. A definition with
- *  `inherit: true` and no such array has no invocables to inherit from. */
+ *  schema declares at least one STEP BODY — an array whose items point at the
+ *  shared grammar, or, for a module published before that fragment existed, one
+ *  carrying the legacy `x-telo-step-context` annotation. That is what drives the
+ *  resolver's generic step traversal; a definition with `inherit: true` and no
+ *  such array has no invocables to inherit from. */
 function validateThrowsDeclarations(manifests) {
     const diagnostics = [];
     for (const m of manifests) {
@@ -386,7 +389,10 @@ function validateThrowsDeclarations(manifests) {
                     severity: DiagnosticSeverity.Error,
                     code: "INHERIT_WITHOUT_STEP_CONTEXT",
                     source: SOURCE,
-                    message: `Telo.Definition '${name}' declares throws.inherit: true but its schema has no field annotated with x-telo-step-context. inherit is only meaningful on definitions that drive invocables via step arrays.`,
+                    message: `Telo.Definition '${name}' declares throws.inherit: true but its schema declares no step ` +
+                        `body. inherit is only meaningful on a definition that drives invocables through steps — ` +
+                        `give an array field 'items: { $ref: "telo://manifest#/$defs/Step" }' (the legacy ` +
+                        `x-telo-step-context annotation is also recognised).`,
                     data: { resource: { kind: m.kind, name }, filePath, path: "throws.inherit" },
                 });
             }
@@ -397,7 +403,7 @@ function validateThrowsDeclarations(manifests) {
 function schemaHasStepContext(schema) {
     if (!schema || typeof schema !== "object")
         return false;
-    if ("x-telo-step-context" in schema)
+    if (isStepSlot(schema))
         return true;
     const props = schema.properties;
     if (props && typeof props === "object") {

package/dist/validate-zone-slots.d.ts

@@ -26,9 +26,9 @@
  *
  * Browser-safe: no Node built-ins.
  */
-import type { ResourceManifest } from "@telorun/sdk";
+import { type ResourceManifest } from "@telorun/sdk";
 export interface ZoneSlotIssue {
-    code: "ZONE_ANNOTATION_INVALID";
+    code: "ZONE_ANNOTATION_INVALID" | "ZONE_ATTRIBUTE_UNKNOWN" | "ZONE_ATTRIBUTE_INCOMPLETE";
     manifest: ResourceManifest;
     /** Schema path of the annotated slot. */
     path: string;

package/dist/validate-zone-slots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-zone-slots.d.ts","sourceRoot":"","sources":["../src/validate-zone-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,yBAAyB,CAAC;IAChC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAmID,iFAAiF;AACjF,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,gBAAgB,GAAG,aAAa,EAAE,CAM1F"}
+{"version":3,"file":"validate-zone-slots.d.ts","sourceRoot":"","sources":["../src/validate-zone-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAuC,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAG1F,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,yBAAyB,GAAG,wBAAwB,GAAG,2BAA2B,CAAC;IACzF,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AA0TD,iFAAiF;AACjF,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,gBAAgB,GAAG,aAAa,EAAE,CAM1F"}