@telorun/analyzer 0.23.0 → 0.23.2

package/dist/alias-resolver.d.ts

@@ -26,4 +26,14 @@ export declare class AliasResolver {
      *  back into its user-facing alias form (e.g. "Http.Server"). */
     aliasesFor(targetModule: string): string[];
 }
+/**
+ * The alias resolver for a resource's own lexical scope. A resource that
+ * originated in an imported library (its `ownModule` names a non-root module —
+ * e.g. an inline handler extracted from an imported Http.Api) resolves its kind
+ * aliases against THAT library's import map, so an anonymous child inherits the
+ * lexical scope of the document that declares it. Returns undefined for
+ * root/consumer-owned resources (and unknown modules), so callers fall back to
+ * the root `aliases`.
+ */
+export declare function scopeResolverForModule(ownModule: string | undefined, rootModules: Set<string>, aliasesByModule: Map<string, AliasResolver>): AliasResolver | undefined;
 //# 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;IAChE;;4FAEwF;IACxF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA6B;IAE7D,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,IAAI;IAOlF;sFACkF;IAClF,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAIhF;;;;qDAIiD;IACjD,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIjD,sFAAsF;IACtF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAmB7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIhC,YAAY,IAAI,MAAM,EAAE;IAIxB;;qEAEiE;IACjE,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE;CAO3C"}
+{"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;IAChE;;4FAEwF;IACxF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA6B;IAE7D,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,IAAI;IAOlF;sFACkF;IAClF,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAIhF;;;;qDAIiD;IACjD,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIjD,sFAAsF;IACtF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAmB7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIhC,YAAY,IAAI,MAAM,EAAE;IAIxB;;qEAEiE;IACjE,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE;CAO3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAC1C,aAAa,GAAG,SAAS,CAI3B"}

package/dist/alias-resolver.js

@@ -67,3 +67,17 @@ export class AliasResolver {
         return result;
     }
 }
+/**
+ * The alias resolver for a resource's own lexical scope. A resource that
+ * originated in an imported library (its `ownModule` names a non-root module —
+ * e.g. an inline handler extracted from an imported Http.Api) resolves its kind
+ * aliases against THAT library's import map, so an anonymous child inherits the
+ * lexical scope of the document that declares it. Returns undefined for
+ * root/consumer-owned resources (and unknown modules), so callers fall back to
+ * the root `aliases`.
+ */
+export function scopeResolverForModule(ownModule, rootModules, aliasesByModule) {
+    return ownModule && !rootModules.has(ownModule)
+        ? aliasesByModule.get(ownModule)
+        : undefined;
+}

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,EAIL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAiB9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AA4hB/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;IA+sBvB,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;IAerB,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,EAIL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAiB9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AA4hB/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;IAstBvB,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;IAerB,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

@@ -1,5 +1,5 @@
 import { defaultRegistry, isTaggedSentinel } from "@telorun/templating";
-import { AliasResolver } from "./alias-resolver.js";
+import { AliasResolver, scopeResolverForModule } from "./alias-resolver.js";
 import { buildCelEnvironment, buildImportInputCelEnvironment, buildTypedCelEnvironment, } from "./cel-environment.js";
 import { DefinitionRegistry } from "./definition-registry.js";
 import { buildDependencyGraph, formatCycle } from "./dependency-graph.js";
@@ -796,8 +796,15 @@ export class StaticAnalyzer {
             const resource = { kind: m.kind, name: m.metadata?.name };
             // Resolve kind through alias if needed; direct lookup takes priority so that
             // aliases whose name matches the module name (the common case) work without
-            // path-derived name mangling.
-            const resolvedKind = aliases.resolveKind(m.kind);
+            // path-derived name mangling. A resource that originated in an imported library
+            // (its `metadata.module` names a non-root module — e.g. an inline route handler
+            // extracted from an imported Http.Api) must resolve its kind alias against THAT
+            // library's import map, not the consumer's; an anonymous child inherits the
+            // lexical scope of the document that declares it. Mirrors the nested-inline and
+            // reference-resolution paths: own-module scope first, root/consumer aliases last.
+            const ownModule = m.metadata?.module;
+            const scopeResolver = scopeResolverForModule(ownModule, rootModules, aliasesByModule);
+            const resolvedKind = scopeResolver?.resolveKind(m.kind) ?? aliases.resolveKind(m.kind);
             const definition = defs.resolve(m.kind) ?? (resolvedKind ? defs.resolve(resolvedKind) : undefined);
             if (!definition) {
                 const suggestedKind = computeSuggestKind(m.kind, aliases, defs);
@@ -865,9 +872,8 @@ export class StaticAnalyzer {
                 // first, then the parent module's own aliases (for resources declared
                 // inside an imported module), then the root aliases. Mirrors how the
                 // analyzer resolves kinds elsewhere so module-scoped aliases don't
-                // produce false UNDEFINED_KIND diagnostics.
-                const ownModule = m.metadata?.module;
-                const scopeResolver = ownModule && !rootModules.has(ownModule) ? aliasesByModule.get(ownModule) : undefined;
+                // produce false UNDEFINED_KIND diagnostics. `scopeResolver` is the
+                // owning module's resolver computed above.
                 diagnostics.push(...validateNestedInlineResources(m, definition.schema, (kind) => {
                     const direct = defs.resolve(kind);
                     if (direct)
@@ -1082,7 +1088,7 @@ export class StaticAnalyzer {
         // Validate provider coherence rules for `provide:` template-target definitions.
         diagnostics.push(...validateProviderCoherence(allManifests, defs, aliases));
         // Validate throws: declarations and catches: coverage (rules 1, 2, 4, 7)
-        diagnostics.push(...validateThrowsCoverage(allManifests, defs, aliases, this.celEnv));
+        diagnostics.push(...validateThrowsCoverage(allManifests, defs, aliases, this.celEnv, aliasesByModule, rootModules));
         // Warn about declared variables / secrets / ports that no CEL references.
         diagnostics.push(...validateUnusedDeclarations(allManifests, this.celEnv));
         // Reroute diagnostics on synthetic (inline-extracted) resources back to

package/dist/normalize-inline-resources.d.ts

@@ -15,8 +15,9 @@ import type { AliasResolver } from "./alias-resolver.js";
  *   e.g. TestBasicAddition_steps_AddTwoNumbers_invoke
  *        TestBasicAddition_steps_0_invoke  (when step has no name)
  *
- * Returns a new array containing the original manifests (mutated in-place) plus all
- * extracted manifests. The original array is not mutated.
+ * 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.
  */
 export declare function normalizeInlineResources(resources: ResourceManifest[], registry: DefinitionRegistry, aliases?: AliasResolver, aliasesByModule?: Map<string, AliasResolver>): ResourceManifest[];
 //# sourceMappingURL=normalize-inline-resources.d.ts.map

package/dist/normalize-inline-resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize-inline-resources.d.ts","sourceRoot":"","sources":["../src/normalize-inline-resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAczD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAC3C,gBAAgB,EAAE,CA+DpB"}
+{"version":3,"file":"normalize-inline-resources.d.ts","sourceRoot":"","sources":["../src/normalize-inline-resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AA8BzD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAC3C,gBAAgB,EAAE,CAsEpB"}

package/dist/normalize-inline-resources.js

@@ -9,6 +9,24 @@ const SYSTEM_KINDS = new Set([
 function sanitizeName(raw) {
     return raw.replace(/[^a-zA-Z0-9_]/g, "_");
 }
+/** Deep-clones a manifest value tree so the in-place rewrites this module and
+ *  `resolveRefSentinels` perform never reach caller-owned objects. Compiled-CEL
+ *  nodes (`{__compiled, source, call?}`) are opaque leaves carrying functions —
+ *  copied by reference, never descended into — matching how `resolveRefSentinels`
+ *  and `manifest-visitor` short-circuit on `__compiled`. */
+function cloneForMutation(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (value.__compiled)
+        return value;
+    if (Array.isArray(value))
+        return value.map(cloneForMutation);
+    const out = {};
+    for (const key of Object.keys(value)) {
+        out[key] = cloneForMutation(value[key]);
+    }
+    return out;
+}
 /**
  * Phase 2 — Inline resource normalization.
  *
@@ -23,13 +41,21 @@ function sanitizeName(raw) {
  *   e.g. TestBasicAddition_steps_AddTwoNumbers_invoke
  *        TestBasicAddition_steps_0_invoke  (when step has no name)
  *
- * Returns a new array containing the original manifests (mutated in-place) plus all
- * extracted manifests. The original array is not mutated.
+ * 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.
  */
 export function normalizeInlineResources(resources, registry, aliases, aliasesByModule) {
-    const result = [...resources];
+    // 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.
+    const result = resources.map(cloneForMutation);
     // Queue: all non-system resources with a name. Extracted resources are appended.
-    const queue = resources.filter((r) => typeof r.metadata?.name === "string" && !!r.kind && !SYSTEM_KINDS.has(r.kind));
+    // Filter the CLONES (not the originals) so traversal mutates copies.
+    const queue = result.filter((r) => typeof r.metadata?.name === "string" && !!r.kind && !SYSTEM_KINDS.has(r.kind));
     let i = 0;
     while (i < queue.length) {
         const resource = queue[i++];

package/dist/resolve-throws-union.d.ts

@@ -1,5 +1,5 @@
 import type { ResourceManifest } from "@telorun/sdk";
-import type { AliasResolver } from "./alias-resolver.js";
+import { type AliasResolver } from "./alias-resolver.js";
 import type { DefinitionRegistry } from "./definition-registry.js";
 export interface ThrowsCodeMeta {
     data?: Record<string, any>;
@@ -27,10 +27,17 @@ export interface ResolveCtx {
     allManifests: ResourceManifest[];
     defs: DefinitionRegistry;
     aliases: AliasResolver;
+    /** Per-imported-library alias resolvers, keyed by module name. A manifest that
+     *  originated in an imported library resolves its kind aliases against its own
+     *  module's resolver, not the consumer's — an inline handler extracted from an
+     *  imported Http.Api inherits the lexical scope of the library that declares it. */
+    aliasesByModule: Map<string, AliasResolver>;
+    /** The consumer/root module names; resources owned by these resolve against `aliases`. */
+    rootModules: Set<string>;
     memo: Map<string, ThrowsUnion>;
     inProgress: Set<string>;
 }
-export declare function createResolveCtx(allManifests: ResourceManifest[], defs: DefinitionRegistry, aliases: AliasResolver): ResolveCtx;
+export declare function createResolveCtx(allManifests: ResourceManifest[], defs: DefinitionRegistry, aliases: AliasResolver, aliasesByModule?: Map<string, AliasResolver>, rootModules?: Set<string>): ResolveCtx;
 /** Resolve the effective throw union for a named manifest. The result combines
  *  explicit `throws.codes`, `throws.inherit: true` dataflow (step-context
  *  traversal with try/catch subtraction), and unbounded markers for

package/dist/resolve-throws-union.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-throws-union.d.ts","sourceRoot":"","sources":["../src/resolve-throws-union.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5B;AAED;;gFAEgF;AAChF,eAAO,MAAM,gBAAgB,mBAAmB,CAAC;AAEjD,MAAM,WAAW,WAAW;IAC1B,gFAAgF;IAChF,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACnC;;;8EAG0E;IAC1E,SAAS,EAAE,OAAO,CAAC;IACnB;;;;gDAI4C;IAC5C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,gBAAgB,EAAE,CAAC;IACjC,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,aAAa,CAAC;IACvB,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACzB;AAED,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,gBAAgB,EAAE,EAChC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,GACrB,UAAU,CAQZ;AAgCD;;;;8CAI8C;AAC9C,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,gBAAgB,EAC1B,GAAG,EAAE,UAAU,GACd,WAAW,CA+Cb"}
+{"version":3,"file":"resolve-throws-union.d.ts","sourceRoot":"","sources":["../src/resolve-throws-union.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEzE,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5B;AAED;;gFAEgF;AAChF,eAAO,MAAM,gBAAgB,mBAAmB,CAAC;AAEjD,MAAM,WAAW,WAAW;IAC1B,gFAAgF;IAChF,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACnC;;;8EAG0E;IAC1E,SAAS,EAAE,OAAO,CAAC;IACnB;;;;gDAI4C;IAC5C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,gBAAgB,EAAE,CAAC;IACjC,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,aAAa,CAAC;IACvB;;;wFAGoF;IACpF,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC5C,0FAA0F;IAC1F,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC/B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACzB;AAED,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,gBAAgB,EAAE,EAChC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,EACtB,eAAe,GAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAa,EACvD,WAAW,GAAE,GAAG,CAAC,MAAM,CAAa,GACnC,UAAU,CAUZ;AA6CD;;;;8CAI8C;AAC9C,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,gBAAgB,EAC1B,GAAG,EAAE,UAAU,GACd,WAAW,CAiDb"}

package/dist/resolve-throws-union.js

@@ -1,13 +1,16 @@
 import { isTaggedSentinel } from "@telorun/templating";
+import { scopeResolverForModule } from "./alias-resolver.js";
 /** Code a non-`InvokeError` failure surfaces as inside a `catch` block. Mirrors
  *  `PLAIN_ERROR_CODE` in `@telorun/run`'s `toSequenceError`: any invoke can throw
  *  a plain error, which the catch sees as `error.code === "INTERNAL_ERROR"`. */
 export const PLAIN_ERROR_CODE = "INTERNAL_ERROR";
-export function createResolveCtx(allManifests, defs, aliases) {
+export function createResolveCtx(allManifests, defs, aliases, aliasesByModule = new Map(), rootModules = new Set()) {
     return {
         allManifests,
         defs,
         aliases,
+        aliasesByModule,
+        rootModules,
         memo: new Map(),
         inProgress: new Set(),
     };
@@ -15,6 +18,10 @@ export function createResolveCtx(allManifests, defs, aliases) {
 function emptyUnion() {
     return { codes: new Map(), unbounded: false };
 }
+/** The owning module's alias resolver for a manifest in this resolve context. */
+function scopeResolverFor(ctx, ownModule) {
+    return scopeResolverForModule(ownModule, ctx.rootModules, ctx.aliasesByModule);
+}
 function unionInto(target, src) {
     for (const [code, meta] of src.codes) {
         if (!target.codes.has(code))
@@ -25,9 +32,18 @@ function unionInto(target, src) {
     if (src.canThrowPlain)
         target.canThrowPlain = true;
 }
-function definitionFor(kind, defs, aliases) {
+function definitionFor(kind, defs, aliases, scopeResolver) {
+    const direct = defs.resolve(kind);
+    if (direct)
+        return direct;
+    const scoped = scopeResolver?.resolveKind(kind);
+    if (scoped) {
+        const d = defs.resolve(scoped);
+        if (d)
+            return d;
+    }
     const resolved = aliases.resolveKind(kind);
-    return defs.resolve(kind) ?? (resolved ? defs.resolve(resolved) : undefined);
+    return resolved ? defs.resolve(resolved) : undefined;
 }
 function codesFromDefinition(definition) {
     const out = new Map();
@@ -51,7 +67,9 @@ export function resolveThrowsUnion(manifest, ctx) {
         if (ctx.inProgress.has(name))
             return emptyUnion();
     }
-    const definition = definitionFor(manifest.kind, ctx.defs, ctx.aliases);
+    const ownModule = manifest.metadata?.module;
+    const scopeResolver = scopeResolverFor(ctx, ownModule);
+    const definition = definitionFor(manifest.kind, ctx.defs, ctx.aliases, scopeResolver);
     if (!definition) {
         const u = { codes: new Map(), unbounded: true };
         if (name)
@@ -78,7 +96,7 @@ export function resolveThrowsUnion(manifest, ctx) {
             result.unbounded = true;
         }
         if (throws.inherit) {
-            const inherited = resolveInherited(manifest, definition, ctx);
+            const inherited = resolveInherited(manifest, definition, ctx, ownModule);
             unionInto(result, inherited);
         }
         if (name)
@@ -90,7 +108,7 @@ export function resolveThrowsUnion(manifest, ctx) {
             ctx.inProgress.delete(name);
     }
 }
-function resolveInherited(manifest, definition, ctx) {
+function resolveInherited(manifest, definition, ctx, ownerModule) {
     const result = { codes: new Map(), unbounded: false };
     const props = definition.schema?.properties;
     if (!props)
@@ -102,16 +120,16 @@ function resolveInherited(manifest, definition, ctx) {
         const steps = manifest[fieldName];
         if (!Array.isArray(steps))
             continue;
-        unionInto(result, collectStepArrayThrows(steps, stepCtx.invoke, undefined, ctx));
+        unionInto(result, collectStepArrayThrows(steps, stepCtx.invoke, undefined, ctx, ownerModule));
     }
     return result;
 }
-function collectStepArrayThrows(steps, invokeField, enclosingTryCodes, ctx) {
+function collectStepArrayThrows(steps, invokeField, enclosingTryCodes, ctx, ownerModule) {
     const result = emptyUnion();
     for (const step of steps) {
         if (!step || typeof step !== "object")
             continue;
-        unionInto(result, collectStepThrows(step, invokeField, enclosingTryCodes, ctx));
+        unionInto(result, collectStepThrows(step, invokeField, enclosingTryCodes, ctx, ownerModule));
     }
     return result;
 }
@@ -120,11 +138,11 @@ function collectStepArrayThrows(steps, invokeField, enclosingTryCodes, ctx) {
  *  / `else` / `elseif` / `do` / `cases` / `default`) are the same set already
  *  traversed by the analyzer's `x-telo-step-context` schema builder, so future
  *  composers that reuse those shape conventions work without changes here. */
-function collectStepThrows(step, invokeField, enclosingTryCodes, ctx) {
+function collectStepThrows(step, invokeField, enclosingTryCodes, ctx, ownerModule) {
     if (step[invokeField]) {
         // Any invoked resource can throw a non-InvokeError at runtime, which an
         // enclosing catch surfaces as PLAIN_ERROR_CODE — record that possibility.
-        const u = cloneUnion(resolveStepInvokeThrows(step, invokeField, enclosingTryCodes, ctx));
+        const u = cloneUnion(resolveStepInvokeThrows(step, invokeField, enclosingTryCodes, ctx, ownerModule));
         u.canThrowPlain = true;
         return u;
     }
@@ -132,7 +150,7 @@ function collectStepThrows(step, invokeField, enclosingTryCodes, ctx) {
         return resolveThrowStepCode(step.throw, enclosingTryCodes);
     }
     if (Array.isArray(step.try)) {
-        const tryUnion = collectStepArrayThrows(step.try, invokeField, enclosingTryCodes, ctx);
+        const tryUnion = collectStepArrayThrows(step.try, invokeField, enclosingTryCodes, ctx, ownerModule);
         let propagated;
         if (Array.isArray(step.catch)) {
             // Catch absorbs the try block's codes; the catch's own throws propagate
@@ -144,7 +162,7 @@ function collectStepThrows(step, invokeField, enclosingTryCodes, ctx) {
             // rethrow can propagate it — seed the set the catch resolves against.
             if (tryUnion.canThrowPlain)
                 tryCodes.add(PLAIN_ERROR_CODE);
-            propagated = collectStepArrayThrows(step.catch, invokeField, tryCodes, ctx);
+            propagated = collectStepArrayThrows(step.catch, invokeField, tryCodes, ctx, ownerModule);
             // Unbounded in the try block still signals the caller to expect
             // arbitrary codes to flow through the catch (e.g. via passthrough).
             if (tryUnion.unbounded)
@@ -154,37 +172,37 @@ function collectStepThrows(step, invokeField, enclosingTryCodes, ctx) {
             propagated = cloneUnion(tryUnion);
         }
         if (Array.isArray(step.finally)) {
-            unionInto(propagated, collectStepArrayThrows(step.finally, invokeField, enclosingTryCodes, ctx));
+            unionInto(propagated, collectStepArrayThrows(step.finally, invokeField, enclosingTryCodes, ctx, ownerModule));
         }
         return propagated;
     }
     if (Array.isArray(step.then)) {
         const result = emptyUnion();
-        unionInto(result, collectStepArrayThrows(step.then, invokeField, enclosingTryCodes, ctx));
+        unionInto(result, collectStepArrayThrows(step.then, invokeField, enclosingTryCodes, ctx, ownerModule));
         if (Array.isArray(step.else)) {
-            unionInto(result, collectStepArrayThrows(step.else, invokeField, enclosingTryCodes, ctx));
+            unionInto(result, collectStepArrayThrows(step.else, invokeField, enclosingTryCodes, ctx, ownerModule));
         }
         if (Array.isArray(step.elseif)) {
             for (const branch of step.elseif) {
                 if (Array.isArray(branch?.then)) {
-                    unionInto(result, collectStepArrayThrows(branch.then, invokeField, enclosingTryCodes, ctx));
+                    unionInto(result, collectStepArrayThrows(branch.then, invokeField, enclosingTryCodes, ctx, ownerModule));
                 }
             }
         }
         return result;
     }
     if (Array.isArray(step.do)) {
-        return collectStepArrayThrows(step.do, invokeField, enclosingTryCodes, ctx);
+        return collectStepArrayThrows(step.do, invokeField, enclosingTryCodes, ctx, ownerModule);
     }
     if (step.cases && typeof step.cases === "object") {
         const result = emptyUnion();
         for (const arr of Object.values(step.cases)) {
             if (Array.isArray(arr)) {
-                unionInto(result, collectStepArrayThrows(arr, invokeField, enclosingTryCodes, ctx));
+                unionInto(result, collectStepArrayThrows(arr, invokeField, enclosingTryCodes, ctx, ownerModule));
             }
         }
         if (Array.isArray(step.default)) {
-            unionInto(result, collectStepArrayThrows(step.default, invokeField, enclosingTryCodes, ctx));
+            unionInto(result, collectStepArrayThrows(step.default, invokeField, enclosingTryCodes, ctx, ownerModule));
         }
         return result;
     }
@@ -199,14 +217,18 @@ function cloneUnion(u) {
         out.canThrowPlain = true;
     return out;
 }
-function resolveStepInvokeThrows(step, invokeField, enclosingTryCodes, ctx) {
+function resolveStepInvokeThrows(step, invokeField, enclosingTryCodes, ctx, ownerModule) {
     const invokeRef = step[invokeField];
     if (!invokeRef || typeof invokeRef !== "object")
         return emptyUnion();
     const invokedKind = invokeRef.kind;
     if (!invokedKind)
         return emptyUnion();
-    const definition = definitionFor(invokedKind, ctx.defs, ctx.aliases);
+    // The invoked kind's alias resolves in the OWNER manifest's lexical scope (the
+    // composer that declares the step), so a library's step referencing its own
+    // import resolves against that library, not the consumer.
+    const scopeResolver = scopeResolverFor(ctx, ownerModule);
+    const definition = definitionFor(invokedKind, ctx.defs, ctx.aliases, scopeResolver);
     if (!definition)
         return { codes: new Map(), unbounded: true };
     if (definition.throws?.passthrough) {
@@ -215,10 +237,12 @@ function resolveStepInvokeThrows(step, invokeField, enclosingTryCodes, ctx) {
     // Named manifest: resolve the full chain (covers transitive inherit).
     const invokeName = invokeRef.name;
     if (invokeName) {
+        const scopedInvokedKind = scopeResolver?.resolveKind(invokedKind);
         const target = ctx.allManifests.find((m) => m.metadata?.name === invokeName &&
             (m.kind === invokedKind ||
                 ctx.aliases.resolveKind(m.kind) === invokedKind ||
-                m.kind === ctx.aliases.resolveKind(invokedKind)));
+                m.kind === ctx.aliases.resolveKind(invokedKind) ||
+                (scopedInvokedKind !== undefined && m.kind === scopedInvokedKind)));
         if (target)
             return resolveThrowsUnion(target, ctx);
     }

package/dist/validate-throws-coverage.d.ts

@@ -1,8 +1,8 @@
 import type { Environment } from "@marcbachmann/cel-js";
 import type { ResourceManifest } from "@telorun/sdk";
-import type { AliasResolver } from "./alias-resolver.js";
+import { type AliasResolver } from "./alias-resolver.js";
 import type { DefinitionRegistry } from "./definition-registry.js";
 import { type AnalysisDiagnostic } from "./types.js";
 /** Entry point — invoked once per analyze() run. */
-export declare function validateThrowsCoverage(manifests: ResourceManifest[], defs: DefinitionRegistry, aliases: AliasResolver, env: Environment): AnalysisDiagnostic[];
+export declare function validateThrowsCoverage(manifests: ResourceManifest[], defs: DefinitionRegistry, aliases: AliasResolver, env: Environment, aliasesByModule?: Map<string, AliasResolver>, rootModules?: Set<string>): AnalysisDiagnostic[];
 //# sourceMappingURL=validate-throws-coverage.d.ts.map

package/dist/validate-throws-coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-throws-coverage.d.ts","sourceRoot":"","sources":["../src/validate-throws-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAOnE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AA4dzE,oDAAoD;AACpD,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,WAAW,GACf,kBAAkB,EAAE,CAwCtB"}
+{"version":3,"file":"validate-throws-coverage.d.ts","sourceRoot":"","sources":["../src/validate-throws-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAOnE,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AA4dzE,oDAAoD;AACpD,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,WAAW,EAChB,eAAe,GAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAa,EACvD,WAAW,GAAE,GAAG,CAAC,MAAM,CAAa,GACnC,kBAAkB,EAAE,CAkDtB"}

package/dist/validate-throws-coverage.js

@@ -1,3 +1,4 @@
+import { scopeResolverForModule } from "./alias-resolver.js";
 import { createResolveCtx, resolveThrowsUnion, } from "./resolve-throws-union.js";
 import { DiagnosticSeverity } from "./types.js";
 import { extractAccessChains, validateChainAgainstSchema } from "./validate-cel-context.js";
@@ -406,16 +407,20 @@ function schemaHasStepContext(schema) {
     return false;
 }
 /** Entry point — invoked once per analyze() run. */
-export function validateThrowsCoverage(manifests, defs, aliases, env) {
+export function validateThrowsCoverage(manifests, defs, aliases, env, aliasesByModule = new Map(), rootModules = new Set()) {
     const diagnostics = [];
     diagnostics.push(...validateThrowsDeclarations(manifests));
-    const resolveCtx = createResolveCtx(manifests, defs, aliases);
+    const resolveCtx = createResolveCtx(manifests, defs, aliases, aliasesByModule, rootModules);
+    // The alias resolver for a manifest's own lexical scope — an imported library's
+    // resolver when it owns the manifest, else undefined (fall back to root aliases).
+    const scopeResolverFor = (m) => scopeResolverForModule(m.metadata?.module, rootModules, aliasesByModule);
     for (const manifest of manifests) {
         if (!manifest.kind || !manifest.metadata?.name)
             continue;
         if (manifest.kind === "Telo.Definition" || manifest.kind === "Telo.Abstract")
             continue;
-        const resolvedKind = aliases.resolveKind(manifest.kind);
+        const scopeResolver = scopeResolverFor(manifest);
+        const resolvedKind = scopeResolver?.resolveKind(manifest.kind) ?? aliases.resolveKind(manifest.kind);
         const definition = defs.resolve(manifest.kind) ?? (resolvedKind ? defs.resolve(resolvedKind) : undefined);
         if (!definition?.schema)
             continue;
@@ -426,7 +431,7 @@ export function validateThrowsCoverage(manifests, defs, aliases, env) {
         }, (entries, arrayPath, siblingData, catchesFor) => {
             diagnostics.push(...checkCatchAllPlacement(entries, resource, "catches", filePath, arrayPath));
             const handlerRef = resolveHandlerRef(siblingData[catchesFor]);
-            const union = handlerRefUnion(handlerRef, manifests, resolveCtx);
+            const union = handlerRefUnion(handlerRef, manifests, resolveCtx, scopeResolver);
             diagnostics.push(...checkCatchesCoverage(entries, union, resource, filePath, arrayPath, env));
             diagnostics.push(...checkTypedErrorData(entries, union, resource, filePath, arrayPath, env));
         });
@@ -436,19 +441,22 @@ export function validateThrowsCoverage(manifests, defs, aliases, env) {
 /** Resolve a handler ref's effective throw union. Prefers the named manifest
  *  (so `inherit: true` handlers expose their transitive union); falls back to
  *  the definition's own codes when no name is given. */
-function handlerRefUnion(handlerRef, manifests, ctx) {
+function handlerRefUnion(handlerRef, manifests, ctx, scopeResolver) {
     if (!handlerRef)
         return { codes: new Map(), unbounded: false };
     if (handlerRef.name) {
-        const resolvedKind = ctx.aliases.resolveKind(handlerRef.kind);
+        const resolvedKind = scopeResolver?.resolveKind(handlerRef.kind) ?? ctx.aliases.resolveKind(handlerRef.kind);
         const targetManifest = manifests.find((m) => m.metadata?.name === handlerRef.name &&
             (m.kind === handlerRef.kind ||
                 m.kind === resolvedKind ||
+                scopeResolver?.resolveKind(m.kind) === handlerRef.kind ||
                 ctx.aliases.resolveKind(m.kind) === handlerRef.kind));
         if (targetManifest)
             return resolveThrowsUnion(targetManifest, ctx);
     }
-    const resolved = ctx.aliases.resolveKind(handlerRef.kind);
+    // No named target — fall back to the handler kind's own declared codes,
+    // resolving the kind in the owner's lexical scope first, then root aliases.
+    const resolved = scopeResolver?.resolveKind(handlerRef.kind) ?? ctx.aliases.resolveKind(handlerRef.kind);
     const def = ctx.defs.resolve(handlerRef.kind) ?? (resolved ? ctx.defs.resolve(resolved) : undefined);
     if (!def?.throws)
         return { codes: new Map(), unbounded: false };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "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.23.0"
+    "@telorun/sdk": "0.26.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/alias-resolver.ts

@@ -69,3 +69,22 @@ export class AliasResolver {
     return result;
   }
 }
+
+/**
+ * The alias resolver for a resource's own lexical scope. A resource that
+ * originated in an imported library (its `ownModule` names a non-root module —
+ * e.g. an inline handler extracted from an imported Http.Api) resolves its kind
+ * aliases against THAT library's import map, so an anonymous child inherits the
+ * lexical scope of the document that declares it. Returns undefined for
+ * root/consumer-owned resources (and unknown modules), so callers fall back to
+ * the root `aliases`.
+ */
+export function scopeResolverForModule(
+  ownModule: string | undefined,
+  rootModules: Set<string>,
+  aliasesByModule: Map<string, AliasResolver>,
+): AliasResolver | undefined {
+  return ownModule && !rootModules.has(ownModule)
+    ? aliasesByModule.get(ownModule)
+    : undefined;
+}

package/src/analyzer.ts

@@ -1,7 +1,7 @@
 import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
 import type { Environment } from "@marcbachmann/cel-js";
 import { defaultRegistry, isTaggedSentinel } from "@telorun/templating";
-import { AliasResolver } from "./alias-resolver.js";
+import { AliasResolver, scopeResolverForModule } from "./alias-resolver.js";
 import { AnalysisRegistry } from "./analysis-registry.js";
 import {
   buildCelEnvironment,
@@ -938,8 +938,15 @@ export class StaticAnalyzer {
 
       // Resolve kind through alias if needed; direct lookup takes priority so that
       // aliases whose name matches the module name (the common case) work without
-      // path-derived name mangling.
-      const resolvedKind = aliases.resolveKind(m.kind);
+      // path-derived name mangling. A resource that originated in an imported library
+      // (its `metadata.module` names a non-root module — e.g. an inline route handler
+      // extracted from an imported Http.Api) must resolve its kind alias against THAT
+      // library's import map, not the consumer's; an anonymous child inherits the
+      // lexical scope of the document that declares it. Mirrors the nested-inline and
+      // reference-resolution paths: own-module scope first, root/consumer aliases last.
+      const ownModule = (m.metadata as { module?: string } | undefined)?.module;
+      const scopeResolver = scopeResolverForModule(ownModule, rootModules, aliasesByModule);
+      const resolvedKind = scopeResolver?.resolveKind(m.kind) ?? aliases.resolveKind(m.kind);
       const definition =
         defs.resolve(m.kind) ?? (resolvedKind ? defs.resolve(resolvedKind) : undefined);
       if (!definition) {
@@ -1025,10 +1032,8 @@ export class StaticAnalyzer {
         // first, then the parent module's own aliases (for resources declared
         // inside an imported module), then the root aliases. Mirrors how the
         // analyzer resolves kinds elsewhere so module-scoped aliases don't
-        // produce false UNDEFINED_KIND diagnostics.
-        const ownModule = (m.metadata as { module?: string } | undefined)?.module;
-        const scopeResolver =
-          ownModule && !rootModules.has(ownModule) ? aliasesByModule.get(ownModule) : undefined;
+        // produce false UNDEFINED_KIND diagnostics. `scopeResolver` is the
+        // owning module's resolver computed above.
         diagnostics.push(
           ...validateNestedInlineResources(
             m,
@@ -1304,7 +1309,9 @@ export class StaticAnalyzer {
     diagnostics.push(...validateProviderCoherence(allManifests, defs, aliases));
 
     // Validate throws: declarations and catches: coverage (rules 1, 2, 4, 7)
-    diagnostics.push(...validateThrowsCoverage(allManifests, defs, aliases, this.celEnv));
+    diagnostics.push(
+      ...validateThrowsCoverage(allManifests, defs, aliases, this.celEnv, aliasesByModule, rootModules),
+    );
 
     // Warn about declared variables / secrets / ports that no CEL references.
     diagnostics.push(...validateUnusedDeclarations(allManifests, this.celEnv));

package/src/normalize-inline-resources.ts

@@ -15,6 +15,22 @@ function sanitizeName(raw: string): string {
   return raw.replace(/[^a-zA-Z0-9_]/g, "_");
 }
 
+/** Deep-clones a manifest value tree so the in-place rewrites this module and
+ *  `resolveRefSentinels` perform never reach caller-owned objects. Compiled-CEL
+ *  nodes (`{__compiled, source, call?}`) are opaque leaves carrying functions —
+ *  copied by reference, never descended into — matching how `resolveRefSentinels`
+ *  and `manifest-visitor` short-circuit on `__compiled`. */
+function cloneForMutation(value: unknown): unknown {
+  if (value === null || typeof value !== "object") return value;
+  if ((value as { __compiled?: unknown }).__compiled) return value;
+  if (Array.isArray(value)) return value.map(cloneForMutation);
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(value)) {
+    out[key] = cloneForMutation((value as Record<string, unknown>)[key]);
+  }
+  return out;
+}
+
 /**
  * Phase 2 — Inline resource normalization.
  *
@@ -29,8 +45,9 @@ function sanitizeName(raw: string): string {
  *   e.g. TestBasicAddition_steps_AddTwoNumbers_invoke
  *        TestBasicAddition_steps_0_invoke  (when step has no name)
  *
- * Returns a new array containing the original manifests (mutated in-place) plus all
- * extracted manifests. The original array is not mutated.
+ * 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.
  */
 export function normalizeInlineResources(
   resources: ResourceManifest[],
@@ -38,10 +55,17 @@ export function normalizeInlineResources(
   aliases?: AliasResolver,
   aliasesByModule?: Map<string, AliasResolver>,
 ): ResourceManifest[] {
-  const result = [...resources];
+  // 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.
+  const result = resources.map(cloneForMutation) as ResourceManifest[];
 
   // Queue: all non-system resources with a name. Extracted resources are appended.
-  const queue = resources.filter(
+  // Filter the CLONES (not the originals) so traversal mutates copies.
+  const queue = result.filter(
     (r): r is ResourceManifest & { metadata: { name: string } } =>
       typeof r.metadata?.name === "string" && !!r.kind && !SYSTEM_KINDS.has(r.kind),
   );

package/src/resolve-throws-union.ts

@@ -1,6 +1,6 @@
 import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
 import { isTaggedSentinel } from "@telorun/templating";
-import type { AliasResolver } from "./alias-resolver.js";
+import { scopeResolverForModule, type AliasResolver } from "./alias-resolver.js";
 import type { DefinitionRegistry } from "./definition-registry.js";
 
 export interface ThrowsCodeMeta {
@@ -32,6 +32,13 @@ export interface ResolveCtx {
   allManifests: ResourceManifest[];
   defs: DefinitionRegistry;
   aliases: AliasResolver;
+  /** Per-imported-library alias resolvers, keyed by module name. A manifest that
+   *  originated in an imported library resolves its kind aliases against its own
+   *  module's resolver, not the consumer's — an inline handler extracted from an
+   *  imported Http.Api inherits the lexical scope of the library that declares it. */
+  aliasesByModule: Map<string, AliasResolver>;
+  /** The consumer/root module names; resources owned by these resolve against `aliases`. */
+  rootModules: Set<string>;
   memo: Map<string, ThrowsUnion>;
   inProgress: Set<string>;
 }
@@ -40,11 +47,15 @@ export function createResolveCtx(
   allManifests: ResourceManifest[],
   defs: DefinitionRegistry,
   aliases: AliasResolver,
+  aliasesByModule: Map<string, AliasResolver> = new Map(),
+  rootModules: Set<string> = new Set(),
 ): ResolveCtx {
   return {
     allManifests,
     defs,
     aliases,
+    aliasesByModule,
+    rootModules,
     memo: new Map(),
     inProgress: new Set(),
   };
@@ -54,6 +65,11 @@ function emptyUnion(): ThrowsUnion {
   return { codes: new Map(), unbounded: false };
 }
 
+/** The owning module's alias resolver for a manifest in this resolve context. */
+function scopeResolverFor(ctx: ResolveCtx, ownModule: string | undefined): AliasResolver | undefined {
+  return scopeResolverForModule(ownModule, ctx.rootModules, ctx.aliasesByModule);
+}
+
 function unionInto(target: ThrowsUnion, src: ThrowsUnion): void {
   for (const [code, meta] of src.codes) {
     if (!target.codes.has(code)) target.codes.set(code, meta);
@@ -66,9 +82,17 @@ function definitionFor(
   kind: string,
   defs: DefinitionRegistry,
   aliases: AliasResolver,
+  scopeResolver?: AliasResolver,
 ): ResourceDefinition | undefined {
+  const direct = defs.resolve(kind);
+  if (direct) return direct;
+  const scoped = scopeResolver?.resolveKind(kind);
+  if (scoped) {
+    const d = defs.resolve(scoped);
+    if (d) return d;
+  }
   const resolved = aliases.resolveKind(kind);
-  return defs.resolve(kind) ?? (resolved ? defs.resolve(resolved) : undefined);
+  return resolved ? defs.resolve(resolved) : undefined;
 }
 
 function codesFromDefinition(definition: ResourceDefinition): Map<string, ThrowsCodeMeta> {
@@ -97,7 +121,9 @@ export function resolveThrowsUnion(
     if (ctx.inProgress.has(name)) return emptyUnion();
   }
 
-  const definition = definitionFor(manifest.kind, ctx.defs, ctx.aliases);
+  const ownModule = (manifest.metadata as { module?: string } | undefined)?.module;
+  const scopeResolver = scopeResolverFor(ctx, ownModule);
+  const definition = definitionFor(manifest.kind, ctx.defs, ctx.aliases, scopeResolver);
   if (!definition) {
     const u: ThrowsUnion = { codes: new Map(), unbounded: true };
     if (name) ctx.memo.set(name, u);
@@ -126,7 +152,7 @@ export function resolveThrowsUnion(
     }
 
     if (throws.inherit) {
-      const inherited = resolveInherited(manifest, definition, ctx);
+      const inherited = resolveInherited(manifest, definition, ctx, ownModule);
       unionInto(result, inherited);
     }
 
@@ -141,6 +167,7 @@ function resolveInherited(
   manifest: ResourceManifest,
   definition: ResourceDefinition,
   ctx: ResolveCtx,
+  ownerModule: string | undefined,
 ): ThrowsUnion {
   const result: ThrowsUnion = { codes: new Map(), unbounded: false };
   const props = definition.schema?.properties as Record<string, any> | undefined;
@@ -151,7 +178,7 @@ function resolveInherited(
     if (!stepCtx?.invoke) continue;
     const steps = (manifest as Record<string, any>)[fieldName];
     if (!Array.isArray(steps)) continue;
-    unionInto(result, collectStepArrayThrows(steps, stepCtx.invoke, undefined, ctx));
+    unionInto(result, collectStepArrayThrows(steps, stepCtx.invoke, undefined, ctx, ownerModule));
   }
 
   return result;
@@ -162,13 +189,14 @@ function collectStepArrayThrows(
   invokeField: string,
   enclosingTryCodes: Set<string> | undefined,
   ctx: ResolveCtx,
+  ownerModule: string | undefined,
 ): ThrowsUnion {
   const result = emptyUnion();
   for (const step of steps) {
     if (!step || typeof step !== "object") continue;
     unionInto(
       result,
-      collectStepThrows(step as Record<string, any>, invokeField, enclosingTryCodes, ctx),
+      collectStepThrows(step as Record<string, any>, invokeField, enclosingTryCodes, ctx, ownerModule),
     );
   }
   return result;
@@ -184,11 +212,14 @@ function collectStepThrows(
   invokeField: string,
   enclosingTryCodes: Set<string> | undefined,
   ctx: ResolveCtx,
+  ownerModule: string | undefined,
 ): ThrowsUnion {
   if (step[invokeField]) {
     // Any invoked resource can throw a non-InvokeError at runtime, which an
     // enclosing catch surfaces as PLAIN_ERROR_CODE — record that possibility.
-    const u = cloneUnion(resolveStepInvokeThrows(step, invokeField, enclosingTryCodes, ctx));
+    const u = cloneUnion(
+      resolveStepInvokeThrows(step, invokeField, enclosingTryCodes, ctx, ownerModule),
+    );
     u.canThrowPlain = true;
     return u;
   }
@@ -198,7 +229,7 @@ function collectStepThrows(
   }
 
   if (Array.isArray(step.try)) {
-    const tryUnion = collectStepArrayThrows(step.try, invokeField, enclosingTryCodes, ctx);
+    const tryUnion = collectStepArrayThrows(step.try, invokeField, enclosingTryCodes, ctx, ownerModule);
     let propagated: ThrowsUnion;
     if (Array.isArray(step.catch)) {
       // Catch absorbs the try block's codes; the catch's own throws propagate
@@ -209,7 +240,7 @@ function collectStepThrows(
       // `error.code === PLAIN_ERROR_CODE`, so a `throw: { code: error.code }`
       // rethrow can propagate it — seed the set the catch resolves against.
       if (tryUnion.canThrowPlain) tryCodes.add(PLAIN_ERROR_CODE);
-      propagated = collectStepArrayThrows(step.catch, invokeField, tryCodes, ctx);
+      propagated = collectStepArrayThrows(step.catch, invokeField, tryCodes, ctx, ownerModule);
       // Unbounded in the try block still signals the caller to expect
       // arbitrary codes to flow through the catch (e.g. via passthrough).
       if (tryUnion.unbounded) propagated.unbounded = true;
@@ -219,7 +250,7 @@ function collectStepThrows(
     if (Array.isArray(step.finally)) {
       unionInto(
         propagated,
-        collectStepArrayThrows(step.finally, invokeField, enclosingTryCodes, ctx),
+        collectStepArrayThrows(step.finally, invokeField, enclosingTryCodes, ctx, ownerModule),
       );
     }
     return propagated;
@@ -227,16 +258,16 @@ function collectStepThrows(
 
   if (Array.isArray(step.then)) {
     const result = emptyUnion();
-    unionInto(result, collectStepArrayThrows(step.then, invokeField, enclosingTryCodes, ctx));
+    unionInto(result, collectStepArrayThrows(step.then, invokeField, enclosingTryCodes, ctx, ownerModule));
     if (Array.isArray(step.else)) {
-      unionInto(result, collectStepArrayThrows(step.else, invokeField, enclosingTryCodes, ctx));
+      unionInto(result, collectStepArrayThrows(step.else, invokeField, enclosingTryCodes, ctx, ownerModule));
     }
     if (Array.isArray(step.elseif)) {
       for (const branch of step.elseif) {
         if (Array.isArray(branch?.then)) {
           unionInto(
             result,
-            collectStepArrayThrows(branch.then, invokeField, enclosingTryCodes, ctx),
+            collectStepArrayThrows(branch.then, invokeField, enclosingTryCodes, ctx, ownerModule),
           );
         }
       }
@@ -245,18 +276,18 @@ function collectStepThrows(
   }
 
   if (Array.isArray(step.do)) {
-    return collectStepArrayThrows(step.do, invokeField, enclosingTryCodes, ctx);
+    return collectStepArrayThrows(step.do, invokeField, enclosingTryCodes, ctx, ownerModule);
   }
 
   if (step.cases && typeof step.cases === "object") {
     const result = emptyUnion();
     for (const arr of Object.values(step.cases as Record<string, unknown>)) {
       if (Array.isArray(arr)) {
-        unionInto(result, collectStepArrayThrows(arr, invokeField, enclosingTryCodes, ctx));
+        unionInto(result, collectStepArrayThrows(arr, invokeField, enclosingTryCodes, ctx, ownerModule));
       }
     }
     if (Array.isArray(step.default)) {
-      unionInto(result, collectStepArrayThrows(step.default, invokeField, enclosingTryCodes, ctx));
+      unionInto(result, collectStepArrayThrows(step.default, invokeField, enclosingTryCodes, ctx, ownerModule));
     }
     return result;
   }
@@ -277,13 +308,18 @@ function resolveStepInvokeThrows(
   invokeField: string,
   enclosingTryCodes: Set<string> | undefined,
   ctx: ResolveCtx,
+  ownerModule: string | undefined,
 ): ThrowsUnion {
   const invokeRef = step[invokeField];
   if (!invokeRef || typeof invokeRef !== "object") return emptyUnion();
   const invokedKind = invokeRef.kind as string | undefined;
   if (!invokedKind) return emptyUnion();
 
-  const definition = definitionFor(invokedKind, ctx.defs, ctx.aliases);
+  // The invoked kind's alias resolves in the OWNER manifest's lexical scope (the
+  // composer that declares the step), so a library's step referencing its own
+  // import resolves against that library, not the consumer.
+  const scopeResolver = scopeResolverFor(ctx, ownerModule);
+  const definition = definitionFor(invokedKind, ctx.defs, ctx.aliases, scopeResolver);
   if (!definition) return { codes: new Map(), unbounded: true };
 
   if (definition.throws?.passthrough) {
@@ -293,12 +329,14 @@ function resolveStepInvokeThrows(
   // Named manifest: resolve the full chain (covers transitive inherit).
   const invokeName = invokeRef.name as string | undefined;
   if (invokeName) {
+    const scopedInvokedKind = scopeResolver?.resolveKind(invokedKind);
     const target = ctx.allManifests.find(
       (m) =>
         m.metadata?.name === invokeName &&
         (m.kind === invokedKind ||
           ctx.aliases.resolveKind(m.kind) === invokedKind ||
-          m.kind === ctx.aliases.resolveKind(invokedKind)),
+          m.kind === ctx.aliases.resolveKind(invokedKind) ||
+          (scopedInvokedKind !== undefined && m.kind === scopedInvokedKind)),
     );
     if (target) return resolveThrowsUnion(target, ctx);
   }

package/src/validate-throws-coverage.ts

@@ -1,6 +1,6 @@
 import type { ASTNode, Environment } from "@marcbachmann/cel-js";
 import type { ResourceManifest } from "@telorun/sdk";
-import type { AliasResolver } from "./alias-resolver.js";
+import { scopeResolverForModule, type AliasResolver } from "./alias-resolver.js";
 import type { DefinitionRegistry } from "./definition-registry.js";
 import {
   createResolveCtx,
@@ -490,16 +490,28 @@ export function validateThrowsCoverage(
   defs: DefinitionRegistry,
   aliases: AliasResolver,
   env: Environment,
+  aliasesByModule: Map<string, AliasResolver> = new Map(),
+  rootModules: Set<string> = new Set(),
 ): AnalysisDiagnostic[] {
   const diagnostics: AnalysisDiagnostic[] = [];
   diagnostics.push(...validateThrowsDeclarations(manifests));
 
-  const resolveCtx = createResolveCtx(manifests, defs, aliases);
+  const resolveCtx = createResolveCtx(manifests, defs, aliases, aliasesByModule, rootModules);
+
+  // The alias resolver for a manifest's own lexical scope — an imported library's
+  // resolver when it owns the manifest, else undefined (fall back to root aliases).
+  const scopeResolverFor = (m: ResourceManifest): AliasResolver | undefined =>
+    scopeResolverForModule(
+      (m.metadata as { module?: string } | undefined)?.module,
+      rootModules,
+      aliasesByModule,
+    );
 
   for (const manifest of manifests) {
     if (!manifest.kind || !manifest.metadata?.name) continue;
     if (manifest.kind === "Telo.Definition" || manifest.kind === "Telo.Abstract") continue;
-    const resolvedKind = aliases.resolveKind(manifest.kind);
+    const scopeResolver = scopeResolverFor(manifest);
+    const resolvedKind = scopeResolver?.resolveKind(manifest.kind) ?? aliases.resolveKind(manifest.kind);
     const definition =
       defs.resolve(manifest.kind) ?? (resolvedKind ? defs.resolve(resolvedKind) : undefined);
     if (!definition?.schema) continue;
@@ -519,7 +531,7 @@ export function validateThrowsCoverage(
           ...checkCatchAllPlacement(entries, resource, "catches", filePath, arrayPath),
         );
         const handlerRef = resolveHandlerRef(siblingData[catchesFor]);
-        const union = handlerRefUnion(handlerRef, manifests, resolveCtx);
+        const union = handlerRefUnion(handlerRef, manifests, resolveCtx, scopeResolver);
         diagnostics.push(
           ...checkCatchesCoverage(entries, union, resource, filePath, arrayPath, env),
         );
@@ -539,20 +551,24 @@ function handlerRefUnion(
   handlerRef: { kind: string; name?: string } | null,
   manifests: ResourceManifest[],
   ctx: ReturnType<typeof createResolveCtx>,
+  scopeResolver: AliasResolver | undefined,
 ): ThrowsUnion {
   if (!handlerRef) return { codes: new Map(), unbounded: false };
   if (handlerRef.name) {
-    const resolvedKind = ctx.aliases.resolveKind(handlerRef.kind);
+    const resolvedKind = scopeResolver?.resolveKind(handlerRef.kind) ?? ctx.aliases.resolveKind(handlerRef.kind);
     const targetManifest = manifests.find(
       (m) =>
         m.metadata?.name === handlerRef.name &&
         (m.kind === handlerRef.kind ||
           m.kind === resolvedKind ||
+          scopeResolver?.resolveKind(m.kind) === handlerRef.kind ||
           ctx.aliases.resolveKind(m.kind) === handlerRef.kind),
     );
     if (targetManifest) return resolveThrowsUnion(targetManifest, ctx);
   }
-  const resolved = ctx.aliases.resolveKind(handlerRef.kind);
+  // No named target — fall back to the handler kind's own declared codes,
+  // resolving the kind in the owner's lexical scope first, then root aliases.
+  const resolved = scopeResolver?.resolveKind(handlerRef.kind) ?? ctx.aliases.resolveKind(handlerRef.kind);
   const def =
     ctx.defs.resolve(handlerRef.kind) ?? (resolved ? ctx.defs.resolve(resolved) : undefined);
   if (!def?.throws) return { codes: new Map(), unbounded: false };