@telorun/analyzer 0.14.0 → 0.15.0

package/dist/analyzer.d.ts.map

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

package/dist/analyzer.js

@@ -696,14 +696,12 @@ export class StaticAnalyzer {
             if (m.kind === "Telo.Abstract") {
                 continue;
             }
-            // Forwarded foreign exports (an imported library's exported instances, whose
-            // metadata.module isn't a root module here) were already validated in their own
-            // module's standalone analysis, and their `kind`/CEL are authored in that module's
-            // scope (e.g. `Self.X` resolves to that module, not the consumer). Re-validating them
-            // against the consumer's scope yields false UNDEFINED_KIND / scope-mismatch errors, so
-            // skip — they participate in this analysis only as cross-module resolution targets.
-            const mModule = m.metadata?.module;
-            if (typeof mModule === "string" && !rootModules.has(mModule)) {
+            // Forwarded exports (flagged by flattenForAnalyzer) are an imported library's exported
+            // instances, already validated in their own module's standalone analysis; their
+            // `kind`/CEL are authored in that module's scope (e.g. `Self.X` → that module, not the
+            // consumer). Re-validating against the consumer's scope yields false UNDEFINED_KIND /
+            // scope-mismatch errors, so skip — they participate here only as resolution targets.
+            if (m.metadata?.forwardedExport === true) {
                 continue;
             }
             const resource = { kind: m.kind, name: m.metadata?.name };

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,EAuZ/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,EA4Z/C,CAAC"}

package/dist/builtins.js

@@ -396,7 +396,12 @@ export const KERNEL_BUILTINS = [
                     type: "object",
                     properties: {
                         kinds: { type: "array", items: { type: "string" } },
-                        resources: { type: "array", items: { type: "string" } },
+                        // `variables` / `secrets` are reserved on the resources.<Alias> value-flow
+                        // surface, so a library may not export instances under those names.
+                        resources: {
+                            type: "array",
+                            items: { type: "string", not: { enum: ["variables", "secrets"] } },
+                        },
                     },
                     additionalProperties: true,
                 },

package/dist/flatten-for-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flatten-for-analyzer.d.ts","sourceRoot":"","sources":["../src/flatten-for-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAc,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAG/E;;;;;;;;;;;;;;;;;;6EAkB6E;AAC7E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,gBAAgB,EAAE,CAyEzE;AAED;;;;;6BAK6B;AAC7B,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,gBAAgB,EAAE,CAEzE"}
+{"version":3,"file":"flatten-for-analyzer.d.ts","sourceRoot":"","sources":["../src/flatten-for-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAc,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAG/E;;;;;;;;;;;;;;;;;;6EAkB6E;AAC7E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,gBAAgB,EAAE,CA6EzE;AAED;;;;;6BAK6B;AAC7B,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,gBAAgB,EAAE,CAEzE"}

package/dist/flatten-for-analyzer.js

@@ -52,10 +52,14 @@ export function flattenForAnalyzer(graph) {
                     // Forward instances listed in the library's `exports.resources` so the
                     // consumer's analyzer can resolve, gate, kind-check, and draw topology edges
                     // for cross-module `!ref Alias.name`. The gate IS this forwarding — only
-                    // exported names cross the boundary. `metadata.module` (stamped by
-                    // collectModuleManifests) marks them foreign, so ref validation treats them
-                    // as resolution targets, not as sources to re-validate.
-                    result.push(m);
+                    // exported names cross the boundary. `metadata.forwardedExport` marks them as
+                    // cross-module resolution targets only (keyed by `metadata.module`), so ref
+                    // resolution / validation treats them as targets, never as local sources to
+                    // re-validate or walk.
+                    result.push({
+                        ...m,
+                        metadata: { ...m.metadata, forwardedExport: true },
+                    });
                 }
             }
         }

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

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

package/dist/resolve-ref-sentinels.js

@@ -1,5 +1,4 @@
 import { isRefSentinel } from "@telorun/templating";
-import { isModuleKind } from "./module-kinds.js";
 import { isRefEntry } from "./reference-field-map.js";
 import { REF_RESOLUTION_SKIP_KINDS as SYSTEM_KINDS } from "./system-kinds.js";
 /**
@@ -28,17 +27,10 @@ export function resolveRefSentinels(resources, registry, aliases, aliasesByModul
 // pass — which loads the entry module only — can still resolve `!ref Alias.name` against
 // imported libraries' exported instances.
 crossModuleTargets = []) {
-    const rootModules = new Set();
-    for (const r of resources) {
-        if (isModuleKind(r.kind) && typeof r.metadata?.name === "string") {
-            rootModules.add(r.metadata.name);
-        }
-    }
     const moduleOf = (r) => r.metadata?.module;
-    const isForeign = (r) => {
-        const mod = moduleOf(r);
-        return typeof mod === "string" && !rootModules.has(mod);
-    };
+    // Forwarded exports are flagged by flattenForAnalyzer (`metadata.forwardedExport`); they're
+    // cross-module resolution targets only — never walked as local ref sources here.
+    const isForeign = (r) => r.metadata?.forwardedExport === true;
     // Local resources resolve a bare / `Self.`-qualified name; forwarded foreign exports
     // resolve an `Alias.`-qualified name keyed by (module, name).
     const byName = new Map();

package/dist/validate-references.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMrD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AA6C/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CA2etB"}
+{"version":3,"file":"validate-references.d.ts","sourceRoot":"","sources":["../src/validate-references.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMrD,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AA4C/F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,EAAE,eAAe,GACvB,kBAAkB,EAAE,CAgftB"}

package/dist/validate-references.js

@@ -4,7 +4,6 @@ import { isInlineResource, resolveFieldEntries, resolveFieldValues } from "./ref
 import { navigateJsonPointer } from "./schema-compat.js";
 import { REF_VALIDATION_SKIP_KINDS as SYSTEM_KINDS } from "./system-kinds.js";
 import { DiagnosticSeverity } from "./types.js";
-import { isModuleKind } from "./module-kinds.js";
 const SOURCE = "telo-analyzer";
 /**
  * Checks whether `kind` satisfies the ref constraint in `entry`.
@@ -99,33 +98,37 @@ export function validateReferences(resources, context) {
     // Forwarded foreign exports (an imported library's exported instances, carrying a
     // metadata.module that isn't a root module) are resolution TARGETS only: excluded from
     // duplicate detection and local name resolution, and never walked as ref sources.
-    const rootModules = new Set();
-    for (const r of resources) {
-        if (isModuleKind(r.kind) && typeof r.metadata?.name === "string") {
-            rootModules.add(r.metadata.name);
-        }
-    }
     const moduleOf = (r) => r.metadata?.module;
-    const isForeign = (r) => {
-        const mod = moduleOf(r);
-        return typeof mod === "string" && !rootModules.has(mod);
-    };
+    // Forwarded exports are flagged by flattenForAnalyzer (`metadata.forwardedExport`); they're
+    // cross-module resolution targets only — excluded from duplicate detection and local name
+    // resolution, and never walked as ref sources.
+    const isForeign = (r) => r.metadata?.forwardedExport === true;
+    // Forwarded exported instances keyed `${module}\0${name}` — the lookup that resolves
+    // whether a cross-module `!ref Alias.name` names a real exported instance.
     const byModuleName = new Map();
+    /** Modules whose import subtree was actually loaded in this analysis. A resolved
+     *  `Telo.Import` carries `resolvedModuleName` (stamped only once the edge — and thus the
+     *  imported module — resolved); forwarded exports carry `metadata.module`. Either marks
+     *  the module loaded independent of how many instances it exports, so a loaded library
+     *  that exports nothing still reports invalid cross-module refs, while partial single-file
+     *  analysis (neither present) is skipped to avoid false `UNRESOLVED_REFERENCE`. */
+    const loadedModules = new Set();
     for (const r of resources) {
+        if (r.kind === "Telo.Import") {
+            const m = r.metadata?.resolvedModuleName;
+            if (typeof m === "string")
+                loadedModules.add(m);
+            continue;
+        }
         if (!r.metadata?.name || SYSTEM_KINDS.has(r.kind) || !isForeign(r))
             continue;
-        byModuleName.set(`${moduleOf(r)}\0${r.metadata.name}`, r);
+        const m = moduleOf(r);
+        if (!m)
+            continue;
+        byModuleName.set(`${m}\0${r.metadata.name}`, r);
+        loadedModules.add(m);
     }
-    /** Whether the analysis set actually carries the named module's exported instances.
-     *  False in partial single-file analysis (the import subtree wasn't loaded) — used to
-     *  skip cross-module resolution checks rather than emit false `UNRESOLVED_REFERENCE`. */
-    const moduleLoaded = (module) => {
-        const prefix = `${module}\0`;
-        for (const key of byModuleName.keys())
-            if (key.startsWith(prefix))
-                return true;
-        return false;
-    };
+    const moduleLoaded = (module) => loadedModules.has(module);
     const localResources = resources.filter((r) => !isForeign(r));
     const byNameAll = new Map();
     const seen = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/analyzer",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Telo Analyzer - Static manifest validator for Telo manifests.",
   "keywords": [
     "telo",
@@ -42,15 +42,16 @@
     "ajv-formats": "^3.0.1",
     "jsonpath-plus": "^10.3.0",
     "yaml": "^2.8.3",
-    "@telorun/templating": "0.4.0"
+    "@telorun/templating": "0.4.1"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.8",
+    "@telorun/sdk": "0.16.0"
   },
   "peerDependencies": {
-    "@telorun/sdk": "0.13.0"
+    "@telorun/sdk": "*"
   },
   "scripts": {
     "build": "tsc -p tsconfig.lib.json",

package/src/alias-resolver.ts

@@ -11,6 +11,15 @@ export class AliasResolver {
     }
   }
 
+  /** Real module name an alias points at (e.g. "Console" → "console"), or undefined.
+   *  Used to resolve an alias-qualified instance reference "Console.writeLine" to the
+   *  forwarded resource declared in that module. The `exports.resources` gate is enforced
+   *  upstream by `flattenForAnalyzer` (only exported instances are forwarded), so a name
+   *  that isn't exported simply won't be found. */
+  moduleForAlias(alias: string): string | undefined {
+    return this.importAliases.get(alias);
+  }
+
   /** Resolves "Http.Api" → "http-server.Api". Returns undefined if alias is unknown. */
   resolveKind(kind: string): string | undefined {
     if (!kind) {

package/src/analyzer.ts

@@ -633,16 +633,19 @@ export class StaticAnalyzer {
         // through the same alias machinery as user-declared Telo.Imports —
         // honours the library's `exports.kinds` list, no special cases.
         if (moduleName) {
-          const exportedKinds: string[] = ((m as any).exports?.kinds as string[] | undefined) ?? [];
+          // `Self` resolves the library's own kinds UNGATED — a library may reference
+          // its own kinds regardless of `exports.kinds`, which gates importers, not
+          // internal use. This is what lets a library declare an instance of a kind it
+          // does not export (e.g. console's `writeLine`) to enforce a singleton.
           if (rootModules.has(moduleName)) {
-            aliases.registerImport("Self", moduleName, exportedKinds);
+            aliases.registerImport("Self", moduleName, []);
           } else {
             let libResolver = aliasesByModule.get(moduleName);
             if (!libResolver) {
               libResolver = new AliasResolver();
               aliasesByModule.set(moduleName, libResolver);
             }
-            libResolver.registerImport("Self", moduleName, exportedKinds);
+            libResolver.registerImport("Self", moduleName, []);
           }
         }
       }
@@ -825,6 +828,15 @@ export class StaticAnalyzer {
         continue;
       }
 
+      // Forwarded exports (flagged by flattenForAnalyzer) are an imported library's exported
+      // instances, already validated in their own module's standalone analysis; their
+      // `kind`/CEL are authored in that module's scope (e.g. `Self.X` → that module, not the
+      // consumer). Re-validating against the consumer's scope yields false UNDEFINED_KIND /
+      // scope-mismatch errors, so skip — they participate here only as resolution targets.
+      if ((m.metadata as { forwardedExport?: boolean } | undefined)?.forwardedExport === true) {
+        continue;
+      }
+
       const resource = { kind: m.kind, name: m.metadata?.name as string };
 
       // Resolve kind through alias if needed; direct lookup takes priority so that
@@ -1196,7 +1208,14 @@ export class StaticAnalyzer {
     );
   }
 
-  normalize(manifests: ResourceManifest[], registry: AnalysisRegistry): ResourceManifest[] {
+  normalize(
+    manifests: ResourceManifest[],
+    registry: AnalysisRegistry,
+    // Forwarded foreign exports used only as cross-module resolution targets (see
+    // resolveRefSentinels). The kernel passes its analyzer-flattened set so the
+    // entry-only runtime pass can still resolve `!ref Alias.name`.
+    crossModuleTargets?: ResourceManifest[],
+  ): ResourceManifest[] {
     const ctx = registry._context();
     const normalized = normalizeInlineResources(
       manifests,
@@ -1207,7 +1226,13 @@ export class StaticAnalyzer {
     // Resolve !ref sentinels after normalize so both the original and
     // inline-extracted manifests get their refs canonicalized to
     // {kind, name} for the kernel that consumes this output.
-    resolveRefSentinels(normalized, ctx.definitions!, ctx.aliases, ctx.aliasesByModule);
+    resolveRefSentinels(
+      normalized,
+      ctx.definitions!,
+      ctx.aliases,
+      ctx.aliasesByModule,
+      crossModuleTargets ?? [],
+    );
     return normalized;
   }
 

package/src/builtins.ts

@@ -398,6 +398,12 @@ export const KERNEL_BUILTINS: ResourceDefinition[] = [
           type: "object",
           properties: {
             kinds: { type: "array", items: { type: "string" } },
+            // `variables` / `secrets` are reserved on the resources.<Alias> value-flow
+            // surface, so a library may not export instances under those names.
+            resources: {
+              type: "array",
+              items: { type: "string", not: { enum: ["variables", "secrets"] } },
+            },
           },
           additionalProperties: true,
         },

package/src/flatten-for-analyzer.ts

@@ -44,6 +44,10 @@ export function flattenForAnalyzer(graph: LoadedGraph): ResourceManifest[] {
       if (!targetModule) continue;
 
       const stamped = collectModuleManifests(targetModule);
+      const libDoc = stamped.find((m) => isModuleKind(m.kind));
+      const exportedResources = new Set<string>(
+        (libDoc as { exports?: { resources?: string[] } } | undefined)?.exports?.resources ?? [],
+      );
       for (const m of stamped) {
         if (
           m.kind === "Telo.Definition" ||
@@ -51,6 +55,22 @@ export function flattenForAnalyzer(graph: LoadedGraph): ResourceManifest[] {
           m.kind === "Telo.Import"
         ) {
           result.push(m);
+        } else if (
+          !isModuleKind(m.kind) &&
+          typeof m.metadata?.name === "string" &&
+          exportedResources.has(m.metadata.name as string)
+        ) {
+          // Forward instances listed in the library's `exports.resources` so the
+          // consumer's analyzer can resolve, gate, kind-check, and draw topology edges
+          // for cross-module `!ref Alias.name`. The gate IS this forwarding — only
+          // exported names cross the boundary. `metadata.forwardedExport` marks them as
+          // cross-module resolution targets only (keyed by `metadata.module`), so ref
+          // resolution / validation treats them as targets, never as local sources to
+          // re-validate or walk.
+          result.push({
+            ...m,
+            metadata: { ...m.metadata, forwardedExport: true } as ResourceManifest["metadata"],
+          });
         }
       }
     }

package/src/resolve-ref-sentinels.ts

@@ -5,43 +5,100 @@ import type { DefinitionRegistry } from "./definition-registry.js";
 import { isRefEntry } from "./reference-field-map.js";
 import { REF_RESOLUTION_SKIP_KINDS as SYSTEM_KINDS } from "./system-kinds.js";
 
+/** Resolved ref shape written in place of a `!ref` sentinel. `alias` is set only for
+ *  cross-module references (resolved into an imported library's exported instance). */
+type ResolvedRef = { kind: string; name: string; alias?: string };
+
 /**
  * Walks every `x-telo-ref` slot in every non-system resource and rewrites
- * `!ref <name>` sentinels in-place to `{kind: <resolved-kind>, name}`.
+ * `!ref <name>` sentinels in-place to `{kind, name}` (local) or
+ * `{kind, name, alias}` (cross-module).
  *
- * The downstream pipeline (inline normalization, dependency graph, kernel
- * controllers) expects every ref-slot value to be either a `{kind, name}`
- * object, an inline-definition object, or a legacy bare string — resolving
- * sentinels here keeps that contract intact so each consumer doesn't need
- * its own sentinel branch.
+ * Reference grammar — the tag's source string is split on the FIRST dot:
+ *   - `!ref writeLine`          → local resource `writeLine`
+ *   - `!ref Self.writeLine`     → local resource `writeLine` (explicit self-qualifier)
+ *   - `!ref Console.writeLine`  → instance `writeLine` exported by the import aliased
+ *                                 `Console`, resolved against the forwarded foreign set
  *
- * The walker assigns `kind` by name lookup (resource names are unique
- * within a manifest scope). When the name doesn't resolve in the local
- * `byName` map, the sentinel is left in place so `validateReferences`
- * can emit the `UNRESOLVED_REFERENCE` diagnostic with full context.
+ * Aliases are PascalCase identifiers without dots and resource names carry no dots
+ * (enforced as a hard diagnostic), so the first-dot split is unambiguous. When the
+ * name doesn't resolve, the sentinel is left in place so `validateReferences` emits the
+ * `UNRESOLVED_REFERENCE` diagnostic with full context.
  *
- * Mutation strategy: the field-path walker descends the resource tree
- * directly and replaces the sentinel on its parent container. Re-parsing
- * a string-encoded concrete path (the earlier shape) coupled the writer
- * to the path-encoding rules of `resolveFieldEntries` — any new path
- * marker would silently break this writer. Descending directly avoids
- * that coupling.
+ * Forwarded foreign resources (an imported library's exported instances, carrying a
+ * `metadata.module` that isn't a root module) are resolution TARGETS only — they are not
+ * re-walked as sources here, since their own ref slots belong to their own module scope.
  */
 export function resolveRefSentinels(
   resources: ResourceManifest[],
   registry: DefinitionRegistry,
   aliases?: AliasResolver,
   aliasesByModule?: Map<string, AliasResolver>,
+  // Extra foreign resources used only as cross-module resolution TARGETS (not mutated, not
+  // walked as sources). The kernel passes the analyzer-flattened set here so the runtime
+  // pass — which loads the entry module only — can still resolve `!ref Alias.name` against
+  // imported libraries' exported instances.
+  crossModuleTargets: ResourceManifest[] = [],
 ): void {
+  const moduleOf = (r: ResourceManifest): string | undefined =>
+    (r.metadata as { module?: string } | undefined)?.module;
+  // Forwarded exports are flagged by flattenForAnalyzer (`metadata.forwardedExport`); they're
+  // cross-module resolution targets only — never walked as local ref sources here.
+  const isForeign = (r: ResourceManifest): boolean =>
+    (r.metadata as { forwardedExport?: boolean } | undefined)?.forwardedExport === true;
+
+  // Local resources resolve a bare / `Self.`-qualified name; forwarded foreign exports
+  // resolve an `Alias.`-qualified name keyed by (module, name).
   const byName = new Map<string, ResourceManifest>();
+  const byModuleName = new Map<string, ResourceManifest>();
   for (const r of resources) {
-    if (r.metadata?.name && !SYSTEM_KINDS.has(r.kind)) {
-      byName.set(r.metadata.name as string, r);
+    if (!r.metadata?.name || SYSTEM_KINDS.has(r.kind)) continue;
+    const name = r.metadata.name as string;
+    if (isForeign(r)) {
+      byModuleName.set(`${moduleOf(r)}\0${name}`, r);
+    } else {
+      byName.set(name, r);
     }
   }
+  for (const r of crossModuleTargets) {
+    if (!r.metadata?.name || SYSTEM_KINDS.has(r.kind) || !isForeign(r)) continue;
+    byModuleName.set(`${moduleOf(r)}\0${r.metadata.name as string}`, r);
+  }
+
+  const resolveTarget = (source: string): ResolvedRef | undefined => {
+    const dot = source.indexOf(".");
+    if (dot === -1) {
+      const t = byName.get(source);
+      return t ? { kind: t.kind as string, name: source } : undefined;
+    }
+    const alias = source.slice(0, dot);
+    const name = source.slice(dot + 1);
+    if (alias === "Self") {
+      const t = byName.get(name);
+      return t ? { kind: t.kind as string, name } : undefined;
+    }
+    const module = aliases?.moduleForAlias(alias);
+    if (module) {
+      const t = byModuleName.get(`${module}\0${name}`);
+      if (t) {
+        // The foreign instance's `kind` is authored in ITS module's scope (e.g.
+        // `Self.WriteLine`); canonicalize to a scope-independent `<module>.<Kind>` for the
+        // consumer's kind check. `Self.` maps to the owning module directly — the forwarded
+        // library's Library doc (hence its `Self` alias) isn't in the consumer's manifest
+        // set — while other alias prefixes resolve via that module's forwarded import scope.
+        const rawKind = t.kind as string;
+        const foreignKind = rawKind.startsWith("Self.")
+          ? `${module}.${rawKind.slice("Self.".length)}`
+          : aliasesByModule?.get(module)?.resolveKind(rawKind) ?? rawKind;
+        return { kind: foreignKind, name, alias };
+      }
+    }
+    return undefined;
+  };
 
   for (const r of resources) {
     if (!r.metadata?.name || !r.kind || SYSTEM_KINDS.has(r.kind)) continue;
+    if (isForeign(r)) continue;
 
     const fieldMap =
       aliases && aliasesByModule
@@ -51,45 +108,33 @@ export function resolveRefSentinels(
 
     for (const [fieldPath, entry] of fieldMap) {
       if (!isRefEntry(entry)) continue;
-      replaceSentinelsAtPath(r as Record<string, unknown>, fieldPath, byName);
+      descend(r as Record<string, unknown>, fieldPath.split("."), resolveTarget);
     }
   }
 }
 
-/** Walks `obj` along `fieldPath` (dot notation with `[]` for arrays and
- *  `{}` for additionalProperties-typed maps) and replaces any `!ref`
- *  sentinel value at the terminal slot with `{kind, name}` looked up
- *  via `byName`. Mutates the parent container in place; no string-path
- *  round-trip. */
-function replaceSentinelsAtPath(
-  obj: Record<string, unknown>,
-  fieldPath: string,
-  byName: Map<string, ResourceManifest>,
-): void {
-  const parts = fieldPath.split(".");
-  descend(obj, parts, byName);
-}
-
+/** Walks `obj` along `fieldPath` parts (dot notation with `[]` for arrays and `{}` for
+ *  additionalProperties-typed maps) and replaces any `!ref` sentinel at the terminal slot
+ *  with its resolved `{kind, name, alias?}`. Mutates the parent container in place. */
 function descend(
   obj: unknown,
   parts: string[],
-  byName: Map<string, ResourceManifest>,
+  resolve: (source: string) => ResolvedRef | undefined,
 ): void {
   if (obj == null || typeof obj !== "object" || parts.length === 0) return;
   const [head, ...rest] = parts;
 
-  // Map iteration: descend into every value of the current object.
   if (head === "{}") {
     const container = obj as Record<string, unknown>;
     for (const key of Object.keys(container)) {
       const child = container[key];
       if (rest.length === 0) {
         if (isRefSentinel(child)) {
-          const target = byName.get(child.source);
-          if (target) container[key] = { kind: target.kind as string, name: child.source };
+          const target = resolve(child.source);
+          if (target) container[key] = target;
         }
       } else {
-        descend(child, rest, byName);
+        descend(child, rest, resolve);
       }
     }
     return;
@@ -107,21 +152,21 @@ function descend(
       if (rest.length === 0) {
         const elem = val[i];
         if (isRefSentinel(elem)) {
-          const target = byName.get(elem.source);
-          if (target) val[i] = { kind: target.kind as string, name: elem.source };
+          const target = resolve(elem.source);
+          if (target) val[i] = target;
         }
       } else {
-        descend(val[i], rest, byName);
+        descend(val[i], rest, resolve);
       }
     }
   } else {
     if (rest.length === 0) {
       if (isRefSentinel(val)) {
-        const target = byName.get(val.source);
-        if (target) container[key] = { kind: target.kind as string, name: val.source };
+        const target = resolve(val.source);
+        if (target) container[key] = target;
       }
     } else {
-      descend(val, rest, byName);
+      descend(val, rest, resolve);
     }
   }
 }

package/src/validate-references.ts

@@ -107,10 +107,46 @@ export function validateReferences(
   // source, different sourceLine) keep separate fingerprints and still
   // trip the diagnostic. `analyze()` enforces that every non-system
   // manifest carries both positional fields — no defensive guard needed.
+  // Forwarded foreign exports (an imported library's exported instances, carrying a
+  // metadata.module that isn't a root module) are resolution TARGETS only: excluded from
+  // duplicate detection and local name resolution, and never walked as ref sources.
+  const moduleOf = (r: ResourceManifest): string | undefined =>
+    (r.metadata as { module?: string } | undefined)?.module;
+  // Forwarded exports are flagged by flattenForAnalyzer (`metadata.forwardedExport`); they're
+  // cross-module resolution targets only — excluded from duplicate detection and local name
+  // resolution, and never walked as ref sources.
+  const isForeign = (r: ResourceManifest): boolean =>
+    (r.metadata as { forwardedExport?: boolean } | undefined)?.forwardedExport === true;
+  // Forwarded exported instances keyed `${module}\0${name}` — the lookup that resolves
+  // whether a cross-module `!ref Alias.name` names a real exported instance.
+  const byModuleName = new Map<string, ResourceManifest>();
+  /** Modules whose import subtree was actually loaded in this analysis. A resolved
+   *  `Telo.Import` carries `resolvedModuleName` (stamped only once the edge — and thus the
+   *  imported module — resolved); forwarded exports carry `metadata.module`. Either marks
+   *  the module loaded independent of how many instances it exports, so a loaded library
+   *  that exports nothing still reports invalid cross-module refs, while partial single-file
+   *  analysis (neither present) is skipped to avoid false `UNRESOLVED_REFERENCE`. */
+  const loadedModules = new Set<string>();
+  for (const r of resources) {
+    if (r.kind === "Telo.Import") {
+      const m = (r.metadata as { resolvedModuleName?: unknown } | undefined)?.resolvedModuleName;
+      if (typeof m === "string") loadedModules.add(m);
+      continue;
+    }
+    if (!r.metadata?.name || SYSTEM_KINDS.has(r.kind) || !isForeign(r)) continue;
+    const m = moduleOf(r);
+    if (!m) continue;
+    byModuleName.set(`${m}\0${r.metadata.name as string}`, r);
+    loadedModules.add(m);
+  }
+  const moduleLoaded = (module: string): boolean => loadedModules.has(module);
+  const localResources = resources.filter((r) => !isForeign(r));
+
   const byNameAll = new Map<string, ResourceManifest[]>();
   const seen = new Set<string>();
   for (const r of resources) {
-    if (!r.metadata?.name || SYSTEM_KINDS.has(r.kind) || r.kind === "Telo.Import") continue;
+    if (!r.metadata?.name || SYSTEM_KINDS.has(r.kind) || r.kind === "Telo.Import" || isForeign(r))
+      continue;
     const name = r.metadata.name as string;
     // `analyze()` guarantees both fields are present on non-system manifests.
     const meta = r.metadata as unknown as { source: string; sourceLine: number };
@@ -148,6 +184,33 @@ export function validateReferences(
       });
     }
   }
+  // A resource name must contain no dot. The `!ref` resolver splits the tag's source on
+  // the first dot to separate an import alias from the resource name, so a dotted name
+  // would mis-resolve into a cross-module lookup. This is the load-bearing invariant of
+  // the reference grammar, so it is enforced here rather than left to the (unenforced)
+  // casing convention.
+  for (const [name, list] of byNameAll) {
+    if (!name.includes(".")) continue;
+    for (const r of list) {
+      const m = r.metadata as { source?: string; sourceLine?: number } | undefined;
+      const range =
+        typeof m?.sourceLine === "number"
+          ? {
+              start: { line: m.sourceLine, character: 0 },
+              end: { line: m.sourceLine, character: Number.MAX_SAFE_INTEGER },
+            }
+          : undefined;
+      diagnostics.push({
+        severity: DiagnosticSeverity.Error,
+        code: "INVALID_RESOURCE_NAME",
+        source: SOURCE,
+        message: `${r.kind}/${name}: resource name must not contain '.' — in a '!ref' the '.' separates an import alias from the resource name`,
+        ...(range ? { range } : {}),
+        data: { resource: { kind: r.kind, name }, filePath: m?.source, path: "metadata.name" },
+      });
+    }
+  }
+
   // Single-resource map for the resolution / scope lookups below — when a
   // collision exists, falling back to the first occurrence keeps the rest
   // of the pass behaving the same as before the duplicate diagnostic was
@@ -161,7 +224,7 @@ export function validateReferences(
   // enclosure (`inScope`) and the scope manifests visible to it — so this
   // handler only validates, it does not re-walk.
   visitManifest(
-    resources,
+    localResources,
     registry,
     {
       onRef: (e) => {
@@ -178,14 +241,37 @@ export function validateReferences(
         // string/inline ambiguity at the source.
         if (isRefSentinel(val)) {
           const refName = val.source;
+          const dot = refName.indexOf(".");
+          const aliasPrefix = dot > 0 ? refName.slice(0, dot) : undefined;
+
+          // Cross-module sentinel left unresolved by Phase 2.5 — it qualifies an import
+          // alias. If that module's exports are loaded in this analysis, the miss is real
+          // (name not in exports.resources, or a typo); if not (partial single-file
+          // analysis), skip rather than emit a false UNRESOLVED_REFERENCE.
+          if (aliasPrefix && aliasPrefix !== "Self" && aliases.hasAlias(aliasPrefix)) {
+            const module = aliases.moduleForAlias(aliasPrefix);
+            if (module && !moduleLoaded(module)) return;
+            diagnostics.push({
+              severity: DiagnosticSeverity.Error,
+              code: "UNRESOLVED_REFERENCE",
+              source: SOURCE,
+              message: `${resourceLabel}: reference at '${concretePath}' → '${refName}' is not exported by module '${module ?? aliasPrefix}' (add it to exports.resources)`,
+              data: { resource: resourceData, filePath, path: concretePath },
+            });
+            return;
+          }
+
+          // Local reference (bare name or explicit `Self.`-qualified).
+          const localName = aliasPrefix === "Self" ? refName.slice(dot + 1) : refName;
           const target =
-            byName.get(refName) ?? visibleScopeManifests.find((m) => m.metadata?.name === refName);
+            byName.get(localName) ??
+            visibleScopeManifests.find((m) => m.metadata?.name === localName);
           if (!target) {
             diagnostics.push({
               severity: DiagnosticSeverity.Error,
               code: "UNRESOLVED_REFERENCE",
               source: SOURCE,
-              message: `${resourceLabel}: reference at '${concretePath}' → resource '${refName}' not found`,
+              message: `${resourceLabel}: reference at '${concretePath}' → resource '${localName}' not found`,
               data: { resource: resourceData, filePath, path: concretePath },
             });
             return;
@@ -280,9 +366,18 @@ export function validateReferences(
         }
 
         // 3. Resolution check — resource with this name must exist.
-        const exists =
-          byName.has(refVal.name) ||
-          visibleScopeManifests.some((m) => m.metadata?.name === refVal.name);
+        let exists: boolean;
+        if (typeof refVal.alias === "string" && refVal.alias !== "Self") {
+          // Cross-module ref resolved by Phase 2.5. Validate against the forwarded
+          // exports when loaded; in partial context (module not loaded) assume resolvable.
+          const module = aliases.moduleForAlias(refVal.alias);
+          exists =
+            !module || !moduleLoaded(module) || byModuleName.has(`${module}\0${refVal.name}`);
+        } else {
+          exists =
+            byName.has(refVal.name) ||
+            visibleScopeManifests.some((m) => m.metadata?.name === refVal.name);
+        }
         if (!exists) {
           diagnostics.push({
             severity: DiagnosticSeverity.Error,
@@ -303,7 +398,7 @@ export function validateReferences(
   // validate the field value against the resulting sub-schema. Driven off the base map
   // (un-expanded) so each schema-from slot is seen as its own site.
   visitManifest(
-    resources,
+    localResources,
     registry,
     {
       onSchemaFrom: (e) => {

package/dist/adapters/http-adapter.d.ts

@@ -1,10 +0,0 @@
-import { type ManifestAdapter } from "../types.js";
-export declare class HttpAdapter implements ManifestAdapter {
-    supports(url: string): boolean;
-    read(url: string): Promise<{
-        text: string;
-        source: string;
-    }>;
-    resolveRelative(base: string, relative: string): string;
-}
-//# sourceMappingURL=http-adapter.d.ts.map

package/dist/adapters/http-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/http-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9E,qBAAa,WAAY,YAAW,eAAe;IACjD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIxB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAWlE,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;CAIxD"}

package/dist/adapters/http-adapter.js

@@ -1,18 +0,0 @@
-import { DEFAULT_MANIFEST_FILENAME } from "../types.js";
-export class HttpAdapter {
-    supports(url) {
-        return url.startsWith("http://") || url.startsWith("https://");
-    }
-    async read(url) {
-        const fetchUrl = url.includes(".yaml") ? url : `${url}/${DEFAULT_MANIFEST_FILENAME}`;
-        const response = await fetch(fetchUrl);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch manifest from ${fetchUrl}: ${response.status} ${response.statusText}`);
-        }
-        return { text: await response.text(), source: fetchUrl };
-    }
-    resolveRelative(base, relative) {
-        const baseDir = base.endsWith("/") ? base : base.slice(0, base.lastIndexOf("/") + 1);
-        return new URL(relative, baseDir).href;
-    }
-}

package/dist/adapters/node-adapter.d.ts

@@ -1,17 +0,0 @@
-import { type ManifestAdapter } from "../types.js";
-/** Node.js fs-based ManifestAdapter for local files. Not browser-compatible. */
-export declare class NodeAdapter implements ManifestAdapter {
-    private readonly cwd;
-    constructor(cwd?: string);
-    supports(url: string): boolean;
-    read(url: string): Promise<{
-        text: string;
-        source: string;
-    }>;
-    resolveRelative(base: string, relative: string): string;
-    expandGlob(base: string, patterns: string[]): Promise<string[]>;
-    resolveOwnerOf(fileUrl: string): Promise<string | null>;
-}
-/** @deprecated Use `new NodeAdapter(cwd)` instead */
-export declare function createNodeAdapter(cwd?: string): ManifestAdapter;
-//# sourceMappingURL=node-adapter.d.ts.map

package/dist/adapters/node-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/node-adapter.ts"],"names":[],"mappings":"AAIA,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAM9E,gFAAgF;AAChF,qBAAa,WAAY,YAAW,eAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,GAAE,MAAsB;IAExD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAUxB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IASlE,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAKjD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAc/D,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAoB9D;AAED,qDAAqD;AACrD,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAsB,GAAG,eAAe,CAE9E"}

package/dist/adapters/node-adapter.js

@@ -1,71 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { minimatch } from "minimatch";
-import { DEFAULT_MANIFEST_FILENAME } from "../types.js";
-function toFilePath(url) {
-    return url.startsWith("file://") ? fileURLToPath(url) : url;
-}
-/** Node.js fs-based ManifestAdapter for local files. Not browser-compatible. */
-export class NodeAdapter {
-    cwd;
-    constructor(cwd = process.cwd()) {
-        this.cwd = cwd;
-    }
-    supports(url) {
-        return (url.startsWith("file://") ||
-            url.startsWith("/") ||
-            url.startsWith("./") ||
-            url.startsWith("../") ||
-            (!url.includes("://") && !url.includes("@")));
-    }
-    async read(url) {
-        const filePath = toFilePath(url);
-        const stat = await fs.stat(filePath).catch(() => null);
-        const resolvedPath = stat?.isDirectory() ? path.join(filePath, DEFAULT_MANIFEST_FILENAME) : filePath;
-        const text = await fs.readFile(resolvedPath, "utf8");
-        return { text, source: resolvedPath };
-    }
-    resolveRelative(base, relative) {
-        const baseDir = path.dirname(path.resolve(this.cwd, toFilePath(base)));
-        return path.resolve(baseDir, relative);
-    }
-    async expandGlob(base, patterns) {
-        const baseDir = path.dirname(path.resolve(this.cwd, toFilePath(base)));
-        const entries = await fs.readdir(baseDir, { recursive: true, encoding: "utf8" });
-        const normalizedPatterns = patterns.map((p) => p.replace(/\\/g, "/").replace(/^\.\//, ""));
-        const matched = [];
-        for (const entry of entries) {
-            const normalized = entry.replace(/\\/g, "/");
-            if (normalizedPatterns.some((p) => minimatch(normalized, p))) {
-                matched.push(path.resolve(baseDir, entry));
-            }
-        }
-        return matched.sort();
-    }
-    async resolveOwnerOf(fileUrl) {
-        const resolved = path.resolve(this.cwd, toFilePath(fileUrl));
-        let dir = path.dirname(resolved);
-        while (true) {
-            const candidate = path.join(dir, DEFAULT_MANIFEST_FILENAME);
-            if (candidate !== resolved) {
-                try {
-                    await fs.access(candidate);
-                    return candidate;
-                }
-                catch {
-                    // telo.yaml not found at this level
-                }
-            }
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-        return null;
-    }
-}
-/** @deprecated Use `new NodeAdapter(cwd)` instead */
-export function createNodeAdapter(cwd = process.cwd()) {
-    return new NodeAdapter(cwd);
-}

package/dist/adapters/registry-adapter.d.ts

@@ -1,15 +0,0 @@
-import { type ManifestAdapter } from "../types.js";
-export declare class RegistryAdapter implements ManifestAdapter {
-    private registryUrl;
-    constructor(registryUrl?: string);
-    supports(url: string): boolean;
-    read(moduleRef: string): Promise<{
-        text: string;
-        source: string;
-    }>;
-    resolveRelative(base: string, relative: string): string;
-    private toRegistryModuleBase;
-    private toRegistryUrl;
-    private parseModuleRef;
-}
-//# sourceMappingURL=registry-adapter.d.ts.map

package/dist/adapters/registry-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/registry-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAI9E,qBAAa,eAAgB,YAAW,eAAe;IACzC,OAAO,CAAC,WAAW;gBAAX,WAAW,SAAuB;IAEtD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAWxB,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAWxE,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAMvD,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,cAAc;CAmBvB"}

package/dist/adapters/registry-adapter.js

@@ -1,53 +0,0 @@
-import { DEFAULT_MANIFEST_FILENAME } from "../types.js";
-const DEFAULT_REGISTRY_URL = "https://registry.telo.run";
-export class RegistryAdapter {
-    registryUrl;
-    constructor(registryUrl = DEFAULT_REGISTRY_URL) {
-        this.registryUrl = registryUrl;
-    }
-    supports(url) {
-        return (!url.startsWith("http://") &&
-            !url.startsWith("https://") &&
-            !url.startsWith("/") &&
-            !url.startsWith(".") &&
-            url.includes("@") &&
-            url.includes("/"));
-    }
-    async read(moduleRef) {
-        const fetchUrl = this.toRegistryUrl(moduleRef);
-        const response = await fetch(fetchUrl);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch manifest ${moduleRef}: ${response.status} ${response.statusText}`);
-        }
-        return { text: await response.text(), source: fetchUrl };
-    }
-    resolveRelative(base, relative) {
-        const baseUrl = this.supports(base) ? this.toRegistryModuleBase(base) : base;
-        const baseWithSlash = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-        return new URL(relative, baseWithSlash).href;
-    }
-    toRegistryModuleBase(moduleRef) {
-        const parsed = this.parseModuleRef(moduleRef);
-        const normalizedBase = this.registryUrl.replace(/\/+$/, "");
-        return `${normalizedBase}/${parsed.modulePath}/${parsed.version}`;
-    }
-    toRegistryUrl(moduleRef) {
-        return `${this.toRegistryModuleBase(moduleRef)}/${DEFAULT_MANIFEST_FILENAME}`;
-    }
-    parseModuleRef(moduleRef) {
-        const atIdx = moduleRef.lastIndexOf("@");
-        if (atIdx <= 0 || atIdx === moduleRef.length - 1) {
-            throw new Error(`Invalid module reference '${moduleRef}', expected namespace/name@version`);
-        }
-        const modulePath = moduleRef.slice(0, atIdx);
-        if (!modulePath.includes("/")) {
-            throw new Error(`Invalid module reference '${moduleRef}', expected namespace/name@version`);
-        }
-        const rawVersion = moduleRef.slice(atIdx + 1);
-        const version = rawVersion.startsWith("v") ? rawVersion.substring(1) : rawVersion;
-        if (!version) {
-            throw new Error(`Invalid module reference '${moduleRef}', expected namespace/name@version`);
-        }
-        return { modulePath, version };
-    }
-}