@telorun/analyzer 0.17.0 → 0.19.0

package/README.md

@@ -55,7 +55,7 @@ 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.6.1
+  Http: std/http-server@0.8.0
   Sql: std/sql@0.5.1
 targets:
   - Migrations

package/dist/analysis-registry.d.ts

@@ -1,6 +1,23 @@
 import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
 import { type ManifestVisitor } from "./manifest-visitor.js";
 import type { AnalysisContext } from "./types.js";
+/** One reference field declared by a resource's definition, derived purely from
+ *  the schema field map (independent of whether the manifest fills it). Editor
+ *  hosts render these as ports / adapters on a node. */
+export interface RefFieldInfo {
+    /** Field-map path with `[]` / `{}` markers (e.g. `targets[]`,
+     *  `routes[].handler`, `encoder`). */
+    path: string;
+    /** True when the path traverses at least one array. */
+    isArray: boolean;
+    /** Accepted `x-telo-ref` constraint strings (e.g. `telo#Runnable`). */
+    refs: string[];
+    /** Distinct capabilities the slot may target (`Telo.Runnable`,
+     *  `Telo.Service`, `Telo.Provider`, …) — one per resolvable constraint. The
+     *  first classifies the port (node-capability → edge, ambient → picker); the
+     *  full set validates drag-to-wire endpoints. Empty when none resolve. */
+    capabilities: string[];
+}
 /**
  * Accumulates type and alias knowledge for a running kernel or analysis session.
  * Wraps AliasResolver and DefinitionRegistry into a single domain-level interface
@@ -23,6 +40,38 @@ export declare class AnalysisRegistry {
      * sub-schema (e.g. Server.notFoundHandler.returns[].content[mime].encoder).
      */
     iterateFieldEntries(resource: ResourceManifest, onRef: (fieldPath: string) => void, onScope: (fieldPath: string) => void): void;
+    /**
+     * Returns every reference field a resource's definition declares, with arity
+     * and the capability each slot targets — derived purely from the schema field
+     * map, so it lists slots even when the manifest leaves them empty. Editor
+     * hosts render these as node ports (drag-to-wire for node-capability targets,
+     * inline picker for ambient targets).
+     */
+    refFieldsForResource(resource: ResourceManifest): RefFieldInfo[];
+    /** Base capability an `x-telo-ref` constraint targets. A definition's declared
+     *  `capability` is always one of the base capabilities, so it wins — this
+     *  resolves user-defined abstracts (e.g. `std/ai#Model`, declared
+     *  `capability: Telo.Invocable`) to the capability instances satisfy, not the
+     *  abstract kind. Builtin abstracts (`telo#Runnable`) carry no `capability`
+     *  field — there the kind itself *is* the capability. Undefined when
+     *  unresolvable. */
+    capabilityForRef(xTeloRef: string): string | undefined;
+    /** Resolves the JSON Schema for a kind's `invoke()` inputs, for editor hosts
+     *  that render a typed inputs form. Two-layer fallback mirroring the analyzer's
+     *  template inputs typing: the definition's own `inputType`, then the
+     *  `extends`-declared abstract's `inputType`. Resolves the inline
+     *  (`{ kind: Type.JsonSchema, schema }`) and raw-schema forms; a bare named
+     *  type reference is left unresolved (returns undefined) so the caller can fall
+     *  back to a freeform map. Undefined when the kind declares no input contract. */
+    inputTypeForKind(kind: string): Record<string, unknown> | undefined;
+    /** Resolves the JSON Schema for a kind's `invoke()` / `run()` output, for
+     *  editor hosts that render a typed output signature. Mirrors
+     *  {@link inputTypeForKind}: the definition's own `outputType`, then the
+     *  `extends`-declared abstract's `outputType`. Resolves the inline and
+     *  raw-schema forms; a bare named type reference is left unresolved. Undefined
+     *  when the kind declares no output contract. */
+    outputTypeForKind(kind: string): Record<string, unknown> | undefined;
+    private capabilitiesForRefs;
     /**
      * Walks a manifest's annotation sites (refs, scopes, schema-from, CEL) via
      * the shared manifest visitor, bound to this registry's definitions and
@@ -54,6 +103,16 @@ export declare class AnalysisRegistry {
     /** Returns the closest user-facing kind to `badKind`, or undefined when nothing
      *  is close enough (or multiple candidates tie). Case-sensitive. */
     suggestKind(badKind: string): string | undefined;
+    /** Returns the **canonical** (`module.Type`) kinds that satisfy an `x-telo-ref`
+     *  constraint — an abstract target expands to its implementations (via the
+     *  extends / capability index), a concrete target yields just itself.
+     *  Resolution mirrors `validateReferences.checkKind`. Unlike
+     *  {@link userFacingKindsForRef} this is import-independent: it includes
+     *  locally-defined kinds (no alias), so callers can test whether an existing
+     *  resource's kind satisfies the ref by canonicalizing it (`resolveKind`) and
+     *  membership-checking here. Returns `undefined` when the ref can't be
+     *  resolved (e.g. unregistered identity). */
+    acceptedKindsForRef(xTeloRef: string): Set<string> | undefined;
     /** Returns every user-facing (alias-form) kind that satisfies the given
      *  `x-telo-ref` constraint string (e.g. `"telo#Invocable"`, `"std/sql#Connection"`).
      *  Resolution mirrors `validateReferences.checkKind`: abstract targets expand to

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

@@ -1 +1 @@
-{"version":3,"file":"analysis-registry.d.ts","sourceRoot":"","sources":["../src/analysis-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKzE,OAAO,EAAqC,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAEhG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;GAIG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IAEpE,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI;IAIjD,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAIpE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAIpE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7C;;;;;;;OAOG;IACH,mBAAmB,CACjB,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,EAClC,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GACnC,IAAI;IAkBP;;;;;;OAMG;IACH,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,EACxB,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;KAAE,GACzF,IAAI;IAQP;;;;OAIG;IACH,kBAAkB,IAAI,kBAAkB,EAAE;IAI1C,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAM/D,QAAQ,IAAI,MAAM,EAAE;IAIpB;mEAC+D;IAC/D,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAIxC;;;gCAG4B;IAC5B,oBAAoB,IAAI,MAAM,EAAE;IAIhC;wEACoE;IACpE,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIhD;;;;;gEAK4D;IAC5D,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IA+B7D,qFAAqF;IACrF,QAAQ,IAAI,eAAe;CAG5B"}
+{"version":3,"file":"analysis-registry.d.ts","sourceRoot":"","sources":["../src/analysis-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKzE,OAAO,EAAqC,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAEhG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD;;wDAEwD;AACxD,MAAM,WAAW,YAAY;IAC3B;0CACsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,OAAO,EAAE,OAAO,CAAC;IACjB,uEAAuE;IACvE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;8EAG0E;IAC1E,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;GAIG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IAEpE,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,GAAG,IAAI;IAIjD,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAIpE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAIpE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7C;;;;;;;OAOG;IACH,mBAAmB,CACjB,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,EAClC,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GACnC,IAAI;IAkBP;;;;;;OAMG;IACH,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,YAAY,EAAE;IAoBhE;;;;;;wBAMoB;IACpB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAQtD;;;;;;sFAMkF;IAClF,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAenE;;;;;qDAKiD;IACjD,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAepE,OAAO,CAAC,mBAAmB;IAS3B;;;;;;OAMG;IACH,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,EACxB,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;KAAE,GACzF,IAAI;IAQP;;;;OAIG;IACH,kBAAkB,IAAI,kBAAkB,EAAE;IAI1C,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAM/D,QAAQ,IAAI,MAAM,EAAE;IAIpB;mEAC+D;IAC/D,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAIxC;;;gCAG4B;IAC5B,oBAAoB,IAAI,MAAM,EAAE;IAIhC;wEACoE;IACpE,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIhD;;;;;;;;iDAQ6C;IAC7C,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,SAAS;IAoB9D;;;;;gEAK4D;IAC5D,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAiB7D,qFAAqF;IACrF,QAAQ,IAAI,eAAe;CAG5B"}

package/dist/analysis-registry.js

@@ -4,6 +4,7 @@ import { DefinitionRegistry } from "./definition-registry.js";
 import { computeSuggestKind, computeValidUserFacingKinds } from "./kind-suggest.js";
 import { visitManifest as runVisitManifest } from "./manifest-visitor.js";
 import { isRefEntry, isScopeEntry } from "./reference-field-map.js";
+import { resolveTypeFieldToSchema } from "./validate-cel-context.js";
 /**
  * Accumulates type and alias knowledge for a running kernel or analysis session.
  * Wraps AliasResolver and DefinitionRegistry into a single domain-level interface
@@ -47,6 +48,102 @@ export class AnalysisRegistry {
             }
         }
     }
+    /**
+     * Returns every reference field a resource's definition declares, with arity
+     * and the capability each slot targets — derived purely from the schema field
+     * map, so it lists slots even when the manifest leaves them empty. Editor
+     * hosts render these as node ports (drag-to-wire for node-capability targets,
+     * inline picker for ambient targets).
+     */
+    refFieldsForResource(resource) {
+        const fieldMap = this.defs.expandedFieldMapForResource(resource, this.aliases, this.aliasesByModule);
+        if (!fieldMap)
+            return [];
+        const out = [];
+        for (const [path, entry] of fieldMap) {
+            if (!isRefEntry(entry))
+                continue;
+            out.push({
+                path,
+                isArray: entry.isArray,
+                refs: entry.refs,
+                capabilities: this.capabilitiesForRefs(entry.refs),
+            });
+        }
+        return out;
+    }
+    /** Base capability an `x-telo-ref` constraint targets. A definition's declared
+     *  `capability` is always one of the base capabilities, so it wins — this
+     *  resolves user-defined abstracts (e.g. `std/ai#Model`, declared
+     *  `capability: Telo.Invocable`) to the capability instances satisfy, not the
+     *  abstract kind. Builtin abstracts (`telo#Runnable`) carry no `capability`
+     *  field — there the kind itself *is* the capability. Undefined when
+     *  unresolvable. */
+    capabilityForRef(xTeloRef) {
+        const kind = this.defs.resolveRef(xTeloRef);
+        if (!kind)
+            return undefined;
+        const def = this.defs.resolve(kind);
+        if (!def)
+            return undefined;
+        return def.capability ?? kind;
+    }
+    /** Resolves the JSON Schema for a kind's `invoke()` inputs, for editor hosts
+     *  that render a typed inputs form. Two-layer fallback mirroring the analyzer's
+     *  template inputs typing: the definition's own `inputType`, then the
+     *  `extends`-declared abstract's `inputType`. Resolves the inline
+     *  (`{ kind: Type.JsonSchema, schema }`) and raw-schema forms; a bare named
+     *  type reference is left unresolved (returns undefined) so the caller can fall
+     *  back to a freeform map. Undefined when the kind declares no input contract. */
+    inputTypeForKind(kind) {
+        const def = this.resolveDefinition(kind);
+        if (!def)
+            return undefined;
+        const own = resolveTypeFieldToSchema(def.inputType, []);
+        if (own)
+            return own;
+        if (def.extends) {
+            const abstractDef = this.resolveDefinition(def.extends);
+            if (abstractDef) {
+                const inherited = resolveTypeFieldToSchema(abstractDef.inputType, []);
+                if (inherited)
+                    return inherited;
+            }
+        }
+        return undefined;
+    }
+    /** Resolves the JSON Schema for a kind's `invoke()` / `run()` output, for
+     *  editor hosts that render a typed output signature. Mirrors
+     *  {@link inputTypeForKind}: the definition's own `outputType`, then the
+     *  `extends`-declared abstract's `outputType`. Resolves the inline and
+     *  raw-schema forms; a bare named type reference is left unresolved. Undefined
+     *  when the kind declares no output contract. */
+    outputTypeForKind(kind) {
+        const def = this.resolveDefinition(kind);
+        if (!def)
+            return undefined;
+        const own = resolveTypeFieldToSchema(def.outputType, []);
+        if (own)
+            return own;
+        if (def.extends) {
+            const abstractDef = this.resolveDefinition(def.extends);
+            if (abstractDef) {
+                const inherited = resolveTypeFieldToSchema(abstractDef.outputType, []);
+                if (inherited)
+                    return inherited;
+            }
+        }
+        return undefined;
+    }
+    capabilitiesForRefs(refs) {
+        const out = [];
+        for (const ref of refs) {
+            const cap = this.capabilityForRef(ref);
+            if (cap && !out.includes(cap))
+                out.push(cap);
+        }
+        return out;
+    }
     /**
      * Walks a manifest's annotation sites (refs, scopes, schema-from, CEL) via
      * the shared manifest visitor, bound to this registry's definitions and
@@ -94,31 +191,46 @@ export class AnalysisRegistry {
     suggestKind(badKind) {
         return computeSuggestKind(badKind, this.aliases, this.defs);
     }
-    /** Returns every user-facing (alias-form) kind that satisfies the given
-     *  `x-telo-ref` constraint string (e.g. `"telo#Invocable"`, `"std/sql#Connection"`).
-     *  Resolution mirrors `validateReferences.checkKind`: abstract targets expand to
-     *  the set of definitions extending them; concrete targets yield just themselves.
-     *  Returns `undefined` when the ref can't be resolved (e.g. unregistered identity),
-     *  so callers can fall back to the unfiltered kind list. */
-    userFacingKindsForRef(xTeloRef) {
+    /** Returns the **canonical** (`module.Type`) kinds that satisfy an `x-telo-ref`
+     *  constraint — an abstract target expands to its implementations (via the
+     *  extends / capability index), a concrete target yields just itself.
+     *  Resolution mirrors `validateReferences.checkKind`. Unlike
+     *  {@link userFacingKindsForRef} this is import-independent: it includes
+     *  locally-defined kinds (no alias), so callers can test whether an existing
+     *  resource's kind satisfies the ref by canonicalizing it (`resolveKind`) and
+     *  membership-checking here. Returns `undefined` when the ref can't be
+     *  resolved (e.g. unregistered identity). */
+    acceptedKindsForRef(xTeloRef) {
         const targetKind = this.defs.resolveRef(xTeloRef);
         if (!targetKind)
             return undefined;
         const targetDef = this.defs.resolve(targetKind);
         if (!targetDef)
             return undefined;
-        const canonicalKinds = [];
+        const out = new Set();
         if (targetDef.kind === "Telo.Abstract") {
             for (const def of this.defs.getByExtends(targetKind)) {
                 const module = def.metadata?.module;
                 if (module && def.metadata?.name) {
-                    canonicalKinds.push(`${module}.${def.metadata.name}`);
+                    out.add(`${module}.${def.metadata.name}`);
                 }
             }
         }
         else {
-            canonicalKinds.push(targetKind);
+            out.add(targetKind);
         }
+        return out;
+    }
+    /** Returns every user-facing (alias-form) kind that satisfies the given
+     *  `x-telo-ref` constraint string (e.g. `"telo#Invocable"`, `"std/sql#Connection"`).
+     *  Resolution mirrors `validateReferences.checkKind`: abstract targets expand to
+     *  the set of definitions extending them; concrete targets yield just themselves.
+     *  Returns `undefined` when the ref can't be resolved (e.g. unregistered identity),
+     *  so callers can fall back to the unfiltered kind list. */
+    userFacingKindsForRef(xTeloRef) {
+        const canonicalKinds = this.acceptedKindsForRef(xTeloRef);
+        if (!canonicalKinds)
+            return undefined;
         const out = new Set();
         for (const kind of canonicalKinds) {
             const dot = kind.indexOf(".");

package/dist/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAiB9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAuhB/F,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,OAAO,GAAE,qBAA0B;IAI/C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAypBvB,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAMvB,SAAS,CACP,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,EAI1B,kBAAkB,CAAC,EAAE,gBAAgB,EAAE,GACtC,gBAAgB,EAAE;IAqBrB,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,GACzB;QAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;CAsB5F"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAiB9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AA2hB/F,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,OAAO,GAAE,qBAA0B;IAI/C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAypBvB,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAMvB,SAAS,CACP,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,EAI1B,kBAAkB,CAAC,EAAE,gBAAgB,EAAE,GACtC,gBAAgB,EAAE;IAqBrB,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,GACzB;QAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;CAsB5F"}

package/dist/analyzer.js

@@ -442,8 +442,11 @@ function collectCelTypeIssues(data, schema, path, definition, manifest, baseType
     }
     else if (data !== null && typeof data === "object") {
         const props = (schema.properties ?? {});
+        const mapValueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object"
+            ? schema.additionalProperties
+            : {};
         for (const [k, v] of Object.entries(data)) {
-            issues.push(...collectCelTypeIssues(v, (props[k] ?? {}), path ? `${path}.${k}` : k, definition, manifest, baseTypedEnv, rootEnv, rootModuleManifest));
+            issues.push(...collectCelTypeIssues(v, (props[k] ?? mapValueSchema), path ? `${path}.${k}` : k, definition, manifest, baseTypedEnv, rootEnv, rootModuleManifest));
         }
     }
     return issues;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { AnalysisRegistry } from "./analysis-registry.js";
+export type { RefFieldInfo } from "./analysis-registry.js";
 export { StaticAnalyzer } from "./analyzer.js";
 export type { GraphLoadError, ImportEdge, LoadedFile, LoadedGraph, LoadedModule, ParseError, } from "./loaded-types.js";
 export { flattenForAnalyzer, flattenLoadedModule, selectModuleManifestsForAnalysis, } from "./flatten-for-analyzer.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EACR,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACH,kBAAkB,EAClB,mBAAmB,EACnB,gCAAgC,GACnC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,YAAY,EACR,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EACH,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACtB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC3E,YAAY,EACR,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,aAAa,EACb,KAAK,EACR,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EACR,cAAc,EACd,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACH,kBAAkB,EAClB,mBAAmB,EACnB,gCAAgC,GACnC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,YAAY,EACR,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EACH,sBAAsB,EACtB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACtB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC3E,YAAY,EACR,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,aAAa,EACb,KAAK,EACR,MAAM,YAAY,CAAC"}

package/package.json

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

package/src/analysis-registry.ts

@@ -6,6 +6,25 @@ import { computeSuggestKind, computeValidUserFacingKinds } from "./kind-suggest.
 import { visitManifest as runVisitManifest, type ManifestVisitor } from "./manifest-visitor.js";
 import { isRefEntry, isScopeEntry } from "./reference-field-map.js";
 import type { AnalysisContext } from "./types.js";
+import { resolveTypeFieldToSchema } from "./validate-cel-context.js";
+
+/** One reference field declared by a resource's definition, derived purely from
+ *  the schema field map (independent of whether the manifest fills it). Editor
+ *  hosts render these as ports / adapters on a node. */
+export interface RefFieldInfo {
+  /** Field-map path with `[]` / `{}` markers (e.g. `targets[]`,
+   *  `routes[].handler`, `encoder`). */
+  path: string;
+  /** True when the path traverses at least one array. */
+  isArray: boolean;
+  /** Accepted `x-telo-ref` constraint strings (e.g. `telo#Runnable`). */
+  refs: string[];
+  /** Distinct capabilities the slot may target (`Telo.Runnable`,
+   *  `Telo.Service`, `Telo.Provider`, …) — one per resolvable constraint. The
+   *  first classifies the port (node-capability → edge, ambient → picker); the
+   *  full set validates drag-to-wire endpoints. Empty when none resolve. */
+  capabilities: string[];
+}
 
 /**
  * Accumulates type and alias knowledge for a running kernel or analysis session.
@@ -63,6 +82,100 @@ export class AnalysisRegistry {
     }
   }
 
+  /**
+   * Returns every reference field a resource's definition declares, with arity
+   * and the capability each slot targets — derived purely from the schema field
+   * map, so it lists slots even when the manifest leaves them empty. Editor
+   * hosts render these as node ports (drag-to-wire for node-capability targets,
+   * inline picker for ambient targets).
+   */
+  refFieldsForResource(resource: ResourceManifest): RefFieldInfo[] {
+    const fieldMap = this.defs.expandedFieldMapForResource(
+      resource,
+      this.aliases,
+      this.aliasesByModule,
+    );
+    if (!fieldMap) return [];
+    const out: RefFieldInfo[] = [];
+    for (const [path, entry] of fieldMap) {
+      if (!isRefEntry(entry)) continue;
+      out.push({
+        path,
+        isArray: entry.isArray,
+        refs: entry.refs,
+        capabilities: this.capabilitiesForRefs(entry.refs),
+      });
+    }
+    return out;
+  }
+
+  /** Base capability an `x-telo-ref` constraint targets. A definition's declared
+   *  `capability` is always one of the base capabilities, so it wins — this
+   *  resolves user-defined abstracts (e.g. `std/ai#Model`, declared
+   *  `capability: Telo.Invocable`) to the capability instances satisfy, not the
+   *  abstract kind. Builtin abstracts (`telo#Runnable`) carry no `capability`
+   *  field — there the kind itself *is* the capability. Undefined when
+   *  unresolvable. */
+  capabilityForRef(xTeloRef: string): string | undefined {
+    const kind = this.defs.resolveRef(xTeloRef);
+    if (!kind) return undefined;
+    const def = this.defs.resolve(kind);
+    if (!def) return undefined;
+    return def.capability ?? kind;
+  }
+
+  /** Resolves the JSON Schema for a kind's `invoke()` inputs, for editor hosts
+   *  that render a typed inputs form. Two-layer fallback mirroring the analyzer's
+   *  template inputs typing: the definition's own `inputType`, then the
+   *  `extends`-declared abstract's `inputType`. Resolves the inline
+   *  (`{ kind: Type.JsonSchema, schema }`) and raw-schema forms; a bare named
+   *  type reference is left unresolved (returns undefined) so the caller can fall
+   *  back to a freeform map. Undefined when the kind declares no input contract. */
+  inputTypeForKind(kind: string): Record<string, unknown> | undefined {
+    const def = this.resolveDefinition(kind);
+    if (!def) return undefined;
+    const own = resolveTypeFieldToSchema(def.inputType, []);
+    if (own) return own;
+    if (def.extends) {
+      const abstractDef = this.resolveDefinition(def.extends);
+      if (abstractDef) {
+        const inherited = resolveTypeFieldToSchema(abstractDef.inputType, []);
+        if (inherited) return inherited;
+      }
+    }
+    return undefined;
+  }
+
+  /** Resolves the JSON Schema for a kind's `invoke()` / `run()` output, for
+   *  editor hosts that render a typed output signature. Mirrors
+   *  {@link inputTypeForKind}: the definition's own `outputType`, then the
+   *  `extends`-declared abstract's `outputType`. Resolves the inline and
+   *  raw-schema forms; a bare named type reference is left unresolved. Undefined
+   *  when the kind declares no output contract. */
+  outputTypeForKind(kind: string): Record<string, unknown> | undefined {
+    const def = this.resolveDefinition(kind);
+    if (!def) return undefined;
+    const own = resolveTypeFieldToSchema(def.outputType, []);
+    if (own) return own;
+    if (def.extends) {
+      const abstractDef = this.resolveDefinition(def.extends);
+      if (abstractDef) {
+        const inherited = resolveTypeFieldToSchema(abstractDef.outputType, []);
+        if (inherited) return inherited;
+      }
+    }
+    return undefined;
+  }
+
+  private capabilitiesForRefs(refs: string[]): string[] {
+    const out: string[] = [];
+    for (const ref of refs) {
+      const cap = this.capabilityForRef(ref);
+      if (cap && !out.includes(cap)) out.push(cap);
+    }
+    return out;
+  }
+
   /**
    * Walks a manifest's annotation sites (refs, scopes, schema-from, CEL) via
    * the shared manifest visitor, bound to this registry's definitions and
@@ -121,29 +234,44 @@ export class AnalysisRegistry {
     return computeSuggestKind(badKind, this.aliases, this.defs);
   }
 
-  /** Returns every user-facing (alias-form) kind that satisfies the given
-   *  `x-telo-ref` constraint string (e.g. `"telo#Invocable"`, `"std/sql#Connection"`).
-   *  Resolution mirrors `validateReferences.checkKind`: abstract targets expand to
-   *  the set of definitions extending them; concrete targets yield just themselves.
-   *  Returns `undefined` when the ref can't be resolved (e.g. unregistered identity),
-   *  so callers can fall back to the unfiltered kind list. */
-  userFacingKindsForRef(xTeloRef: string): string[] | undefined {
+  /** Returns the **canonical** (`module.Type`) kinds that satisfy an `x-telo-ref`
+   *  constraint — an abstract target expands to its implementations (via the
+   *  extends / capability index), a concrete target yields just itself.
+   *  Resolution mirrors `validateReferences.checkKind`. Unlike
+   *  {@link userFacingKindsForRef} this is import-independent: it includes
+   *  locally-defined kinds (no alias), so callers can test whether an existing
+   *  resource's kind satisfies the ref by canonicalizing it (`resolveKind`) and
+   *  membership-checking here. Returns `undefined` when the ref can't be
+   *  resolved (e.g. unregistered identity). */
+  acceptedKindsForRef(xTeloRef: string): Set<string> | undefined {
     const targetKind = this.defs.resolveRef(xTeloRef);
     if (!targetKind) return undefined;
     const targetDef = this.defs.resolve(targetKind);
     if (!targetDef) return undefined;
 
-    const canonicalKinds: string[] = [];
+    const out = new Set<string>();
     if (targetDef.kind === "Telo.Abstract") {
       for (const def of this.defs.getByExtends(targetKind)) {
         const module = (def.metadata as { module?: string } | undefined)?.module;
         if (module && def.metadata?.name) {
-          canonicalKinds.push(`${module}.${def.metadata.name as string}`);
+          out.add(`${module}.${def.metadata.name as string}`);
         }
       }
     } else {
-      canonicalKinds.push(targetKind);
+      out.add(targetKind);
     }
+    return out;
+  }
+
+  /** Returns every user-facing (alias-form) kind that satisfies the given
+   *  `x-telo-ref` constraint string (e.g. `"telo#Invocable"`, `"std/sql#Connection"`).
+   *  Resolution mirrors `validateReferences.checkKind`: abstract targets expand to
+   *  the set of definitions extending them; concrete targets yield just themselves.
+   *  Returns `undefined` when the ref can't be resolved (e.g. unregistered identity),
+   *  so callers can fall back to the unfiltered kind list. */
+  userFacingKindsForRef(xTeloRef: string): string[] | undefined {
+    const canonicalKinds = this.acceptedKindsForRef(xTeloRef);
+    if (!canonicalKinds) return undefined;
 
     const out = new Set<string>();
     for (const kind of canonicalKinds) {

package/src/analyzer.ts

@@ -540,11 +540,15 @@ function collectCelTypeIssues(
     }
   } else if (data !== null && typeof data === "object") {
     const props = (schema.properties ?? {}) as Record<string, any>;
+    const mapValueSchema =
+      schema.additionalProperties && typeof schema.additionalProperties === "object"
+        ? (schema.additionalProperties as Record<string, any>)
+        : {};
     for (const [k, v] of Object.entries(data as Record<string, unknown>)) {
       issues.push(
         ...collectCelTypeIssues(
           v,
-          (props[k] ?? {}) as Record<string, any>,
+          (props[k] ?? mapValueSchema) as Record<string, any>,
           path ? `${path}.${k}` : k,
           definition,
           manifest,

package/src/index.ts

@@ -1,4 +1,5 @@
 export { AnalysisRegistry } from "./analysis-registry.js";
+export type { RefFieldInfo } from "./analysis-registry.js";
 export { StaticAnalyzer } from "./analyzer.js";
 export type {
     GraphLoadError,