@telorun/analyzer 0.2.1 → 0.4.0

package/README.md

@@ -1,3 +1,7 @@
+---
+description: "Telo: YAML-driven execution engine for declarative backends with micro-kernel architecture and language-agnostic design"
+---
+
 # ⚡ Telo
 
 Runtime for declarative backends.
@@ -73,6 +77,7 @@ connection:
 kind: Sql.Migration
 metadata:
   name: Migration_20260413_182154_CreateFeedback
+version: 20260413_182154_CreateFeedback
 sql: |
   CREATE TABLE IF NOT EXISTS feedback (
     id        INTEGER PRIMARY KEY AUTOINCREMENT,

package/dist/alias-resolver.d.ts

@@ -8,5 +8,9 @@ export declare class AliasResolver {
     resolveKind(kind: string): string | undefined;
     hasAlias(alias: string): boolean;
     knownAliases(): string[];
+    /** Returns every alias that currently points at `targetModule`.
+     *  Used by clients that need to convert a canonical kind key (e.g. "http-server.Server")
+     *  back into its user-facing alias form (e.g. "Http.Server"). */
+    aliasesFor(targetModule: string): string[];
 }
 //# sourceMappingURL=alias-resolver.d.ts.map

package/dist/alias-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alias-resolver.d.ts","sourceRoot":"","sources":["../src/alias-resolver.ts"],"names":[],"mappings":"AAAA;gFACgF;AAChF,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkC;IAEhE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,IAAI;IAOlF,sFAAsF;IACtF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAe7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIhC,YAAY,IAAI,MAAM,EAAE;CAGzB"}
+{"version":3,"file":"alias-resolver.d.ts","sourceRoot":"","sources":["../src/alias-resolver.ts"],"names":[],"mappings":"AAAA;gFACgF;AAChF,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkC;IAEhE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,IAAI;IAOlF,sFAAsF;IACtF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAe7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIhC,YAAY,IAAI,MAAM,EAAE;IAIxB;;qEAEiE;IACjE,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE;CAO3C"}

package/dist/alias-resolver.js

@@ -33,4 +33,15 @@ export class AliasResolver {
     knownAliases() {
         return Array.from(this.importAliases.keys());
     }
+    /** Returns every alias that currently points at `targetModule`.
+     *  Used by clients that need to convert a canonical kind key (e.g. "http-server.Server")
+     *  back into its user-facing alias form (e.g. "Http.Server"). */
+    aliasesFor(targetModule) {
+        const result = [];
+        for (const [alias, mod] of this.importAliases) {
+            if (mod === targetModule)
+                result.push(alias);
+        }
+        return result;
+    }
 }

package/dist/analysis-registry.d.ts

@@ -25,6 +25,17 @@ export declare class AnalysisRegistry {
     builtinDefinitions(): ResourceDefinition[];
     resolveDefinition(kind: string): ResourceDefinition | undefined;
     allKinds(): string[];
+    /** Returns every import alias that points at `moduleName` (the canonical, kebab-case
+     *  module name). Empty when no import declares that target. */
+    aliasesFor(moduleName: string): string[];
+    /** Returns every user-facing kind that is legal in the current scope:
+     *  Telo root kinds plus the alias form of each non-abstract imported definition.
+     *  Used by editor hosts to drive completion and by the analyzer to produce
+     *  "did you mean" hints. */
+    validUserFacingKinds(): string[];
+    /** 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;
     /** @internal Bridge for StaticAnalyzer — do not use outside the analyzer package. */
     _context(): AnalysisContext;
 }

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,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;IAE/C,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;;;OAGG;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;IAcP;;;;OAIG;IACH,kBAAkB,IAAI,kBAAkB,EAAE;IAI1C,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAM/D,QAAQ,IAAI,MAAM,EAAE;IAIpB,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;AAMzE,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;IAE/C,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;;;OAGG;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;IAcP;;;;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,qFAAqF;IACrF,QAAQ,IAAI,eAAe;CAG5B"}

package/dist/analysis-registry.js

@@ -1,6 +1,7 @@
 import { AliasResolver } from "./alias-resolver.js";
 import { KERNEL_BUILTINS } from "./builtins.js";
 import { DefinitionRegistry } from "./definition-registry.js";
+import { computeSuggestKind, computeValidUserFacingKinds } from "./kind-suggest.js";
 import { isRefEntry, isScopeEntry } from "./reference-field-map.js";
 /**
  * Accumulates type and alias knowledge for a running kernel or analysis session.
@@ -56,6 +57,23 @@ export class AnalysisRegistry {
     allKinds() {
         return this._context().definitions?.kinds() ?? [];
     }
+    /** Returns every import alias that points at `moduleName` (the canonical, kebab-case
+     *  module name). Empty when no import declares that target. */
+    aliasesFor(moduleName) {
+        return this.aliases.aliasesFor(moduleName);
+    }
+    /** Returns every user-facing kind that is legal in the current scope:
+     *  Telo root kinds plus the alias form of each non-abstract imported definition.
+     *  Used by editor hosts to drive completion and by the analyzer to produce
+     *  "did you mean" hints. */
+    validUserFacingKinds() {
+        return computeValidUserFacingKinds(this.aliases, this.defs);
+    }
+    /** Returns the closest user-facing kind to `badKind`, or undefined when nothing
+     *  is close enough (or multiple candidates tie). Case-sensitive. */
+    suggestKind(badKind) {
+        return computeSuggestKind(badKind, this.aliases, this.defs);
+    }
     /** @internal Bridge for StaticAnalyzer — do not use outside the analyzer package. */
     _context() {
         return { aliases: this.aliases, definitions: this.defs };

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;AAGzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAY9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAsP/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,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IA0PvB,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAMvB,SAAS,CAAC,SAAS,EAAE,gBAAgB,EAAE,EAAE,QAAQ,EAAE,gBAAgB,GAAG,gBAAgB,EAAE;IAKxF,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;CAiB5F"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAa9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAuP/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,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAsSvB,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAMvB,SAAS,CAAC,SAAS,EAAE,gBAAgB,EAAE,EAAE,QAAQ,EAAE,gBAAgB,GAAG,gBAAgB,EAAE;IAKxF,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;CAiB5F"}

package/dist/analyzer.js

@@ -3,11 +3,13 @@ import { buildCelEnvironment, buildTypedCelEnvironment, } from "./cel-environmen
 import { DefinitionRegistry } from "./definition-registry.js";
 import { buildDependencyGraph, formatCycle } from "./dependency-graph.js";
 import { buildKernelGlobalsSchema, mergeKernelGlobalsIntoContext } from "./kernel-globals.js";
+import { computeSuggestKind } from "./kind-suggest.js";
 import { isModuleKind } from "./module-kinds.js";
 import { normalizeInlineResources } from "./normalize-inline-resources.js";
 import { celTypeSatisfiesJsonSchema, substituteCelFields, validateAgainstSchema, } from "./schema-compat.js";
 import { DiagnosticSeverity } from "./types.js";
 import { extractAccessChains, getManifestItem, pathMatchesScope, resolveContextAnnotations, resolveTypeFieldToSchema, validateChainAgainstSchema, } from "./validate-cel-context.js";
+import { validateExtends } from "./validate-extends.js";
 import { validateReferences } from "./validate-references.js";
 import { validateThrowsCoverage } from "./validate-throws-coverage.js";
 const TEMPLATE_REGEX = /\$\{\{\s*([^}]+?)\s*\}\}/g;
@@ -209,9 +211,24 @@ export class StaticAnalyzer {
         // Register module identities and aliases.
         // The root module doc (Telo.Application or Telo.Library) provides its own
         // identity; imported modules surface their identity via resolvedModuleName/
-        // resolvedNamespace stamped onto the Telo.Import by the loader (so we don't
-        // need to include imported module manifests in the analysis set, avoiding false
-        // reference errors in the parent context).
+        // resolvedNamespace stamped onto the Telo.Import by the loader.
+        //
+        // Two alias scopes are tracked:
+        //  - `aliases` — the consumer's aliases, populated from Telo.Imports declared in
+        //    the entry manifest (its own module).
+        //  - `aliasesByModule` — per-imported-library aliases, populated from Telo.Imports
+        //    forwarded by the loader from inside imported libraries. A library may use
+        //    different alias names than the consumer for the same dependency; resolving
+        //    a forwarded def's `extends` / `capability` against the consumer's scope
+        //    would either fail or pick the wrong target. Each forwarded def is normalized
+        //    in its own library's scope.
+        const rootModules = new Set();
+        for (const m of manifests) {
+            if (isModuleKind(m.kind) && m.metadata?.name) {
+                rootModules.add(m.metadata.name);
+            }
+        }
+        const aliasesByModule = new Map();
         for (const m of manifests) {
             if (isModuleKind(m.kind)) {
                 const namespace = m.metadata.namespace ?? null;
@@ -225,26 +242,58 @@ export class StaticAnalyzer {
                 const exportedKinds = m.exports?.kinds ?? [];
                 const resolvedModuleName = m.metadata.resolvedModuleName;
                 const resolvedNamespace = m.metadata.resolvedNamespace;
+                const ownModule = m.metadata?.module;
                 if (alias && source) {
                     const targetModule = resolvedModuleName ?? source.split("/").filter(Boolean).pop() ?? source;
-                    aliases.registerImport(alias, targetModule, exportedKinds);
+                    // Module identity is registered globally so x-telo-ref resolution sees
+                    // transitively-imported modules regardless of which scope brought them in.
                     if (resolvedModuleName) {
                         defs.registerModuleIdentity(resolvedNamespace ?? null, resolvedModuleName);
                     }
+                    // Alias registration is scoped: consumer imports vs. imported-library imports.
+                    if (!ownModule || rootModules.has(ownModule)) {
+                        aliases.registerImport(alias, targetModule, exportedKinds);
+                    }
+                    else {
+                        let libResolver = aliasesByModule.get(ownModule);
+                        if (!libResolver) {
+                            libResolver = new AliasResolver();
+                            aliasesByModule.set(ownModule, libResolver);
+                        }
+                        libResolver.registerImport(alias, targetModule, exportedKinds);
+                    }
                 }
             }
         }
-        // Register definitions from Telo.Definition resources.
-        // Normalize alias-prefixed `capability` to canonical form so extendedBy lookup works
-        // (e.g. "Workflow.Backend" → "workflow.Backend" when "Workflow" is a known alias).
+        // Register definitions from Telo.Definition AND Telo.Abstract resources.
+        // Abstracts declare contracts that implementations target via `extends` (canonical)
+        // or `capability: <AbstractKind>` (legacy). Until they're registered, validateReferences
+        // can't resolve x-telo-ref entries pointing at library-declared abstracts — so abstracts
+        // must go through register() too, not just the kernel builtins in the constructor.
+        //
+        // Normalize alias-prefixed `capability` and `extends` to canonical form using the
+        // declaring scope's resolver, so `extendedBy` is keyed by canonical kind regardless
+        // of alias choices. `capability` covers the legacy implements-this-abstract overload;
+        // `extends` is the canonical first-class form.
         for (const m of manifests) {
-            if (m.kind === "Telo.Definition") {
-                const def = m;
-                const resolvedCapability = def.capability
-                    ? (aliases.resolveKind(def.capability) ?? def.capability)
-                    : def.capability;
-                defs.register(resolvedCapability !== def.capability ? { ...def, capability: resolvedCapability } : def);
-            }
+            if (m.kind !== "Telo.Definition" && m.kind !== "Telo.Abstract")
+                continue;
+            const def = m;
+            const ownModule = def.metadata?.module;
+            const scopeResolver = ownModule && !rootModules.has(ownModule)
+                ? (aliasesByModule.get(ownModule) ?? new AliasResolver())
+                : aliases;
+            const resolvedCapability = def.capability
+                ? (scopeResolver.resolveKind(def.capability) ?? def.capability)
+                : def.capability;
+            const resolvedExtends = def.extends
+                ? (scopeResolver.resolveKind(def.extends) ?? def.extends)
+                : def.extends;
+            const needsPatch = resolvedCapability !== def.capability || resolvedExtends !== def.extends;
+            const normalized = needsPatch
+                ? { ...def, capability: resolvedCapability, extends: resolvedExtends }
+                : def;
+            defs.register(normalized);
         }
         // Phase 2: extract inline resources from x-telo-ref slots into first-class manifests
         const allManifests = normalizeInlineResources(manifests, defs, aliases);
@@ -281,20 +330,14 @@ export class StaticAnalyzer {
             const resolvedKind = aliases.resolveKind(m.kind);
             const definition = defs.resolve(m.kind) ?? (resolvedKind ? defs.resolve(resolvedKind) : undefined);
             if (!definition) {
-                const knownAliases = aliases.knownAliases();
-                const knownKinds = defs.kinds();
-                const parts = [];
-                if (knownAliases.length > 0)
-                    parts.push(`imports: ${knownAliases.join(", ")}`);
-                if (knownKinds.length > 0)
-                    parts.push(`kinds: ${knownKinds.join(", ")}`);
-                const hint = parts.length > 0 ? ` Known ${parts.join(" | ")}` : "";
+                const suggestedKind = computeSuggestKind(m.kind, aliases, defs);
+                const hint = suggestedKind ? ` Did you mean '${suggestedKind}'?` : "";
                 diagnostics.push({
                     severity: DiagnosticSeverity.Error,
                     code: "UNDEFINED_KIND",
                     source: SOURCE,
                     message: `No Telo.Definition found for kind '${m.kind}'.${hint}`,
-                    data: { resource, filePath, path: "kind" },
+                    data: { resource, filePath, path: "kind", suggestedKind },
                 });
                 continue;
             }
@@ -406,6 +449,8 @@ export class StaticAnalyzer {
         }
         // Validate resource references (Phase 3)
         diagnostics.push(...validateReferences(allManifests, { aliases, definitions: defs }));
+        // Validate `extends` fields and flag legacy `capability: <UserAbstract>` overload.
+        diagnostics.push(...validateExtends(allManifests, defs, aliases));
         // Validate throws: declarations and catches: coverage (rules 1, 2, 4, 7)
         diagnostics.push(...validateThrowsCoverage(allManifests, defs, aliases, this.celEnv));
         return diagnostics;

package/dist/builtins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../src/builtins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,eAAO,MAAM,eAAe,EAAE,kBAAkB,EA4I/C,CAAC"}
+{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../src/builtins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,eAAO,MAAM,eAAe,EAAE,kBAAkB,EAsJ/C,CAAC"}

package/dist/builtins.js

@@ -25,9 +25,13 @@ export const KERNEL_BUILTINS = [
                     additionalProperties: true,
                 },
                 capability: { type: "string" },
+                schema: { type: "object", additionalProperties: true },
             },
             required: ["metadata"],
-            additionalProperties: false,
+            // Telo.Abstract is an extension point by design — it must accept forward-compatible
+            // fields (e.g. inputType/outputType from the typed-abstracts plan) without requiring
+            // the analyzer to enumerate them here.
+            additionalProperties: true,
         },
     },
     {
@@ -53,6 +57,12 @@ export const KERNEL_BUILTINS = [
                 source: { type: "string" },
                 variables: { type: "object" },
                 secrets: { type: "object" },
+                runtime: {
+                    oneOf: [
+                        { type: "string" },
+                        { type: "array", items: { type: "string" } },
+                    ],
+                },
             },
             required: ["metadata", "source"],
             additionalProperties: false,

package/dist/definition-registry.d.ts

@@ -20,6 +20,7 @@ export declare class DefinitionRegistry {
      *  Used to compute definition $id values for the AJV schema store. */
     private readonly reverseIdentityMap;
     register(definition: ResourceDefinition): void;
+    private addExtendedBy;
     /** Register a module identity for x-telo-ref resolution.
      *  Call once per module doc (Telo.Application or Telo.Library) when the manifest is loaded.
      *  @param namespace  The module's metadata.namespace (e.g. "std"), or null for telo built-ins.

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

@@ -1 +1 @@
-{"version":3,"file":"definition-registry.d.ts","sourceRoot":"","sources":["../src/definition-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,EAA0B,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAG1F,+EAA+E;AAC/E,qBAAa,kBAAkB;;IAK7B;;sFAEkF;IAClF,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;IAClE,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;IAC1D;6DACyD;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IACzD;;0EAEsE;IACtE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6B;IAEhE,QAAQ,CAAC,UAAU,EAAE,kBAAkB,GAAG,IAAI;IAwB9C;;;yFAGqF;IACrF,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAgB1E;4EACwE;IACxE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMnE;wFACoF;IACpF,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,EAAE;IAWtE,OAAO,CAAC,iBAAiB;IAczB;;;;;;;;4FAQwF;IACxF,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAUhD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAIrD,+FAA+F;IAC/F,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAIxD,gGAAgG;IAChG,kBAAkB,CAChB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,GACvD,iBAAiB,GAAG,SAAS;IAOhC;;qEAEiE;IACjE,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,kBAAkB,EAAE;IAgBxD,KAAK,IAAI,MAAM,EAAE;CAGlB"}
+{"version":3,"file":"definition-registry.d.ts","sourceRoot":"","sources":["../src/definition-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,EAA0B,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAG1F,+EAA+E;AAC/E,qBAAa,kBAAkB;;IAK7B;;sFAEkF;IAClF,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IAEzD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyC;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;IAClE,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;IAC1D;6DACyD;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IACzD;;0EAEsE;IACtE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6B;IAEhE,QAAQ,CAAC,UAAU,EAAE,kBAAkB,GAAG,IAAI;IAiC9C,OAAO,CAAC,aAAa;IASrB;;;yFAGqF;IACrF,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAgB1E;4EACwE;IACxE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMnE;wFACoF;IACpF,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,EAAE;IAWtE,OAAO,CAAC,iBAAiB;IAczB;;;;;;;;4FAQwF;IACxF,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAUhD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAIrD,+FAA+F;IAC/F,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAIxD,gGAAgG;IAChG,kBAAkB,CAChB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,GACvD,iBAAiB,GAAG,SAAS;IAOhC;;qEAEiE;IACjE,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,kBAAkB,EAAE;IAgBxD,KAAK,IAAI,MAAM,EAAE;CAGlB"}

package/dist/definition-registry.js

@@ -28,14 +28,22 @@ export class DefinitionRegistry {
         const key = mod ? `${mod}.${name}` : name;
         this.defs.set(key, definition);
         this.fieldMaps.set(key, buildReferenceFieldMap(definition.schema ?? {}));
+        // `capability` populates extendedBy for backward-compat with the legacy pattern where
+        // a concrete definition overloaded `capability: <AbstractKind>` to mean "implements
+        // this abstract." The canonical pattern is `extends` (below). Both populate the index,
+        // unioned — so in-flight modules pre-migration keep working.
         if (definition.capability) {
-            const children = this.extendedBy.get(definition.capability);
-            if (children) {
-                children.push(key);
-            }
-            else {
-                this.extendedBy.set(definition.capability, [key]);
-            }
+            this.addExtendedBy(definition.capability, key);
+        }
+        // `extends` — first-class "implements-this-abstract" edge. Alias-form resolution
+        // happens in the analyzer before register() is called (analyzer.ts pre-resolves
+        // via aliases.resolveKind), so the value here is already the canonical kind string
+        // (e.g. "workflow.Backend"). If the analyzer could not resolve the alias (partial
+        // context, or the declaring file doesn't import the target's alias), the value
+        // stays as the original alias-prefixed form; validateExtends emits EXTENDS_MALFORMED
+        // or EXTENDS_UNKNOWN_TARGET depending on the case.
+        if (definition.extends) {
+            this.addExtendedBy(definition.extends, key);
         }
         // Auto-register the telo identity when any Telo built-in is registered.
         if (definition.kind === "Telo.Abstract" && mod === "Telo") {
@@ -47,6 +55,16 @@ export class DefinitionRegistry {
             this.tryRegisterSchema(mod, name, definition.schema);
         }
     }
+    addExtendedBy(parent, child) {
+        const children = this.extendedBy.get(parent);
+        if (children) {
+            if (!children.includes(child))
+                children.push(child);
+        }
+        else {
+            this.extendedBy.set(parent, [child]);
+        }
+    }
     /** Register a module identity for x-telo-ref resolution.
      *  Call once per module doc (Telo.Application or Telo.Library) when the manifest is loaded.
      *  @param namespace  The module's metadata.namespace (e.g. "std"), or null for telo built-ins.

package/dist/kind-suggest.d.ts

@@ -0,0 +1,15 @@
+import type { AliasResolver } from "./alias-resolver.js";
+import type { DefinitionRegistry } from "./definition-registry.js";
+/** Computes the set of user-facing kind strings available in the given
+ *  (aliases, defs) context:
+ *    - The hardcoded Telo root kinds.
+ *    - For every registered non-abstract definition, the alias form
+ *      `${alias}.${TypeName}` for each import alias that points at its
+ *      module. Canonical kebab-case forms (e.g. `http-server.Server`) are
+ *      deliberately excluded — users write manifests via alias. */
+export declare function computeValidUserFacingKinds(aliases: AliasResolver, defs: DefinitionRegistry): string[];
+/** Returns the closest user-facing kind to `badKind` within an edit-distance
+ *  threshold, or undefined when nothing close enough exists (including ties).
+ *  Case-sensitive — kinds are PascalCase by contract. */
+export declare function computeSuggestKind(badKind: string, aliases: AliasResolver, defs: DefinitionRegistry): string | undefined;
+//# sourceMappingURL=kind-suggest.d.ts.map

package/dist/kind-suggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind-suggest.d.ts","sourceRoot":"","sources":["../src/kind-suggest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAenE;;;;;;mEAMmE;AACnE,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,kBAAkB,GACvB,MAAM,EAAE,CAkBV;AAED;;yDAEyD;AACzD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,kBAAkB,GACvB,MAAM,GAAG,SAAS,CAuBpB"}

package/dist/kind-suggest.js

@@ -0,0 +1,63 @@
+import { distance } from "./levenshtein.js";
+/** User-facing root kinds that are always legal regardless of imports. */
+const ROOT_KINDS = [
+    "Telo.Application",
+    "Telo.Library",
+    "Telo.Import",
+    "Telo.Definition",
+];
+/** Definition kinds that are not user-instantiable and should be excluded
+ *  from completion / suggestion lists. */
+const ABSTRACT_DEF_KINDS = new Set(["Telo.Abstract", "Telo.Template"]);
+/** Computes the set of user-facing kind strings available in the given
+ *  (aliases, defs) context:
+ *    - The hardcoded Telo root kinds.
+ *    - For every registered non-abstract definition, the alias form
+ *      `${alias}.${TypeName}` for each import alias that points at its
+ *      module. Canonical kebab-case forms (e.g. `http-server.Server`) are
+ *      deliberately excluded — users write manifests via alias. */
+export function computeValidUserFacingKinds(aliases, defs) {
+    const out = new Set(ROOT_KINDS);
+    for (const kind of defs.kinds()) {
+        const def = defs.resolve(kind);
+        if (!def || ABSTRACT_DEF_KINDS.has(def.kind))
+            continue;
+        const dot = kind.indexOf(".");
+        if (dot === -1)
+            continue;
+        const moduleName = kind.slice(0, dot);
+        const typeName = kind.slice(dot + 1);
+        for (const alias of aliases.aliasesFor(moduleName)) {
+            out.add(`${alias}.${typeName}`);
+        }
+    }
+    return Array.from(out);
+}
+/** Returns the closest user-facing kind to `badKind` within an edit-distance
+ *  threshold, or undefined when nothing close enough exists (including ties).
+ *  Case-sensitive — kinds are PascalCase by contract. */
+export function computeSuggestKind(badKind, aliases, defs) {
+    if (!badKind)
+        return undefined;
+    const candidates = computeValidUserFacingKinds(aliases, defs);
+    const threshold = Math.min(3, Math.floor(badKind.length / 3));
+    if (threshold < 1)
+        return undefined;
+    let best;
+    let bestDist = threshold + 1;
+    let tied = false;
+    for (const c of candidates) {
+        const d = distance(badKind, c);
+        if (d < bestDist) {
+            best = c;
+            bestDist = d;
+            tied = false;
+        }
+        else if (d === bestDist) {
+            tied = true;
+        }
+    }
+    if (!best || bestDist > threshold || tied)
+        return undefined;
+    return best;
+}

package/dist/levenshtein.d.ts

@@ -0,0 +1,5 @@
+/** Classic Wagner-Fischer Levenshtein distance. Iterative with two rolling rows
+ *  so memory is O(min(a, b)); sufficient for short strings like resource kind
+ *  identifiers (a few dozen characters at most). */
+export declare function distance(a: string, b: string): number;
+//# sourceMappingURL=levenshtein.d.ts.map

package/dist/levenshtein.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levenshtein.d.ts","sourceRoot":"","sources":["../src/levenshtein.ts"],"names":[],"mappings":"AAAA;;oDAEoD;AACpD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgCrD"}

package/dist/levenshtein.js

@@ -0,0 +1,34 @@
+/** Classic Wagner-Fischer Levenshtein distance. Iterative with two rolling rows
+ *  so memory is O(min(a, b)); sufficient for short strings like resource kind
+ *  identifiers (a few dozen characters at most). */
+export function distance(a, b) {
+    if (a === b)
+        return 0;
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    // Ensure b is the shorter string so the row buffer stays small.
+    if (a.length < b.length) {
+        const tmp = a;
+        a = b;
+        b = tmp;
+    }
+    let prev = new Array(b.length + 1);
+    let curr = new Array(b.length + 1);
+    for (let j = 0; j <= b.length; j++)
+        prev[j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        curr[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+            curr[j] = Math.min(curr[j - 1] + 1, // insertion
+            prev[j] + 1, // deletion
+            prev[j - 1] + cost);
+        }
+        const swap = prev;
+        prev = curr;
+        curr = swap;
+    }
+    return prev[b.length];
+}

package/dist/manifest-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest-loader.d.ts","sourceRoot":"","sources":["../src/manifest-loader.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAOtE,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAGrB,MAAM,YAAY,CAAC;AASpB,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAG/B;IAEJ,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE,CAAC;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,sBAAsB,GAAE,eAAe,EAAE,GAAG,iBAAsB;IAmB9E,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAKxC,OAAO,CAAC,IAAI;IAMN,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/C,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAqGnE,eAAe;YAoBf,eAAe;IAgEvB,iBAAiB,CACrB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;QACT,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,gBAAgB,EAAE,CAAC;QAC9B,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;KAClD,GAAG,IAAI,CAAC;IAiCH,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,GAC5C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAsCrC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;CAiEnE"}
+{"version":3,"file":"manifest-loader.d.ts","sourceRoot":"","sources":["../src/manifest-loader.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAOtE,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAGrB,MAAM,YAAY,CAAC;AASpB,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAG/B;IAEJ,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE,CAAC;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,sBAAsB,GAAE,eAAe,EAAE,GAAG,iBAAsB;IAmB9E,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAKxC,OAAO,CAAC,IAAI;IAMN,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/C,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAqGnE,eAAe;YAoBf,eAAe;IAgEvB,iBAAiB,CACrB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;QACT,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,gBAAgB,EAAE,CAAC;QAC9B,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;KAClD,GAAG,IAAI,CAAC;IAiCH,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,GAC5C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAsCrC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;CA2GnE"}

package/dist/manifest-loader.js

@@ -277,7 +277,30 @@ export class Loader {
     }
     async loadManifests(entryUrl) {
         const visited = new Set([entryUrl]);
+        // Cache resolved library identity per import URL so a Telo.Import re-encountered
+        // through a different chain still gets `resolvedModuleName` / `resolvedNamespace`
+        // stamped — without re-loading the target. The early `visited` short-circuit used
+        // to silently leave duplicate Telo.Imports unstamped, which broke alias resolution
+        // when the same library was imported by two different files in the same analysis set.
+        const libraryIdentityByUrl = new Map();
         const entry = await this.loadModule(entryUrl);
+        // Forward Telo.Definition, Telo.Abstract, AND Telo.Import docs from imported
+        // libraries to the analyzer so its downstream passes can see them:
+        //  - Definitions / Abstracts feed cross-package `x-telo-ref` resolution and
+        //    `extends` target validation.
+        //  - Imports feed the per-library alias resolver — alias-form `extends` inside
+        //    a library (e.g. ai-openai's `extends: Ai.Model`) resolves against THAT
+        //    library's own `Telo.Import` declarations, not the root manifest's. Without
+        //    forwarding the imports, importing such a library would surface a spurious
+        //    EXTENDS_MALFORMED for an alias the library legitimately uses internally.
+        // Alias resolution itself stays in the analyzer; the loader's only semantic
+        // action is stamping `resolvedModuleName` / `resolvedNamespace` — recording the
+        // result of loading. Identity is cached per URL (see libraryIdentityByUrl above)
+        // because the same library can be reached through multiple chains, and every
+        // Telo.Import doc — including the duplicates short-circuited by `visited` —
+        // must end up stamped, otherwise per-scope alias resolution falls back to a
+        // path-derived string (e.g. "abstract-lib.yaml") and produces wrong canonical
+        // kinds.
         const importedDefs = [];
         const queue = [...entry];
         while (queue.length > 0) {
@@ -291,36 +314,52 @@ export class Loader {
             const importUrl = importSource.startsWith(".") || importSource.startsWith("/")
                 ? this.pick(base).resolveRelative(base, importSource)
                 : importSource;
-            if (visited.has(importUrl))
-                continue;
-            visited.add(importUrl);
-            let imported;
-            try {
-                imported = await this.loadModule(importUrl);
-            }
-            catch (err) {
-                const e = err instanceof Error ? err : new Error(String(err));
-                e.sourceLine = m.metadata?.sourceLine ?? 0;
-                throw e;
-            }
-            // Import target must be a Telo.Library. Check the Library branch
-            // explicitly rather than "anything that's a module kind" so that a
-            // future third kind can't silently slip past as a valid import target.
-            const importedLibrary = imported.find((im) => im.kind === "Telo.Library");
-            const importedApplication = imported.find((im) => im.kind === "Telo.Application");
-            if (importedApplication) {
-                const e = new Error(`Telo.Import target '${importSource}' is a Telo.Application. ` +
-                    `Only Telo.Library modules may be imported. Applications are run directly, not imported.`);
-                e.sourceLine = m.metadata?.sourceLine ?? 0;
-                throw e;
+            if (!visited.has(importUrl)) {
+                visited.add(importUrl);
+                let imported;
+                try {
+                    imported = await this.loadModule(importUrl);
+                }
+                catch (err) {
+                    const e = err instanceof Error ? err : new Error(String(err));
+                    e.sourceLine = m.metadata?.sourceLine ?? 0;
+                    throw e;
+                }
+                // Import target must be a Telo.Library. Check the Library branch
+                // explicitly rather than "anything that's a module kind" so that a
+                // future third kind can't silently slip past as a valid import target.
+                const importedLibrary = imported.find((im) => im.kind === "Telo.Library");
+                const importedApplication = imported.find((im) => im.kind === "Telo.Application");
+                if (importedApplication) {
+                    const e = new Error(`Telo.Import target '${importSource}' is a Telo.Application. ` +
+                        `Only Telo.Library modules may be imported. Applications are run directly, not imported.`);
+                    e.sourceLine = m.metadata?.sourceLine ?? 0;
+                    throw e;
+                }
+                if (importedLibrary?.metadata?.name) {
+                    libraryIdentityByUrl.set(importUrl, {
+                        name: importedLibrary.metadata.name,
+                        namespace: importedLibrary.metadata.namespace ?? null,
+                    });
+                }
+                for (const im of imported) {
+                    if (im.kind === "Telo.Definition" ||
+                        im.kind === "Telo.Abstract" ||
+                        im.kind === "Telo.Import") {
+                        importedDefs.push(im);
+                    }
+                    if (im.kind === "Telo.Import")
+                        queue.push(im);
+                }
             }
-            const importedModule = importedLibrary;
-            if (importedModule?.metadata?.name) {
+            // Stamp m with cached identity (works for both fresh and duplicate visits).
+            const identity = libraryIdentityByUrl.get(importUrl);
+            if (identity) {
                 const pi = m.metadata?.positionIndex;
                 m.metadata = {
                     ...m.metadata,
-                    resolvedModuleName: importedModule.metadata.name,
-                    resolvedNamespace: importedModule.metadata.namespace ?? null,
+                    resolvedModuleName: identity.name,
+                    resolvedNamespace: identity.namespace,
                 };
                 if (pi) {
                     Object.defineProperty(m.metadata, "positionIndex", {
@@ -331,12 +370,6 @@ export class Loader {
                     });
                 }
             }
-            for (const im of imported) {
-                if (im.kind === "Telo.Definition")
-                    importedDefs.push(im);
-                if (im.kind === "Telo.Import")
-                    queue.push(im);
-            }
         }
         return [...entry, ...importedDefs];
     }