@telorun/analyzer 0.14.0 → 0.16.0

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/types.ts

@@ -63,6 +63,15 @@ export interface LoadOptions {
    *  so the kernel can evaluate them at runtime. Leave unset (false) for static analysis —
    *  the analyzer works on raw strings and does not need compiled values. */
   compile?: boolean;
+  /** When true, each module document's inline `imports:` map is desugared into
+   *  synthetic `Telo.Import` manifests appended to the file's `manifests` /
+   *  `positions` (the AST `documents` array is left raw). On for every resolved
+   *  consumer — the kernel's analysis and runtime loads, and the analyzer — so
+   *  inline imports participate in discovery, alias resolution, and execution.
+   *  Off for the editor's round-trip view, which reads the raw `imports:` map and
+   *  pairs manifests to YAML nodes by index. Folded into the file cache key so a
+   *  desugared and a raw load of the same file never collide. */
+  desugarImports?: boolean;
 }
 
 export interface LoaderInitOptions {

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 };
-    }
-}