@telorun/analyzer 0.73.0 → 0.74.0

package/dist/normalize-inline-resources.js

@@ -1,4 +1,13 @@
-import { isRefEntry, isScopeEntry, isInlineResource } from "./reference-field-map.js";
+import { inlineStepTargetName } from "@telorun/sdk";
+import { isTaggedSentinel } from "@telorun/templating";
+import { controllerBearingAncestor, hasOwnControllerOrTemplate, } from "./extends-resolution.js";
+import { isForwardedDeclaration } from "./forwarded-declaration.js";
+import { definitionInScope } from "./module-alias-scope.js";
+import { isInlineResource, isRefEntry } from "./reference-field-map.js";
+import { gatherPropertySchemas } from "./schema-walk.js";
+import { declaredScopes, outsideScopesOf, scopeEncloses, scopeMembers, } from "./scope-declarations.js";
+import { forEachStep, stepBodiesOf } from "./step-bodies.js";
+import { readStepSlot } from "./step-slot.js";
 const SYSTEM_KINDS = new Set([
     "Telo.Definition",
     "Telo.Application",
@@ -44,95 +53,266 @@ function cloneForMutation(value) {
 /**
  * Phase 2 — Inline resource normalization.
  *
- * After all manifests and definitions are loaded, walks every non-system resource's
- * x-telo-ref slots. For each inline resource value (has keys beyond kind/name/metadata),
- * assigns a deterministic name, extracts it as a first-class manifest, and replaces
- * the inline value in-place with `{kind, name}`. Newly extracted resources are enqueued
- * so nested inlines are resolved in the same pass.
+ * Every inline declaration (a `{kind, …config}` with no `name`) is extracted as a
+ * first-class manifest under a deterministic name and replaced in place with
+ * `{kind, name}`. Two kinds of slot carry one:
  *
- * Naming scheme:
- *   {parentName}_{pathSegment}[_{itemName|index}]_{fieldName}
- *   e.g. TestBasicAddition_steps_AddTwoNumbers_invoke
- *        TestBasicAddition_steps_0_invoke  (when step has no name)
+ *  - a REFERENCE slot, found through the kind's field map, named
+ *    `{parentName}_{pathSegment}[_{itemName|index}]_{fieldName}`
+ *    (`TestBasicAddition_steps_AddTwoNumbers_invoke`);
+ *  - a STEP's dispatch target, at any nesting depth of a step body, named by
+ *    `inlineStepTargetName` — the name the step engine has always registered it
+ *    under, which is durable identity and so must not move with the extraction.
+ *
+ * Step slots are found through the kind's step-body annotation and walked with
+ * `walkStepArray`, never through the field map: that map is the kernel's Phase-5
+ * injection surface, and a step's target resolves at dispatch.
+ *
+ * Every extracted manifest is queued in turn, so an inline declaration nested in
+ * another's slots — a handler inside an inline step target — is extracted too.
+ * So is every member of an `x-telo-scope` array, which is a declaration of its
+ * own.
+ *
+ * WHERE an extraction is created:
+ *
+ *  - a reference slot lying in a region of a scope its owner declares (a
+ *    sequence's `targets:`) resolves against that scope, so its declaration
+ *    joins the scope's array and is created per scope run;
+ *  - a step target is created where its owner is — the module's top level, or
+ *    the scope array holding a scope member — and never in a scope the owner
+ *    declares, because that would make every step target of a sequence with a
+ *    `with:` block a scoped resource and move its durable identity;
+ *  - any other extraction is created where its owner is.
+ *
+ * A declaration written inside a scope's region and created outside it records
+ * the scope (`xTeloOrigin.outsideScopes`), and `validateScopedNameReach` reports
+ * a reference from it to a name that scope declares.
+ *
+ * An extraction out of a dependency's forwarded manifest is that dependency's
+ * code: it is stamped `forwardedInternal` (see `isForwardedDeclaration`) and
+ * carries the declaring module's `moduleGlobals`, as its parent does.
  *
  * Returns a new array of deep-cloned manifests (the rewrites land on the clones)
- * plus all extracted manifests. The caller's manifests — array and elements — are
- * never mutated; this is the analyzer's immutability boundary.
+ * plus every top-level extraction. The caller's manifests — array and elements —
+ * are never mutated; this is the analyzer's immutability boundary.
  */
 export function normalizeInlineResources(resources, registry, aliases, aliasesByModule) {
     // Deep-clone the input so this pass — and `resolveRefSentinels`, which runs on
-    // this output — never mutate caller-owned manifests. `extractInlinesAtPath`
-    // rewrites inline ref slots in place, so without cloning we'd corrupt shared
-    // state such as the editor's `LoadedFile.manifests` parse cache (a reused
-    // sentinel would be rewritten to `{kind, name}`, later misread as an authored
-    // reference form). The clone is the analyzer's immutability boundary.
+    // this output — never mutate caller-owned manifests. The extractions rewrite
+    // slots in place, so without cloning we'd corrupt shared state such as the
+    // editor's `LoadedFile.manifests` parse cache (a reused sentinel would be
+    // rewritten to `{kind, name}`, later misread as an authored reference form).
     const result = resources.map(cloneForMutation);
-    // Queue: all non-system resources with a name. Extracted resources are appended.
-    // Filter the CLONES (not the originals) so traversal mutates copies.
     // System kinds join the queue too: their inline-accepting slots are filtered
     // per entry below, so a system document is walked but only its opted-in slots
     // are extracted from.
-    const queue = result.filter((r) => typeof r.metadata?.name === "string" && !!r.kind);
-    let i = 0;
-    while (i < queue.length) {
-        const resource = queue[i++];
+    const queue = result
+        .filter((r) => typeof r.metadata?.name === "string" && !!r.kind)
+        .map((manifest) => ({
+        manifest,
+        home: undefined,
+        outside: outsideScopesOf(manifest),
+        ...provenanceOf(manifest, undefined),
+    }));
+    const place = (manifest, into, module) => {
+        if (into)
+            into.push(manifest);
+        else
+            result.push(manifest);
+        queue.push({
+            manifest: manifest,
+            home: into,
+            outside: outsideScopesOf(manifest),
+            ...provenanceOf(manifest, module),
+        });
+    };
+    for (let i = 0; i < queue.length; i++) {
+        const current = queue[i];
+        const { manifest: resource, home, outside } = current;
+        // The registry reads a kind's alias table off `metadata.module`; a scope
+        // member is looked up through a view carrying its owner's.
+        const view = current.module !== undefined && moduleOf(resource) === undefined
+            ? { ...resource, metadata: { ...resource.metadata, module: current.module } }
+            : resource;
         // When aliasesByModule is available, use the expanded map so inline refs
         // hidden behind an x-telo-schema-from indirection (e.g. an encoder inside
         // an HttpDispatch.Outcomes/$defs/Returns sub-schema) reach extraction.
         const fieldMap = aliases && aliasesByModule
-            ? registry.expandedFieldMapForResource(resource, aliases, aliasesByModule)
+            ? registry.expandedFieldMapForResource(view, aliases, aliasesByModule)
             : registry.getFieldMapForKind(resource.kind, aliases);
         if (!fieldMap)
             continue;
         const parentName = resource.metadata.name;
-        const parentModule = resource.metadata.module;
-        // Collect scope visibility prefixes so we can route extracted resources correctly.
-        const scopePrefixes = [];
-        for (const [, entry] of fieldMap) {
-            if (!isScopeEntry(entry))
-                continue;
-            const paths = Array.isArray(entry.scope) ? entry.scope : [entry.scope];
-            for (const p of paths) {
-                scopePrefixes.push(p.replace(/^\//, "").replace(/\//g, "."));
+        const parentModule = moduleOf(view);
+        const inherit = {
+            module: parentModule,
+            forwarded: current.forwarded,
+            moduleGlobals: current.moduleGlobals,
+        };
+        const scopes = declaredScopes(resource, fieldMap);
+        // Queued BEFORE anything is extracted into these arrays: an extraction
+        // queues itself, and must not be walked twice. A member is created inside
+        // this resource's scope, which is itself created where this resource is.
+        for (const scope of scopes) {
+            for (const member of scopeMembers(scope)) {
+                queue.push({ manifest: member, home: scope.declarations, outside, ...inherit });
             }
         }
+        const outsideAt = (slotPath, createdIn) => [
+            ...outside,
+            ...scopes
+                .filter((scope) => scope !== createdIn && scopeEncloses(scope, slotPath))
+                .map((scope) => ({
+                ownerKind: resource.kind,
+                ownerName: parentName,
+                field: scope.path,
+                names: scopeMembers(scope).map((member) => member.metadata.name),
+            }))
+                .filter((scope) => scope.names.length > 0),
+        ];
         for (const [fieldPath, entry] of fieldMap) {
             if (!isRefEntry(entry))
                 continue;
             if (!acceptsInline(resource.kind, entry))
                 continue;
-            const inScope = scopePrefixes.some((prefix) => fieldPath === prefix ||
-                fieldPath.startsWith(prefix + ".") ||
-                fieldPath.startsWith(prefix + "["));
-            const invocationContext = isRefEntry(entry) ? entry.context : undefined;
-            const extracted = extractInlinesAtPath(resource, fieldPath, parentName, resource.kind, parentModule, invocationContext);
-            for (const manifest of extracted) {
-                result.push(manifest);
-                queue.push(manifest);
-                // TODO Phase 5: when inScope, add to parent's scope array instead of outer set
-                void inScope;
+            const scope = scopes.find((s) => scopeEncloses(s, fieldPath));
+            for (const manifest of extractInlinesAtPath(resource, fieldPath, parentName, resource.kind, inherit, outsideAt(fieldPath, scope), entry.context)) {
+                place(manifest, scope?.declarations ?? home, parentModule);
             }
         }
+        if (SYSTEM_KINDS.has(resource.kind))
+            continue;
+        extractStepTargets(resource, view, registry, aliases, aliasesByModule, inherit, outsideAt, (m) => place(m, home, parentModule));
     }
     return result;
 }
+const moduleOf = (manifest) => {
+    const module = manifest.metadata?.module;
+    return typeof module === "string" ? module : undefined;
+};
+function provenanceOf(manifest, module) {
+    return {
+        module: moduleOf(manifest) ?? module,
+        forwarded: isForwardedDeclaration(manifest),
+        moduleGlobals: manifest.metadata?.moduleGlobals,
+    };
+}
+/**
+ * Extract every inline dispatch target of every step in `resource`'s step
+ * bodies, at any nesting depth, into a named manifest.
+ *
+ * The name is the step engine's, so it names what the RUNTIME owner passes it:
+ *
+ *  - the owner kind is the kind whose CONTROLLER runs the body — the kind
+ *    itself, or for an `extends` child that inherits its controller, the
+ *    ancestor that supplies it;
+ *  - the path's first segment is the field the controller reads its body from.
+ *    For a `base:`-form child that is the PARENT's field the body is mapped onto,
+ *    which is taken from a pure `self.<field>` mapping; a body `base:` reshapes any
+ *    other way is left inline, for the runtime to name exactly as it always has;
+ *  - an inline declaration stating its own `metadata.name` keeps it, as
+ *    `ensureKindRef` always has.
+ */
+function extractStepTargets(resource, view, registry, aliases, aliasesByModule, inherit, outsideAt, emit) {
+    const definition = definitionInScope(registry, view.kind, view.metadata, aliases, aliasesByModule);
+    if (!definition)
+        return;
+    const schema = registry.effectiveSchemaOf(definition);
+    if (!schema)
+        return;
+    const resolveDef = (kind, from) => definitionInScope(registry, kind, from?.metadata, aliases, aliasesByModule);
+    const runner = hasOwnControllerOrTemplate(definition)
+        ? definition
+        : (controllerBearingAncestor(definition, resolveDef) ?? definition);
+    const owner = { kind: runner.metadata.name, resourceName: resource.metadata.name };
+    const base = runner !== definition ? definition.base : undefined;
+    for (const body of stepBodiesOf(resource, schema)) {
+        const root = base === undefined ? body.field : mappedStepField(base, body.field, runner, registry);
+        if (root === undefined)
+            continue;
+        const outsideScopes = outsideAt(body.field);
+        forEachStep(body, schema, (step, stepPath) => {
+            const target = step[body.invokeField];
+            if (!target || typeof target !== "object" || Array.isArray(target))
+                return;
+            if (!isInlineResource(target))
+                return;
+            // The step grammar requires a name, and a target is named after it; a step
+            // without one is reported by schema validation and left as written.
+            if (typeof step.name !== "string")
+                return;
+            const inline = target;
+            const declared = inline.metadata?.name;
+            const name = typeof declared === "string"
+                ? declared
+                : inlineStepTargetName(owner, [root, ...stepPathSegments(stepPath).slice(1)], step.name);
+            step[body.invokeField] = { kind: inline.kind, name };
+            emit(buildManifest(inline, name, {
+                parentKind: resource.kind,
+                parentName: resource.metadata.name,
+                pathFromParent: `${stepPath}.${body.invokeField}`,
+                stepTarget: true,
+                ...(outsideScopes.length > 0 ? { outsideScopes } : {}),
+            }, inherit));
+        });
+    }
+}
+/** The runner's step field a `base:` mapping forwards `field` into, when it does
+ *  so verbatim (`steps: !cel "self.<field>"`); undefined otherwise. */
+function mappedStepField(base, field, runner, registry) {
+    if (!base || typeof base !== "object" || Array.isArray(base))
+        return undefined;
+    const runnerSchema = registry.effectiveSchemaOf(runner);
+    if (!runnerSchema)
+        return undefined;
+    const runnerSteps = new Set(gatherPropertySchemas(runnerSchema)
+        .filter(([, schema]) => readStepSlot(schema) !== undefined)
+        .map(([key]) => key));
+    for (const [target, value] of Object.entries(base)) {
+        if (runnerSteps.has(target) && pureSelfField(value) === field)
+            return target;
+    }
+    return undefined;
+}
+/** `f` for a CEL value that is exactly `self.f`, in any spelling it arrives in. */
+function pureSelfField(value) {
+    let source;
+    if (isTaggedSentinel(value)) {
+        if (value.engine === "cel")
+            source = value.source;
+    }
+    else if (value && typeof value === "object" && value.__compiled) {
+        const compiled = value.source;
+        if (typeof compiled === "string")
+            source = compiled;
+    }
+    else if (typeof value === "string") {
+        source = /^\s*\$\{\{([\s\S]*)\}\}\s*$/.exec(value)?.[1];
+    }
+    return source === undefined ? undefined : /^self\.([A-Za-z_$][\w$]*)$/.exec(source.trim())?.[1];
+}
+/** `steps[1].cases.a[0]` → `["steps", "1", "cases", "a", "0"]`. Exact even for a
+ *  case key holding punctuation: the name keeps only alphanumeric runs, so
+ *  splitting inside a key cannot change it. */
+function stepPathSegments(path) {
+    return path.split(/[.[\]]/).filter((segment) => segment.length > 0);
+}
 /**
  * Walks `resource` following `fieldPath` (dot notation, `[]` = array traversal).
  * Mutates the resource in-place: replaces each inline value with `{kind, name}`.
  * Returns the extracted manifests.
- *
- * Each extracted manifest carries `metadata.xTeloOrigin` so downstream
- * diagnostics can be rerouted back to the parent doc's YAML position:
- *   - `parentKind` / `parentName` — the resource that owned the inline slot
- *   - `pathFromParent` — concrete dotted path with `[N]` indices, matching
- *     `buildPositionIndex` keys (e.g. `routes[0].handler`)
  */
-function extractInlinesAtPath(resource, fieldPath, parentName, parentKind, parentModule, invocationContext) {
+function extractInlinesAtPath(resource, fieldPath, parentName, parentKind, inherit, outsideScopes, invocationContext) {
     const extracted = [];
     const parts = fieldPath.split(".");
     function emit(inline, nameSegments, concretePath) {
         const name = sanitizeName([parentName, ...nameSegments].join("_"));
-        extracted.push(buildManifest(inline, name, parentKind, parentName, concretePath, parentModule, invocationContext));
+        extracted.push(buildManifest(inline, name, {
+            parentKind,
+            parentName,
+            pathFromParent: concretePath,
+            ...(outsideScopes.length > 0 ? { outsideScopes } : {}),
+        }, inherit, invocationContext));
         return name;
     }
     function traverse(obj, partsLeft, nameParts, pathSoFar) {
@@ -207,7 +387,7 @@ function extractInlinesAtPath(resource, fieldPath, parentName, parentKind, paren
     traverse(resource, parts, [], "");
     return extracted;
 }
-function buildManifest(inline, name, parentKind, parentName, pathFromParent, parentModule, invocationContext) {
+function buildManifest(inline, name, origin, inherit, invocationContext) {
     const existingMeta = inline.metadata && typeof inline.metadata === "object"
         ? inline.metadata
         : {};
@@ -217,9 +397,11 @@ function buildManifest(inline, name, parentKind, parentName, pathFromParent, par
             ...existingMeta,
             name,
             // Inherit parent module only if the inline doesn't already declare one
-            ...(parentModule && !existingMeta.module ? { module: parentModule } : {}),
+            ...(inherit.module && !existingMeta.module ? { module: inherit.module } : {}),
+            ...(inherit.forwarded ? { forwardedInternal: true } : {}),
+            ...(inherit.moduleGlobals !== undefined ? { moduleGlobals: inherit.moduleGlobals } : {}),
             ...(invocationContext ? { xTeloInvocationContext: invocationContext } : {}),
-            xTeloOrigin: { parentKind, parentName, pathFromParent },
+            xTeloOrigin: origin,
         },
     };
 }

package/dist/reference-field-map.d.ts

@@ -1,4 +1,5 @@
-import { type RefUse, type RefUseCases } from "./ref-slot.js";
+import { type RefSlot, type RefUse, type RefUseCases } from "./ref-slot.js";
+import { type StepSlot } from "./step-slot.js";
 export { readRefSlot, isRefSlot, hasDeclaredUse } from "./ref-slot.js";
 export type { RefSlot, RefUse, RefUseCases } from "./ref-slot.js";
 /** An entry for a field that carries one or more x-telo-ref constraints. */
@@ -36,6 +37,39 @@ export interface RefFieldEntry {
      *  an unconditional opt-in would rewrite the value into a valid shape before
      *  the schema ever saw it. */
     inline?: boolean;
+    /** See {@link RefSlot.throwsThrough}. */
+    throwsThrough?: boolean;
+}
+/** The slot an entry records, as `readRefSlot` read it. */
+export declare function refSlotOfEntry(entry: RefFieldEntry): RefSlot;
+/** Everything a driven-slot map records at one field path. */
+export interface DrivenPath {
+    /** Every reference slot declared here, by any branch. Kept apart rather than
+     *  merged into one slot and read as a union: a branch that does not apply to a
+     *  resource can only ADD what counts — more coverage demanded, never less — and
+     *  one merged slot could not hold two case-map selectors or a branch that
+     *  declares no use. */
+    refs: RefFieldEntry[];
+    /** Every step body declared here, by any branch. */
+    steps: StepSlot[];
+    /** Back-edges of a recursive schema: the schema here is also the one entered
+     *  at each of these paths, so everything below them applies again below this
+     *  one, as deep as a resource's data goes. Recorded BESIDE `refs`, never in
+     *  place of them — a `!ref` here resolves as a reference, an inline object
+     *  recurses. */
+    recurse: string[];
+}
+/** See {@link buildDrivenSlotMap}. */
+export interface DrivenSlots {
+    paths: Map<string, DrivenPath>;
+    /** Per `{}` field path, the keys JSON Schema does NOT apply that
+     *  `additionalProperties` to: those the same schema declares under
+     *  `properties`, plus the resource envelope at the root. Where several schemas
+     *  meet at one `{}` path, only keys every one of them declares are skipped. */
+    declaredKeys: Map<string, Set<string>>;
+    /** True when some path holds a step or reference slot. A map of back-edges
+     *  alone drives nothing, so a walk over it is skipped. */
+    drives: boolean;
 }
 /** An entry for a field that declares an execution scope (x-telo-scope). */
 export interface ScopeFieldEntry {
@@ -139,4 +173,28 @@ export declare function collectRefs(node: Record<string, any>): string[];
  *  inline normalization and Phase 5 injection see slots that the local field map
  *  hid behind the schema-from indirection. */
 export declare function buildFieldMapAtPath(schema: Record<string, any>, pathPrefix: string): ReferenceFieldMap;
+/**
+ * Every slot through which a resource of this schema DRIVES another — the
+ * reference field map's own traversal, plus what a dispatch analysis needs and
+ * the injection surface must not have:
+ *
+ * - local `$ref` is followed, resolved against the root. The injection map
+ *   stops there so a step's `invoke` never becomes an injection site; this map
+ *   stops AT a step body instead, which removes that reason. A reference back
+ *   to a node already on the descent is recorded as a back-edge rather than
+ *   unrolled, so a recursive shape stays finite here and is followed as deep as
+ *   the data goes by `forEachDrivenSlot`;
+ * - a step body is recorded and not descended — the step traversal owns
+ *   everything below it;
+ * - the root's own variant branches and `additionalProperties` are walked, not
+ *   only its `properties`;
+ * - a path keeps EVERY slot any branch declares there, where the injection map
+ *   keeps the last one written (see {@link DrivenPath.refs});
+ * - each `{}` path records the keys its `additionalProperties` does not cover.
+ *
+ * Shared by every throws question (a kind's `inherit` union, a scope list's
+ * denominator, catch-scope enclosure, and whether `inherit` is legal at all),
+ * so none can reach a slot another cannot. Memoized per schema object.
+ */
+export declare function buildDrivenSlotMap(schema: Record<string, any>): DrivenSlots;
 //# sourceMappingURL=reference-field-map.d.ts.map

package/dist/reference-field-map.d.ts.map

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