@telorun/analyzer 0.20.0 → 0.21.0

package/README.md

@@ -55,8 +55,8 @@ metadata:
     A complete feedback collection REST API — no code, pure YAML.
     Persists entries to SQLite and serves them over HTTP.
 imports:
-  Http: std/http-server@0.8.0
-  Sql: std/sql@0.5.1
+  Http: std/http-server@0.9.0
+  Sql: std/sql@0.8.0
 targets:
   - Migrations
   - Server

package/dist/reference-field-map.js

@@ -175,6 +175,8 @@ function traverseNode(node, path, map, root, visitedRefs = new Set()) {
         }
         return;
     }
+    if (typeof node?.$ref === "string")
+        return;
     // Array — recurse into items
     if (node.type === "array" && node.items) {
         traverseNode(node.items, path + "[]", map, root, visitedRefs);

package/dist/resolve-ref-sentinels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-ref-sentinels.d.ts","sourceRoot":"","sources":["../src/resolve-ref-sentinels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAQnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EAK5C,kBAAkB,GAAE,gBAAgB,EAAO,GAC1C,IAAI,CAwEN"}
+{"version":3,"file":"resolve-ref-sentinels.d.ts","sourceRoot":"","sources":["../src/resolve-ref-sentinels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAQnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EAK5C,kBAAkB,GAAE,gBAAgB,EAAO,GAC1C,IAAI,CAmFN"}

package/dist/resolve-ref-sentinels.js

@@ -1,5 +1,5 @@
 import { isRefSentinel } from "@telorun/templating";
-import { isRefEntry } from "./reference-field-map.js";
+import { isRefEntry, isScopeEntry } from "./reference-field-map.js";
 import { REF_RESOLUTION_SKIP_KINDS as SYSTEM_KINDS } from "./system-kinds.js";
 /**
  * Walks every `x-telo-ref` slot in every non-system resource and rewrites
@@ -81,22 +81,80 @@ crossModuleTargets = []) {
         }
         return undefined;
     };
-    for (const r of resources) {
+    const processResource = (r) => {
         if (!r.metadata?.name || !r.kind || SYSTEM_KINDS.has(r.kind))
-            continue;
-        if (isForeign(r))
-            continue;
+            return;
         const fieldMap = aliases && aliasesByModule
             ? registry.expandedFieldMapForResource(r, aliases, aliasesByModule)
             : registry.getFieldMapForKind(r.kind, aliases);
         if (!fieldMap)
-            continue;
+            return;
         for (const [fieldPath, entry] of fieldMap) {
-            if (!isRefEntry(entry))
+            const parts = fieldPath.split(".");
+            if (isRefEntry(entry)) {
+                descend(r, parts, resolveTarget);
+            }
+            else if (isScopeEntry(entry)) {
+                // x-telo-scope resources (e.g. a Run.Sequence `with` server) carry their own ref
+                // slots. The top-level walk skips scope contents, so recurse so a scoped resource's
+                // `!ref` (e.g. an Http.Server mount) is canonicalized to {kind, name} like any other.
+                forEachScopeResource(r, parts, processResource);
+            }
+        }
+    };
+    for (const r of resources) {
+        if (isForeign(r))
+            continue;
+        processResource(r);
+    }
+}
+/**
+ * Navigates `obj` along the scope field path (dot notation, `[]` = array items) and
+ * invokes `cb` on every resource-like object found — any value carrying a `kind` string.
+ *
+ * Two-phase design:
+ *
+ *  Phase 1 — path-walk: steps through each `parts` segment. `[]`-suffixed parts spread
+ *  the array into individual elements so `current` always ends up holding scalars or
+ *  plain objects, never intermediate arrays. Non-`[]` parts push the value as-is.
+ *
+ *  Phase 2 — terminal visit: after the walk, `current` contains the values at the end
+ *  of the path. These are always scalars or plain objects because of the `[]` spreading
+ *  above, EXCEPT when a scope field is typed as an array in the schema but the path
+ *  was authored WITHOUT a `[]` suffix. The `visit` function handles that case by
+ *  recursing one level into arrays so `cb` is always called on resource objects, not
+ *  on their container.
+ */
+function forEachScopeResource(obj, parts, cb) {
+    let current = [obj];
+    for (const part of parts) {
+        const isArr = part.endsWith("[]");
+        const key = isArr ? part.slice(0, -2) : part;
+        const next = [];
+        for (const node of current) {
+            if (!node || typeof node !== "object")
+                continue;
+            const val = node[key];
+            if (val == null)
                 continue;
-            descend(r, fieldPath.split("."), resolveTarget);
+            if (isArr && Array.isArray(val))
+                next.push(...val);
+            else if (!isArr)
+                next.push(val);
         }
+        current = next;
     }
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            for (const elem of node)
+                visit(elem);
+        }
+        else if (node && typeof node === "object" && typeof node.kind === "string") {
+            cb(node);
+        }
+    };
+    for (const node of current)
+        visit(node);
 }
 /** Walks `obj` along `fieldPath` parts (dot notation with `[]` for arrays and `{}` for
  *  additionalProperties-typed maps) and replaces any `!ref` sentinel at the terminal slot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -37,18 +37,18 @@
     "src/**"
   ],
   "dependencies": {
-    "@marcbachmann/cel-js": "^7.5.3",
+    "@marcbachmann/cel-js": "^7.6.1",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "jsonpath-plus": "^10.3.0",
     "yaml": "^2.8.3",
-    "@telorun/templating": "0.6.0"
+    "@telorun/templating": "0.7.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.1.8",
-    "@telorun/sdk": "0.21.0"
+    "@telorun/sdk": "0.23.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/reference-field-map.ts

@@ -229,6 +229,7 @@ function traverseNode(
     }
     return;
   }
+  if (typeof node?.$ref === "string") return;
 
   // Array — recurse into items
   if (node.type === "array" && node.items) {

package/src/resolve-ref-sentinels.ts

@@ -2,7 +2,7 @@ import type { ResourceManifest } from "@telorun/sdk";
 import { isRefSentinel } from "@telorun/templating";
 import type { AliasResolver } from "./alias-resolver.js";
 import type { DefinitionRegistry } from "./definition-registry.js";
-import { isRefEntry } from "./reference-field-map.js";
+import { isRefEntry, isScopeEntry } from "./reference-field-map.js";
 import { REF_RESOLUTION_SKIP_KINDS as SYSTEM_KINDS } from "./system-kinds.js";
 
 /** Resolved ref shape written in place of a `!ref` sentinel. `alias` is set only for
@@ -96,21 +96,78 @@ export function resolveRefSentinels(
     return undefined;
   };
 
-  for (const r of resources) {
-    if (!r.metadata?.name || !r.kind || SYSTEM_KINDS.has(r.kind)) continue;
-    if (isForeign(r)) continue;
+  const processResource = (r: ResourceManifest): void => {
+    if (!r.metadata?.name || !r.kind || SYSTEM_KINDS.has(r.kind)) return;
 
     const fieldMap =
       aliases && aliasesByModule
         ? registry.expandedFieldMapForResource(r, aliases, aliasesByModule)
         : registry.getFieldMapForKind(r.kind, aliases);
-    if (!fieldMap) continue;
+    if (!fieldMap) return;
 
     for (const [fieldPath, entry] of fieldMap) {
-      if (!isRefEntry(entry)) continue;
-      descend(r as Record<string, unknown>, fieldPath.split("."), resolveTarget);
+      const parts = fieldPath.split(".");
+      if (isRefEntry(entry)) {
+        descend(r as Record<string, unknown>, parts, resolveTarget);
+      } else if (isScopeEntry(entry)) {
+        // x-telo-scope resources (e.g. a Run.Sequence `with` server) carry their own ref
+        // slots. The top-level walk skips scope contents, so recurse so a scoped resource's
+        // `!ref` (e.g. an Http.Server mount) is canonicalized to {kind, name} like any other.
+        forEachScopeResource(r as Record<string, unknown>, parts, processResource);
+      }
+    }
+  };
+
+  for (const r of resources) {
+    if (isForeign(r)) continue;
+    processResource(r);
+  }
+}
+
+/**
+ * Navigates `obj` along the scope field path (dot notation, `[]` = array items) and
+ * invokes `cb` on every resource-like object found — any value carrying a `kind` string.
+ *
+ * Two-phase design:
+ *
+ *  Phase 1 — path-walk: steps through each `parts` segment. `[]`-suffixed parts spread
+ *  the array into individual elements so `current` always ends up holding scalars or
+ *  plain objects, never intermediate arrays. Non-`[]` parts push the value as-is.
+ *
+ *  Phase 2 — terminal visit: after the walk, `current` contains the values at the end
+ *  of the path. These are always scalars or plain objects because of the `[]` spreading
+ *  above, EXCEPT when a scope field is typed as an array in the schema but the path
+ *  was authored WITHOUT a `[]` suffix. The `visit` function handles that case by
+ *  recursing one level into arrays so `cb` is always called on resource objects, not
+ *  on their container.
+ */
+function forEachScopeResource(
+  obj: Record<string, unknown>,
+  parts: string[],
+  cb: (resource: ResourceManifest) => void,
+): void {
+  let current: unknown[] = [obj];
+  for (const part of parts) {
+    const isArr = part.endsWith("[]");
+    const key = isArr ? part.slice(0, -2) : part;
+    const next: unknown[] = [];
+    for (const node of current) {
+      if (!node || typeof node !== "object") continue;
+      const val = (node as Record<string, unknown>)[key];
+      if (val == null) continue;
+      if (isArr && Array.isArray(val)) next.push(...val);
+      else if (!isArr) next.push(val);
     }
+    current = next;
   }
+  const visit = (node: unknown): void => {
+    if (Array.isArray(node)) {
+      for (const elem of node) visit(elem);
+    } else if (node && typeof node === "object" && typeof (node as { kind?: unknown }).kind === "string") {
+      cb(node as ResourceManifest);
+    }
+  };
+  for (const node of current) visit(node);
 }
 
 /** Walks `obj` along `fieldPath` parts (dot notation with `[]` for arrays and `{}` for