@telorun/analyzer 0.48.0 → 0.49.0

package/dist/schema-compat.js

@@ -282,7 +282,76 @@ export function celTypeSatisfiesJsonSchema(celType, schema) {
     return compatibleWith.some((t) => schemaTypes.includes(t));
 }
 /** Return a literal placeholder value of the correct schema type for AJV. */
-export function celPlaceholderForSchema(schema) {
+/** A number inside the schema's declared bounds. The placeholder stands in for a
+ *  value only known at runtime, so its single job is to be ACCEPTABLE — a bare 0
+ *  into an `exclusiveMinimum: 0` field (a scale, a positive dimension) would
+ *  report a violation against a value the author never wrote. Bounds are read in
+ *  the order that pins the value: an inclusive minimum is usable as-is, an
+ *  exclusive one needs a step past it, and a wholly-negative range needs the
+ *  maximum end instead. */
+function numericPlaceholder(schema) {
+    const isInteger = schema.type === "integer";
+    // One step past an exclusive bound. Integral for both `integer` and `number`:
+    // any value inside the band will do, and a whole number is inside it whenever
+    // a fractional one is (the narrow-band case below handles when it is not).
+    const step = 1;
+    if (typeof schema.minimum === "number")
+        return schema.minimum;
+    if (typeof schema.exclusiveMinimum === "number") {
+        const candidate = schema.exclusiveMinimum + step;
+        if (typeof schema.maximum === "number" && candidate > schema.maximum) {
+            // A narrow band (0 < x <= 0.5) has no integral step; take the midpoint,
+            // which the band's own definition guarantees is inside it.
+            return isInteger ? schema.maximum : (schema.exclusiveMinimum + schema.maximum) / 2;
+        }
+        return candidate;
+    }
+    if (typeof schema.maximum === "number" && schema.maximum < 0)
+        return schema.maximum;
+    if (typeof schema.exclusiveMaximum === "number" && schema.exclusiveMaximum <= 0) {
+        return schema.exclusiveMaximum - step;
+    }
+    return 0;
+}
+/** The constraints a placeholder must satisfy, folded across `allOf` branches.
+ *  Inheritance between types is expressed by intersecting `allOf`, so a bound a
+ *  parent declared lives in a branch rather than on the property itself — a
+ *  placeholder that reads only the top level would violate it and report against
+ *  a value the author never wrote. The tightest bound wins, which is what the
+ *  intersection means. */
+function foldedConstraints(schema) {
+    const branches = Array.isArray(schema.allOf) ? schema.allOf : [];
+    if (branches.length === 0)
+        return schema;
+    const out = { ...schema };
+    for (const branch of branches) {
+        const folded = foldedConstraints(branch);
+        for (const key of ["minimum", "exclusiveMinimum", "minLength", "minItems"]) {
+            if (typeof folded[key] === "number" && (typeof out[key] !== "number" || folded[key] > out[key])) {
+                out[key] = folded[key];
+            }
+        }
+        for (const key of ["maximum", "exclusiveMaximum"]) {
+            if (typeof folded[key] === "number" && (typeof out[key] !== "number" || folded[key] < out[key])) {
+                out[key] = folded[key];
+            }
+        }
+        if (out.type === undefined && folded.type !== undefined)
+            out.type = folded.type;
+        if (out.enum === undefined && folded.enum !== undefined)
+            out.enum = folded.enum;
+        if (out.default === undefined && folded.default !== undefined)
+            out.default = folded.default;
+        if (folded.required) {
+            out.required = [...new Set([...(out.required ?? []), ...folded.required])];
+        }
+        if (folded.properties)
+            out.properties = { ...folded.properties, ...(out.properties ?? {}) };
+    }
+    return out;
+}
+export function celPlaceholderForSchema(rawSchema) {
+    const schema = foldedConstraints(rawSchema);
     if (schema.default !== undefined)
         return schema.default;
     // An enum-constrained field needs a placeholder drawn from the enum: the
@@ -296,19 +365,46 @@ export function celPlaceholderForSchema(schema) {
     switch (schema.type) {
         case "integer":
         case "number":
-            return schema.minimum ?? 0;
+            return numericPlaceholder(schema);
         case "string":
-            return "";
+            // `minLength` is the string analogue of `minimum`: a bare "" into a
+            // `minLength: 1` field would report a violation against a value the author
+            // never wrote. Any string of the right length will do.
+            return typeof schema.minLength === "number" && schema.minLength > 0
+                ? "x".repeat(schema.minLength)
+                : "";
         case "boolean":
             return false;
         case "array":
-            return [];
+            // `minItems` is the array analogue of `minimum` / `minLength`: an empty
+            // array into a `minItems: 1` field would report a violation against a
+            // value the author never wrote.
+            return typeof schema.minItems === "number" && schema.minItems > 0
+                ? Array.from({ length: schema.minItems }, () => celPlaceholderForSchema((schema.items ?? {})))
+                : [];
         case "object":
-            return {};
+            return objectPlaceholder(schema);
         default:
             return null;
     }
 }
+/** An object satisfying the schema's `required` list. A bare `{}` would report
+ *  every required property as missing against a value the author never wrote —
+ *  the case where a whole map is produced by one expression (`inputs: !cel
+ *  "buildRequest(...)"`), which is exactly when the analyzer knows least and
+ *  should say least. Members are filled recursively by the same rule, so a
+ *  required nested object is satisfied too. */
+function objectPlaceholder(schema) {
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    if (required.length === 0)
+        return {};
+    const properties = (schema.properties ?? {});
+    const out = {};
+    for (const key of required) {
+        out[key] = celPlaceholderForSchema(properties[key] ?? {});
+    }
+    return out;
+}
 const CEL_PURE_RE = /^\s*\$\{\{[^}]*\}\}\s*$/;
 /** Resolve a `$ref` (only `#/$defs/...` form) against the root schema. */
 export function resolveRef(schema, root) {
@@ -321,8 +417,75 @@ export function resolveRef(schema, root) {
     return schema;
 }
 /** Collect property schemas from top-level `properties` and all `oneOf`/`anyOf` sub-schemas. */
+/**
+ * The `oneOf` / `anyOf` branch a value is written against, when exactly one fits.
+ *
+ * A union carries no `type` / `properties` / `items` of its own, so a walker that
+ * ignores it descends with an empty schema and hands every CEL leaf underneath a
+ * `null` placeholder — which then fails every branch and reports a pile of
+ * violations against a value that is perfectly valid. Picking the branch first
+ * is what lets the leaves be typed.
+ *
+ * Selection is structural and conservative: a branch must agree with the data's
+ * kind, and for an object every `required` key must be present (which is what
+ * separates a `{type, text}` part from a `{type, data, mediaType}` one). If that
+ * leaves anything other than exactly one branch, the union is returned unchanged
+ * — an ambiguous union is one the analyzer should not resolve on the author's
+ * behalf.
+ */
+function selectUnionBranch(schema, data, root) {
+    const branches = (schema.oneOf ?? schema.anyOf);
+    if (!Array.isArray(branches) || branches.length === 0)
+        return schema;
+    if (schema.type !== undefined || schema.properties !== undefined)
+        return schema;
+    const kind = Array.isArray(data)
+        ? "array"
+        : data === null
+            ? "null"
+            : typeof data === "object"
+                ? "object"
+                : typeof data === "string"
+                    ? "string"
+                    : typeof data === "number"
+                        ? "number"
+                        : typeof data === "boolean"
+                            ? "boolean"
+                            : undefined;
+    if (!kind)
+        return schema;
+    const fits = branches
+        .map((b) => resolveRef(b, root))
+        .filter((b) => {
+        const types = Array.isArray(b.type) ? b.type : b.type ? [b.type] : [];
+        if (types.length > 0 && !types.includes(kind))
+            return false;
+        if (kind === "object" && Array.isArray(b.required)) {
+            const keys = Object.keys(data);
+            if (!b.required.every((r) => keys.includes(r)))
+                return false;
+        }
+        return true;
+    });
+    return fits.length === 1 ? fits[0] : schema;
+}
 export function collectProperties(schema) {
     const props = { ...(schema.properties ?? {}) };
+    // `allOf` INTERSECTS, so a branch constraining a property constrains the
+    // property itself — type inheritance expresses an inherited bound exactly this
+    // way (`allOf: [{ properties: { score: { minimum: 10 } } }]`). Merging the
+    // branch's constraints into the property is what lets a placeholder for that
+    // property be built from the bound the value must actually satisfy; reading
+    // only the top level would produce one that violates it.
+    for (const sub of (schema.allOf ?? [])) {
+        if (!sub || typeof sub !== "object" || !sub.properties)
+            continue;
+        for (const [k, v] of Object.entries(sub.properties)) {
+            props[k] = k in props ? { ...props[k], ...v } : v;
+        }
+    }
+    // `oneOf` / `anyOf` are alternatives, not constraints: a property seen in one
+    // branch is contributed only when no branch already declared it.
     for (const sub of schema.oneOf ?? schema.anyOf ?? []) {
         if (sub && typeof sub === "object" && sub.properties) {
             for (const [k, v] of Object.entries(sub.properties)) {
@@ -335,10 +498,22 @@ export function collectProperties(schema) {
 }
 /** Deep-clone `data`, replacing every pure CEL template string (`${{ expr }}`) with a
  *  schema-appropriate placeholder so AJV can validate non-CEL fields without false positives. */
-export function substituteCelFields(data, schema, rootSchema) {
+export function substituteCelFields(data, schema, rootSchema, 
+/** Called with the dotted path of every value replaced by a placeholder.
+ *
+ *  A placeholder is a stand-in for something only known at runtime, so its
+ *  VALUE says nothing: a caller that judges constraints at these paths reports
+ *  against a value no author wrote. Some constraints cannot be satisfied by
+ *  construction at all (`pattern`, `format`, a `oneOf` of unrelated shapes),
+ *  so making every placeholder acceptable is not achievable in general —
+ *  knowing where not to look is. Structural findings survive because they are
+ *  located at the CONTAINER, not at the substituted leaf. */
+onSubstitute, path = "") {
     const root = rootSchema ?? schema;
-    const resolved = resolveRef(schema, root);
+    const resolved = selectUnionBranch(resolveRef(schema, root), data, root);
+    const mark = () => onSubstitute?.(path);
     if (typeof data === "string" && CEL_PURE_RE.test(data)) {
+        mark();
         return celPlaceholderForSchema(resolved);
     }
     // `!ref <name>` sentinels are identity markers, not runtime values —
@@ -352,11 +527,12 @@ export function substituteCelFields(data, schema, rootSchema) {
         return data;
     }
     if (isTaggedSentinel(data)) {
+        mark();
         return celPlaceholderForSchema(resolved);
     }
     if (Array.isArray(data)) {
         const itemSchema = resolveRef((resolved.items ?? {}), root);
-        return data.map((item) => substituteCelFields(item, itemSchema, root));
+        return data.map((item, i) => substituteCelFields(item, itemSchema, root, onSubstitute, `${path}[${i}]`));
     }
     if (data !== null && typeof data === "object") {
         const props = collectProperties(resolved);
@@ -365,7 +541,7 @@ export function substituteCelFields(data, schema, rootSchema) {
             : undefined;
         const result = {};
         for (const [k, v] of Object.entries(data)) {
-            result[k] = substituteCelFields(v, (props[k] ?? addlProps ?? {}), root);
+            result[k] = substituteCelFields(v, (props[k] ?? addlProps ?? {}), root, onSubstitute, path ? `${path}.${k}` : k);
         }
         return result;
     }

package/dist/validate-base-mapping.js

@@ -78,9 +78,19 @@ export function validateBaseMapping(manifests, registry, aliases) {
     }
     return diagnostics;
 }
+/** Keys the inherited controller supplies itself when it builds the parent
+ *  manifest (`{ kind, metadata, ...base }`), so `base:` neither has to set them
+ *  nor may. Without this exclusion a parent whose schema lists `metadata` in
+ *  `required` — `JS.Script` does, the most natural parent for a remapping child —
+ *  is unusable: omitting it is BASE_MISSING_REQUIRED and setting it is
+ *  BASE_UNKNOWN_FIELD, since `metadata` is required but never a declared
+ *  property. Only at the top level; a nested `metadata` field is the parent's
+ *  own and is checked normally. */
+const CONTROLLER_SUPPLIED_KEYS = new Set(["kind", "metadata"]);
 function checkObject(value, schema, path, ctx) {
     const properties = (schema.properties ?? {});
-    const required = Array.isArray(schema.required) ? schema.required : [];
+    const isRoot = path === "base";
+    const required = (Array.isArray(schema.required) ? schema.required : []).filter((name) => !(isRoot && CONTROLLER_SUPPLIED_KEYS.has(name)));
     const additionalFalse = schema.additionalProperties === false;
     for (const req of required) {
         if (!(req in value)) {

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

@@ -14,12 +14,6 @@ export interface ContextResolveOpts {
     };
     allManifests?: Record<string, any>[];
 }
-/**
- * Resolve a type field value (string name, inline type, or raw schema) to a JSON Schema.
- * - String: look up the named type in allManifests (Type.JsonSchema resources)
- * - Object with `kind` + `schema`: inline type definition → return the `schema`
- * - Object with `type` or `properties`: raw JSON Schema, return as-is
- */
 export declare function resolveTypeFieldToSchema(value: unknown, allManifests: Record<string, any>[], ancestry?: ReadonlySet<string>): Record<string, any> | undefined;
 /**
  * Returns true when a CEL expression path (from walkCelExpressions, e.g. "routes[0].inputs.q")

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;AAGtF,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;AAED;;;;;GAKG;AACH,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,CA0CjC;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,CAmIrB;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,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,CA4IrB;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,11 +1,50 @@
 export { extractAccessChains, validateChainAgainstSchema } from "@telorun/templating";
 import { mergeTypeSchemas } 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.
  * - String: look up the named type in allManifests (Type.JsonSchema resources)
  * - Object with `kind` + `schema`: inline type definition → return the `schema`
  * - Object with `type` or `properties`: raw JSON Schema, return as-is
  */
+/**
+ * Kind names that DECLARE `capability: Telo.Type` — the kernel built-ins plus
+ * every definition in scope.
+ *
+ * Derived from the declared capability, never from the kind's spelling: which
+ * kinds are data shapes is a topology fact the analyzer must read off
+ * `Telo.Definition` docs, not guess from a name. A name test would silently miss
+ * any third-party type kind and would have to be edited every time one is added.
+ *
+ * Names, not fully-qualified kinds, because a resource writes its kind through
+ * whatever alias its file declares (`Type.JsonSchema`, `Telo.JsonSchema`,
+ * `Shapes.JsonSchema`) while the definition knows only its own module and name.
+ * Memoized per manifest list — this runs on every type-field resolution.
+ */
+const typeKindNames = new WeakMap();
+function typeCapableNames(allManifests) {
+    const cached = typeKindNames.get(allManifests);
+    if (cached)
+        return cached;
+    const names = new Set();
+    for (const def of [...KERNEL_BUILTINS, ...allManifests]) {
+        if (def?.kind !== "Telo.Definition" && def?.kind !== "Telo.Abstract")
+            continue;
+        if (def.capability !== "Telo.Type")
+            continue;
+        const name = def.metadata?.name;
+        if (typeof name === "string")
+            names.add(name);
+    }
+    typeKindNames.set(allManifests, names);
+    return names;
+}
+function isTypeKind(kind, allManifests) {
+    if (typeof kind !== "string")
+        return false;
+    const suffix = kind.slice(kind.lastIndexOf(".") + 1);
+    return typeCapableNames(allManifests).has(suffix);
+}
 export function resolveTypeFieldToSchema(value, allManifests, ancestry = new Set()) {
     if (!value)
         return undefined;
@@ -15,8 +54,7 @@ export function resolveTypeFieldToSchema(value, allManifests, ancestry = new Set
             return undefined;
         // Named type reference — find a Telo.Type resource by name
         const typeManifest = allManifests.find((m) => m.metadata?.name === value &&
-            typeof m.kind === "string" &&
-            /\bType\b/.test(m.kind) &&
+            isTypeKind(m.kind, allManifests) &&
             typeof m.schema === "object" &&
             m.schema !== null);
         if (!typeManifest)
@@ -209,11 +247,20 @@ export function resolveContextAnnotations(schema, manifestItem, opts) {
     const { manifestRoot = manifestItem, defs, aliases, allManifests } = normalizedOpts;
     const from = schema["x-telo-context-from"];
     if (from) {
-        const resolved = navigatePath(manifestItem, from.split("/"));
-        // `resolved` is a map of property names → sub-schemas (e.g. { query: {...}, body: {...} })
+        const navigated = navigatePath(manifestItem, from.split("/"));
+        // The navigated value is either a plain map of property names → sub-schemas
+        // (a transport scope's `request/schema` → `{ query, body, params }`), or a
+        // `telo#Type` field naming one contract (`inputType:`). The second form has
+        // to be resolved first: the standard library writes it as the inline
+        // `{ kind: Type.JsonSchema, schema: … }` wrapper, so merging it verbatim
+        // would type the variable as `{ kind, schema }` instead of its properties.
+        const asType = resolveTypeFieldToSchema(navigated, allManifests ?? []);
+        const resolved = asType?.properties ?? navigated;
+        const required = Array.isArray(asType?.required) ? asType.required : undefined;
         return {
             ...schema,
             properties: { ...(schema.properties ?? {}), ...(resolved ?? {}) },
+            ...(required ? { required } : {}),
             additionalProperties: false,
         };
     }

package/dist/validate-invocation-contract.d.ts

@@ -0,0 +1,30 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import type { AliasResolver } from "./alias-resolver.js";
+import type { DefinitionRegistry } from "./definition-registry.js";
+import { type AnalysisDiagnostic } from "./types.js";
+/**
+ * Phase 3 — static checks on declared invocation contracts.
+ *
+ * The runtime binds a contract to every instance and enforces it at dispatch;
+ * these are the failures worth catching before anything runs, and the ones the
+ * runtime cannot see at all (a declaration that is inert, an input nobody can
+ * supply).
+ *
+ * Diagnostics:
+ *  - CONTRACT_MISSING_MAPPING: a definition that inherits its controller declares
+ *    its own `inputType` / `outputType` without the `inputs:` / `result:` mapping
+ *    that bridges it back to the inherited controller.
+ *  - CONTRACT_INPUTS_SCHEMA_FORM: a leftover `inputs:` property map on a kind
+ *    whose input contract is now `inputType:`.
+ *  - CONTRACT_TYPE_NOT_FOUND: a contract names a type that is not declared in
+ *    scope, so every call through it would fail at dispatch.
+ *
+ * Deliberately NOT diagnosed: an input that is neither `required:` nor
+ * defaulted. It is indistinguishable from a genuinely optional one — `Ai.Text`
+ * takes `prompt` OR `messages`, and `system` is optional on purpose — so the
+ * check fired ~40 times across the standard library on correct manifests with no
+ * way for an author to record the intent. A warning that cannot be silenced on
+ * correct code teaches people to ignore warnings.
+ */
+export declare function validateInvocationContract(manifests: ResourceManifest[], registry: DefinitionRegistry, aliases: AliasResolver, aliasesByModule?: Map<string, AliasResolver>): AnalysisDiagnostic[];
+//# sourceMappingURL=validate-invocation-contract.d.ts.map

package/dist/validate-invocation-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-invocation-contract.d.ts","sourceRoot":"","sources":["../src/validate-invocation-contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AASnE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIzE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,aAAa,EACtB,eAAe,GAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAa,GACtD,kBAAkB,EAAE,CA4CtB"}