@telorun/analyzer 0.3.0 → 0.5.0

package/src/manifest-loader.ts

@@ -1,8 +1,8 @@
 import type { Environment } from "@marcbachmann/cel-js";
 import { isCompiledValue, type ResourceManifest } from "@telorun/sdk";
 import { isMap, isPair, isScalar, isSeq, parseAllDocuments, type Document } from "yaml";
-import { HttpAdapter } from "./adapters/http-adapter.js";
-import { RegistryAdapter } from "./adapters/registry-adapter.js";
+import { HttpSource } from "./sources/http-source.js";
+import { RegistrySource } from "./sources/registry-source.js";
 import { buildCelEnvironment } from "./cel-environment.js";
 import { isModuleKind } from "./module-kinds.js";
 import { precompileDoc } from "./precompile.js";
@@ -10,7 +10,7 @@ import {
   DEFAULT_MANIFEST_FILENAME,
   type LoadOptions,
   type LoaderInitOptions,
-  type ManifestAdapter,
+  type ManifestSource,
   type Position,
   type PositionIndex,
 } from "./types.js";
@@ -23,42 +23,42 @@ const SYSTEM_KINDS = new Set([
 ]);
 
 export class Loader {
-  private static readonly moduleCache = new Map<
+  private readonly moduleCache = new Map<
     string,
     { text: string; manifests: ResourceManifest[] }
   >();
 
-  protected adapters: ManifestAdapter[];
+  protected sources: ManifestSource[];
   private readonly celEnv: Environment;
 
-  constructor(extraAdaptersOrOptions: ManifestAdapter[] | LoaderInitOptions = []) {
-    const options: LoaderInitOptions = Array.isArray(extraAdaptersOrOptions)
-      ? { extraAdapters: extraAdaptersOrOptions }
-      : extraAdaptersOrOptions;
+  constructor(extraSourcesOrOptions: ManifestSource[] | LoaderInitOptions = []) {
+    const options: LoaderInitOptions = Array.isArray(extraSourcesOrOptions)
+      ? { extraSources: extraSourcesOrOptions }
+      : extraSourcesOrOptions;
 
-    const includeHttpAdapter = options.includeHttpAdapter ?? true;
-    const includeRegistryAdapter = options.includeRegistryAdapter ?? true;
+    const includeHttpSource = options.includeHttpSource ?? true;
+    const includeRegistrySource = options.includeRegistrySource ?? true;
 
-    this.adapters = [];
-    if (includeHttpAdapter) this.adapters.push(new HttpAdapter());
-    if (includeRegistryAdapter) this.adapters.push(new RegistryAdapter(options.registryUrl));
+    this.sources = [];
+    if (includeHttpSource) this.sources.push(new HttpSource());
+    if (includeRegistrySource) this.sources.push(new RegistrySource(options.registryUrl));
 
-    if (options.extraAdapters?.length) {
-      this.adapters.unshift(...options.extraAdapters);
+    if (options.extraSources?.length) {
+      this.sources.unshift(...options.extraSources);
     }
 
     this.celEnv = buildCelEnvironment(options.celHandlers);
   }
 
-  register(adapter: ManifestAdapter): this {
-    this.adapters.unshift(adapter);
+  register(source: ManifestSource): this {
+    this.sources.unshift(source);
     return this;
   }
 
-  private pick(url: string): ManifestAdapter {
-    const a = this.adapters.find((a) => a.supports(url));
-    if (!a) throw new Error(`No adapter found for: ${url}`);
-    return a;
+  private pick(url: string): ManifestSource {
+    const s = this.sources.find((s) => s.supports(url));
+    if (!s) throw new Error(`No source found for: ${url}`);
+    return s;
   }
 
   async resolveEntryPoint(url: string): Promise<string> {
@@ -69,7 +69,7 @@ export class Loader {
   async loadModule(url: string, options?: LoadOptions): Promise<ResourceManifest[]> {
     const { text, source } = await this.pick(url).read(url);
     const cacheKey = `${options?.compile ? "compiled" : "raw"}:${source}`;
-    const cached = Loader.moduleCache.get(cacheKey);
+    const cached = this.moduleCache.get(cacheKey);
     if (cached && cached.text === text) {
       return cloneManifestArray(cached.manifests);
     }
@@ -152,8 +152,8 @@ export class Loader {
       const includePatterns = (moduleManifest as any).include as string[] | undefined;
       if (includePatterns?.length) {
         hasIncludes = true;
-        const adapter = this.pick(source);
-        const includedFiles = await this.resolveIncludes(source, includePatterns, adapter);
+        const picked = this.pick(source);
+        const includedFiles = await this.resolveIncludes(source, includePatterns, picked);
         for (const includedUrl of includedFiles) {
           const partialManifests = await this.loadPartialFile(includedUrl, moduleName, options);
           resolved.push(...partialManifests);
@@ -162,7 +162,7 @@ export class Loader {
     }
 
     if (!hasIncludes) {
-      Loader.moduleCache.set(cacheKey, { text, manifests: resolved });
+      this.moduleCache.set(cacheKey, { text, manifests: resolved });
     }
     return cloneManifestArray(resolved);
   }
@@ -170,21 +170,21 @@ export class Loader {
   private async resolveIncludes(
     ownerSource: string,
     patterns: string[],
-    adapter: ManifestAdapter,
+    source: ManifestSource,
   ): Promise<string[]> {
     const hasGlobs = patterns.some((p) => /[*?{}\[\]]/.test(p));
     if (hasGlobs) {
-      if (!adapter.expandGlob) {
+      if (!source.expandGlob) {
         throw new Error(
-          `Include patterns in '${ownerSource}' contain globs but the adapter for this source ` +
+          `Include patterns in '${ownerSource}' contain globs but the source for this URL ` +
             `does not support glob expansion. Use explicit file paths instead of patterns like: ` +
             patterns.filter((p) => /[*?{}\[\]]/.test(p)).join(", "),
         );
       }
-      return adapter.expandGlob(ownerSource, patterns);
+      return source.expandGlob(ownerSource, patterns);
     }
     // Literal relative paths — deduplicate in case the same file appears under multiple patterns.
-    return [...new Set(patterns.map((p) => adapter.resolveRelative(ownerSource, p)))];
+    return [...new Set(patterns.map((p) => source.resolveRelative(ownerSource, p)))];
   }
 
   private async loadPartialFile(
@@ -280,9 +280,9 @@ export class Loader {
     }
 
     // Find the owning telo.yaml via parent-directory traversal
-    const adapter = this.pick(fileUrl);
-    if (!adapter.resolveOwnerOf) return null;
-    const ownerUrl = await adapter.resolveOwnerOf(fileUrl);
+    const source = this.pick(fileUrl);
+    if (!source.resolveOwnerOf) return null;
+    const ownerUrl = await source.resolveOwnerOf(fileUrl);
     if (!ownerUrl) return null;
 
     // Load the owner module (which will load included files via include expansion)
@@ -333,8 +333,34 @@ export class Loader {
 
   async loadManifests(entryUrl: string): Promise<ResourceManifest[]> {
     const visited = new Set<string>([entryUrl]);
+    // Cache resolved library identity per import URL so a Telo.Import re-encountered
+    // through a different chain still gets `resolvedModuleName` / `resolvedNamespace`
+    // stamped — without re-loading the target. The early `visited` short-circuit used
+    // to silently leave duplicate Telo.Imports unstamped, which broke alias resolution
+    // when the same library was imported by two different files in the same analysis set.
+    const libraryIdentityByUrl = new Map<
+      string,
+      { name: string; namespace: string | null }
+    >();
     const entry = await this.loadModule(entryUrl);
 
+    // Forward Telo.Definition, Telo.Abstract, AND Telo.Import docs from imported
+    // libraries to the analyzer so its downstream passes can see them:
+    //  - Definitions / Abstracts feed cross-package `x-telo-ref` resolution and
+    //    `extends` target validation.
+    //  - Imports feed the per-library alias resolver — alias-form `extends` inside
+    //    a library (e.g. ai-openai's `extends: Ai.Model`) resolves against THAT
+    //    library's own `Telo.Import` declarations, not the root manifest's. Without
+    //    forwarding the imports, importing such a library would surface a spurious
+    //    EXTENDS_MALFORMED for an alias the library legitimately uses internally.
+    // Alias resolution itself stays in the analyzer; the loader's only semantic
+    // action is stamping `resolvedModuleName` / `resolvedNamespace` — recording the
+    // result of loading. Identity is cached per URL (see libraryIdentityByUrl above)
+    // because the same library can be reached through multiple chains, and every
+    // Telo.Import doc — including the duplicates short-circuited by `visited` —
+    // must end up stamped, otherwise per-scope alias resolution falls back to a
+    // path-derived string (e.g. "abstract-lib.yaml") and produces wrong canonical
+    // kinds.
     const importedDefs: ResourceManifest[] = [];
     const queue: ResourceManifest[] = [...entry];
 
@@ -348,36 +374,56 @@ export class Loader {
         importSource.startsWith(".") || importSource.startsWith("/")
           ? this.pick(base).resolveRelative(base, importSource)
           : importSource;
-      if (visited.has(importUrl)) continue;
-      visited.add(importUrl);
-      let imported: ResourceManifest[];
-      try {
-        imported = await this.loadModule(importUrl);
-      } catch (err) {
-        const e = err instanceof Error ? err : new Error(String(err));
-        (e as any).sourceLine = (m.metadata as any)?.sourceLine ?? 0;
-        throw e;
-      }
-      // Import target must be a Telo.Library. Check the Library branch
-      // explicitly rather than "anything that's a module kind" so that a
-      // future third kind can't silently slip past as a valid import target.
-      const importedLibrary = imported.find((im) => im.kind === "Telo.Library");
-      const importedApplication = imported.find((im) => im.kind === "Telo.Application");
-      if (importedApplication) {
-        const e = new Error(
-          `Telo.Import target '${importSource}' is a Telo.Application. ` +
-            `Only Telo.Library modules may be imported. Applications are run directly, not imported.`,
-        );
-        (e as any).sourceLine = (m.metadata as any)?.sourceLine ?? 0;
-        throw e;
+
+      if (!visited.has(importUrl)) {
+        visited.add(importUrl);
+        let imported: ResourceManifest[];
+        try {
+          imported = await this.loadModule(importUrl);
+        } catch (err) {
+          const e = err instanceof Error ? err : new Error(String(err));
+          (e as any).sourceLine = (m.metadata as any)?.sourceLine ?? 0;
+          throw e;
+        }
+        // Import target must be a Telo.Library. Check the Library branch
+        // explicitly rather than "anything that's a module kind" so that a
+        // future third kind can't silently slip past as a valid import target.
+        const importedLibrary = imported.find((im) => im.kind === "Telo.Library");
+        const importedApplication = imported.find((im) => im.kind === "Telo.Application");
+        if (importedApplication) {
+          const e = new Error(
+            `Telo.Import target '${importSource}' is a Telo.Application. ` +
+              `Only Telo.Library modules may be imported. Applications are run directly, not imported.`,
+          );
+          (e as any).sourceLine = (m.metadata as any)?.sourceLine ?? 0;
+          throw e;
+        }
+        if (importedLibrary?.metadata?.name) {
+          libraryIdentityByUrl.set(importUrl, {
+            name: importedLibrary.metadata.name as string,
+            namespace: ((importedLibrary.metadata as any).namespace as string | null) ?? null,
+          });
+        }
+        for (const im of imported) {
+          if (
+            im.kind === "Telo.Definition" ||
+            im.kind === "Telo.Abstract" ||
+            im.kind === "Telo.Import"
+          ) {
+            importedDefs.push(im);
+          }
+          if (im.kind === "Telo.Import") queue.push(im);
+        }
       }
-      const importedModule = importedLibrary;
-      if (importedModule?.metadata?.name) {
+
+      // Stamp m with cached identity (works for both fresh and duplicate visits).
+      const identity = libraryIdentityByUrl.get(importUrl);
+      if (identity) {
         const pi = (m.metadata as any)?.positionIndex;
         m.metadata = {
           ...m.metadata,
-          resolvedModuleName: importedModule.metadata.name as string,
-          resolvedNamespace: (importedModule.metadata as any).namespace ?? null,
+          resolvedModuleName: identity.name,
+          resolvedNamespace: identity.namespace,
         };
         if (pi) {
           Object.defineProperty(m.metadata, "positionIndex", {
@@ -388,10 +434,6 @@ export class Loader {
           });
         }
       }
-      for (const im of imported) {
-        if (im.kind === "Telo.Definition") importedDefs.push(im);
-        if (im.kind === "Telo.Import") queue.push(im);
-      }
     }
 
     return [...entry, ...importedDefs];

package/src/{adapters/http-adapter.ts → sources/http-source.ts}

@@ -1,6 +1,6 @@
-import { DEFAULT_MANIFEST_FILENAME, type ManifestAdapter } from "../types.js";
+import { DEFAULT_MANIFEST_FILENAME, type ManifestSource } from "../types.js";
 
-export class HttpAdapter implements ManifestAdapter {
+export class HttpSource implements ManifestSource {
   supports(url: string): boolean {
     return url.startsWith("http://") || url.startsWith("https://");
   }

package/src/{adapters/registry-adapter.ts → sources/registry-source.ts}

@@ -1,8 +1,8 @@
-import { DEFAULT_MANIFEST_FILENAME, type ManifestAdapter } from "../types.js";
+import { DEFAULT_MANIFEST_FILENAME, type ManifestSource } from "../types.js";
 
 const DEFAULT_REGISTRY_URL = "https://registry.telo.run";
 
-export class RegistryAdapter implements ManifestAdapter {
+export class RegistrySource implements ManifestSource {
   constructor(private registryUrl = DEFAULT_REGISTRY_URL) {}
 
   supports(url: string): boolean {

package/src/types.ts

@@ -41,19 +41,19 @@ export interface AnalysisDiagnostic {
   data?: unknown;
 }
 
-export interface ManifestAdapter {
+export interface ManifestSource {
   supports(url: string): boolean;
   read(url: string): Promise<{ text: string; source: string }>;
   resolveRelative(base: string, relative: string): string;
 
   /** Expand glob patterns relative to a base source. Returns sources in the same
    *  format as read().source — suitable to pass back into read() / resolveRelative().
-   *  Optional — only filesystem-capable adapters implement this. */
+   *  Optional — only filesystem-capable sources implement this. */
   expandGlob?(base: string, patterns: string[]): Promise<string[]>;
 
   /** Walk parent directories from fileUrl looking for the nearest telo.yaml.
    *  Returns the source in the same format as read().source, or null if none found.
-   *  Optional — only filesystem-capable adapters implement this. */
+   *  Optional — only filesystem-capable sources implement this. */
   resolveOwnerOf?(fileUrl: string): Promise<string | null>;
 }
 
@@ -66,13 +66,13 @@ export interface LoadOptions {
 }
 
 export interface LoaderInitOptions {
-  /** Adapters inserted with highest priority before built-ins. */
-  extraAdapters?: ManifestAdapter[];
-  /** Include built-in HttpAdapter. Defaults to true. */
-  includeHttpAdapter?: boolean;
-  /** Include built-in RegistryAdapter. Defaults to true. */
-  includeRegistryAdapter?: boolean;
-  /** Base URL used by built-in RegistryAdapter when enabled. */
+  /** Sources inserted with highest priority before built-ins. */
+  extraSources?: ManifestSource[];
+  /** Include built-in HttpSource. Defaults to true. */
+  includeHttpSource?: boolean;
+  /** Include built-in RegistrySource. Defaults to true. */
+  includeRegistrySource?: boolean;
+  /** Base URL used by built-in RegistrySource when enabled. */
   registryUrl?: string;
   /** Handlers for CEL stdlib functions (e.g. `sha256`). Analyzer-only callers may
    *  omit this and get throwing stubs; runtime callers (kernel) must supply real impls. */

package/src/validate-extends.ts

@@ -0,0 +1,175 @@
+import type { ResourceManifest } from "@telorun/sdk";
+import type { AliasResolver } from "./alias-resolver.js";
+import type { DefinitionRegistry } from "./definition-registry.js";
+import { DiagnosticSeverity, type AnalysisDiagnostic } from "./types.js";
+
+const SOURCE = "telo-analyzer";
+
+/** Alias-form pattern for `extends`: "<Alias>.<AbstractName>", two PascalCase segments. */
+const EXTENDS_ALIAS_RE = /^[A-Z][A-Za-z0-9_]*\.[A-Z][A-Za-z0-9_]*$/;
+
+/**
+ * Phase 3b — Validate `extends` fields on Telo.Definition docs, and flag the legacy
+ * `capability: <UserAbstract>` overload with CAPABILITY_SHADOWS_EXTENDS so users migrate.
+ *
+ * `extends` uses alias form ("<Alias>.<Name>") resolved against the declaring file's
+ * Telo.Import declarations — same pattern as `kind:` prefixes. The analyzer pre-resolves
+ * via AliasResolver before register() is called, so by the time this validator runs,
+ * the definition's effective `extends` is either the canonical form (when the alias was
+ * known) or the original alias-prefixed string (when it wasn't).
+ *
+ * Diagnostics:
+ *  - EXTENDS_MALFORMED: value not in "<Alias>.<Name>" alias form, or not resolvable
+ *    via the declaring file's imports (alias unknown → can't distinguish from a typo).
+ *  - EXTENDS_UNKNOWN_TARGET: alias resolves to a module, but that module has no
+ *    registered definition with the target name.
+ *  - EXTENDS_NON_ABSTRACT: target resolves to a Telo.Definition, not a Telo.Abstract.
+ *  - CAPABILITY_SHADOWS_EXTENDS (warning): `capability` names a user-declared abstract
+ *    (metadata.module !== "Telo"). Builtin lifecycle capabilities (Telo.Invocable, etc.)
+ *    never trigger this — they're lifecycle roles by design.
+ */
+export function validateExtends(
+  manifests: ResourceManifest[],
+  registry: DefinitionRegistry,
+  aliases: AliasResolver,
+): AnalysisDiagnostic[] {
+  const diagnostics: AnalysisDiagnostic[] = [];
+
+  // Defs forwarded from imported libraries carry `metadata.module` set to that
+  // library's name (stamped by the loader). The analyzer's Phase 1 already normalized
+  // their `extends` against the declaring library's own alias scope (`aliasesByModule`
+  // in analyzer.ts), so the canonical-form value is correct. What this validator can't
+  // re-check is whether the original alias was well-formed in the library's source —
+  // that's the library author's concern, surfaced when the library is analyzed as a
+  // root. Re-validating here against the consumer's alias scope (which doesn't know
+  // the library's internal aliases) would produce false-positive EXTENDS_MALFORMED /
+  // EXTENDS_UNKNOWN_TARGET. Skip forwarded defs entirely.
+  const importedModules = new Set<string>();
+  for (const m of manifests) {
+    if (m.kind !== "Telo.Import") continue;
+    const resolved = (m.metadata as { resolvedModuleName?: string } | undefined)?.resolvedModuleName;
+    if (resolved) importedModules.add(resolved);
+  }
+
+  for (const m of manifests) {
+    if (m.kind !== "Telo.Definition") continue;
+    const name = m.metadata?.name as string | undefined;
+    if (!name) continue;
+    const ownModule = (m.metadata as { module?: string } | undefined)?.module;
+    if (ownModule && importedModules.has(ownModule)) continue;
+    const filePath = (m.metadata as { source?: string } | undefined)?.source;
+    const resource = { kind: m.kind, name };
+    const label = `${m.kind}/${name}`;
+
+    // --- extends validation ---
+    // At this point `m.extends` is whatever the manifest declared (alias form, e.g.
+    // "Ai.Model"). Resolve through the AliasResolver to the canonical form before
+    // looking up the target definition.
+    const extendsValue = (m as { extends?: unknown }).extends;
+    if (extendsValue !== undefined) {
+      if (typeof extendsValue !== "string") {
+        diagnostics.push({
+          severity: DiagnosticSeverity.Error,
+          code: "EXTENDS_MALFORMED",
+          source: SOURCE,
+          message: `${label}: 'extends' must be a string in alias form "<Alias>.<Name>"`,
+          data: { resource, filePath, path: "extends" },
+        });
+      } else if (!EXTENDS_ALIAS_RE.test(extendsValue)) {
+        diagnostics.push({
+          severity: DiagnosticSeverity.Error,
+          code: "EXTENDS_MALFORMED",
+          source: SOURCE,
+          message:
+            `${label}: 'extends: ${extendsValue}' must be in alias form "<Alias>.<Name>" ` +
+            `(e.g. "Ai.Model"), resolved via this file's Telo.Import declarations.`,
+          data: { resource, filePath, path: "extends" },
+        });
+      } else {
+        const prefix = extendsValue.slice(0, extendsValue.indexOf("."));
+        if (!aliases.hasAlias(prefix)) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Error,
+            code: "EXTENDS_MALFORMED",
+            source: SOURCE,
+            message:
+              `${label}: 'extends: ${extendsValue}' — alias '${prefix}' is not a Telo.Import ` +
+              `in this file's scope. Declare the import or correct the alias.`,
+            data: { resource, filePath, path: "extends" },
+          });
+        } else {
+          const canonical = aliases.resolveKind(extendsValue);
+          if (!canonical) {
+            // Alias exists but the suffix isn't in its exported kinds — behave like
+            // an unknown target so users see the symbol is wrong, not that the alias is.
+            diagnostics.push({
+              severity: DiagnosticSeverity.Error,
+              code: "EXTENDS_UNKNOWN_TARGET",
+              source: SOURCE,
+              message: `${label}: 'extends' target '${extendsValue}' is not an exported kind of alias '${prefix}'.`,
+              data: { resource, filePath, path: "extends" },
+            });
+          } else {
+            const targetDef = registry.resolve(canonical);
+            if (!targetDef) {
+              diagnostics.push({
+                severity: DiagnosticSeverity.Error,
+                code: "EXTENDS_UNKNOWN_TARGET",
+                source: SOURCE,
+                message: `${label}: 'extends' target '${extendsValue}' (resolved: '${canonical}') is not a registered definition.`,
+                data: { resource, filePath, path: "extends" },
+              });
+            } else if (targetDef.kind !== "Telo.Abstract") {
+              diagnostics.push({
+                severity: DiagnosticSeverity.Error,
+                code: "EXTENDS_NON_ABSTRACT",
+                source: SOURCE,
+                message:
+                  `${label}: 'extends' target '${extendsValue}' (resolved: '${canonical}') is a ${targetDef.kind}, not a Telo.Abstract. ` +
+                  `Only Telo.Abstract declarations may be extended.`,
+                data: { resource, filePath, path: "extends" },
+              });
+            }
+          }
+        }
+      }
+    }
+
+    // --- legacy capability-as-abstract warning ---
+    // `capability` is expected to name either a builtin lifecycle (module "Telo") or a
+    // user-declared abstract. The latter is the pre-`extends` overload — emit a warning
+    // suggesting the canonical form. Resolve through aliases first because the manifest
+    // retains the alias-prefixed form (e.g. "AbstractLib.Greeter"); the registered key
+    // is the canonical form after alias resolution (e.g. "abstract-lib.Greeter").
+    const capability = (m as { capability?: unknown }).capability;
+    if (typeof capability === "string") {
+      const resolvedCap = aliases.resolveKind(capability) ?? capability;
+      const capDef = registry.resolve(resolvedCap);
+      if (
+        capDef &&
+        capDef.kind === "Telo.Abstract" &&
+        capDef.metadata.module !== "Telo"
+      ) {
+        // Build suggestion using the original alias form if aliases can produce it.
+        const aliasesForModule = aliases.aliasesFor(capDef.metadata.module);
+        const suggestion =
+          aliasesForModule.length > 0
+            ? `${aliasesForModule[0]}.${capDef.metadata.name}`
+            : `${capDef.metadata.module}.${capDef.metadata.name}`;
+        diagnostics.push({
+          severity: DiagnosticSeverity.Warning,
+          code: "CAPABILITY_SHADOWS_EXTENDS",
+          source: SOURCE,
+          message:
+            `${label}: 'capability: ${capability}' names a user-declared abstract. ` +
+            `Prefer 'extends' for implements-this-abstract declarations; 'capability' should ` +
+            `name a lifecycle role. Use \`extends: "${suggestion}"\` with a lifecycle ` +
+            `\`capability\` (e.g. Telo.Invocable, Telo.Provider, Telo.Service).`,
+          data: { resource, filePath, path: "capability" },
+        });
+      }
+    }
+  }
+
+  return diagnostics;
+}

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/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"}