@happyvertical/smrt-core 0.30.0

package/dist/lazy-config.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Lazy / execute-time agent_config resolvers.
+ *
+ * Persisted agent configs (e.g. `_smrt_agent_schedules.agent_config`) freeze
+ * any value resolved at sync time, including env-derived ones. When operators
+ * rotate an env var the persisted snapshot goes stale until the schedule is
+ * rewritten.
+ *
+ * To avoid that, callers can store **sentinel references** in the persisted
+ * config and register matching resolvers that run at execute time. The
+ * runtime walks the agent_config tree, replaces every recognised sentinel
+ * with the resolver's current return value, and only then hands the config
+ * to the agent.
+ *
+ * Two registration shapes are supported:
+ *
+ * 1. **Global named resolvers** — register a callback by name once at
+ *    application startup. Use this for shared resolvers like
+ *    `resolveSharedAssetStorage`.
+ *
+ *    ```ts
+ *    import { registerConfigResolver } from '@happyvertical/smrt-agents';
+ *
+ *    registerConfigResolver('sharedAssetStorage', () =>
+ *      resolveSharedAssetStorage(),
+ *    );
+ *    ```
+ *
+ *    Then in the persisted agent_config:
+ *    ```jsonc
+ *    { "assetStorage": { "$env": "sharedAssetStorage" } }
+ *    ```
+ *
+ * 2. **Per-agent class resolvers** — declare them as a static
+ *    `configResolvers` map on the agent class. The runtime applies them on
+ *    top of the persisted config keyed by the same name as the resolver.
+ *
+ *    ```ts
+ *    class Praeco extends Agent {
+ *      static configResolvers = {
+ *        assetStorage: () => resolveSharedAssetStorage(),
+ *      };
+ *    }
+ *    ```
+ *
+ * Both shapes can be combined freely. Global resolvers always take precedence
+ * for `$env` sentinels; class resolvers fill in / override fields by name.
+ *
+ * @module
+ */
+/**
+ * A lazy resolver — synchronous or async. Return values are merged into the
+ * config tree at execute time. Throwing is allowed but is treated as a
+ * resolution failure (see {@link ResolveLazyConfigOptions.onError}).
+ */
+export type ConfigResolver = () => unknown | Promise<unknown>;
+/**
+ * Sentinel object recognised inside agent_config to defer a value to a named
+ * resolver. The runtime accepts both `$env` (preferred) and `$resolver` for
+ * symmetry with similar systems.
+ */
+export interface LazyConfigSentinel {
+    $env?: string;
+    $resolver?: string;
+}
+/**
+ * Options for resolving the lazy parts of a config tree.
+ */
+export interface ResolveLazyConfigOptions {
+    /**
+     * Per-class resolvers — typically the agent class's static
+     * `configResolvers`. Applied as a key-by-key overlay on top of the
+     * sentinel-resolved config.
+     */
+    classResolvers?: Record<string, ConfigResolver>;
+    /**
+     * Optional override for the global resolver registry. When omitted the
+     * shared module-scoped registry is used. Useful for tests.
+     */
+    resolvers?: Map<string, ConfigResolver> | Record<string, ConfigResolver>;
+    /**
+     * What to do when a sentinel references a resolver that isn't registered,
+     * or when a resolver throws.
+     *
+     * - `'leave'` (default): the sentinel is left in place verbatim. The
+     *   downstream consumer is responsible for handling it.
+     * - `'omit'`: the sentinel key is removed from the parent object/array.
+     * - `'throw'`: re-throw the underlying error (or throw a new one for
+     *   missing resolvers).
+     */
+    onError?: 'leave' | 'omit' | 'throw';
+}
+/**
+ * Register a named resolver that participates in lazy config resolution.
+ *
+ * Calling this with the same name twice replaces the previous resolver — the
+ * registry is intentionally last-write-wins so application boot ordering
+ * doesn't have to be fragile.
+ */
+export declare function registerConfigResolver(name: string, resolver: ConfigResolver): void;
+/**
+ * Remove a previously registered resolver. Returns `true` if a resolver was
+ * removed.
+ */
+export declare function unregisterConfigResolver(name: string): boolean;
+/**
+ * Get the resolver registered under the given name, if any.
+ */
+export declare function getConfigResolver(name: string): ConfigResolver | undefined;
+/**
+ * List the names of all currently-registered global resolvers.
+ */
+export declare function listConfigResolvers(): string[];
+/**
+ * Reset the global resolver registry. Primarily for tests.
+ */
+export declare function resetConfigResolvers(): void;
+/**
+ * Type guard that returns `true` if `value` is a lazy config sentinel.
+ *
+ * Recognises objects of the form `{ $env: string }` or
+ * `{ $resolver: string }` exactly — extra keys disqualify the value so
+ * arbitrary user data isn't accidentally treated as a sentinel.
+ */
+export declare function isLazyConfigSentinel(value: unknown): value is LazyConfigSentinel;
+/**
+ * Resolve every lazy sentinel inside an `agent_config`-style record at
+ * execute time. The input is not mutated; a new object is returned with
+ * sentinel placeholders replaced by their resolver's current return value.
+ *
+ * Class-level resolvers from {@link ResolveLazyConfigOptions.classResolvers}
+ * are applied as a final overlay so they always reflect the live value
+ * regardless of what's persisted.
+ *
+ * @example Sentinel resolution
+ * ```ts
+ * registerConfigResolver('sharedAssetStorage', () => resolveStorage());
+ *
+ * const stored = { assetStorage: { $env: 'sharedAssetStorage' } };
+ * const live = await resolveLazyConfig(stored);
+ * // live.assetStorage === resolveStorage()
+ * ```
+ *
+ * @example Class-level resolvers
+ * ```ts
+ * const live = await resolveLazyConfig(stored, {
+ *   classResolvers: { assetStorage: () => resolveStorage() },
+ * });
+ * ```
+ */
+export declare function resolveLazyConfig<T extends Record<string, unknown>>(config: T, options?: ResolveLazyConfigOptions): Promise<T>;
+/**
+ * Look up the static `configResolvers` map on a class (or any of its
+ * ancestors). Returns `undefined` if none is declared.
+ *
+ * The lookup walks the prototype chain so a subclass can extend its parent's
+ * resolvers without redeclaring them.
+ */
+export declare function getClassConfigResolvers(ctor: unknown): Record<string, ConfigResolver> | undefined;
+//# sourceMappingURL=lazy-config.d.ts.map

package/dist/lazy-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-config.d.ts","sourceRoot":"","sources":["../src/lazy-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE9D;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAEhD;;;OAGG;IACH,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAEzE;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;CACtC;AAID;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,cAAc,GACvB,IAAI,CAQN;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAE1E;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,kBAAkB,CAU7B;AA2GD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvE,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,CAAC,CAAC,CAwCZ;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,GACZ,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,SAAS,CAkB5C"}

package/dist/lazy-config.js

@@ -0,0 +1,146 @@
+const globalResolvers = /* @__PURE__ */ new Map();
+function registerConfigResolver(name, resolver) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error("registerConfigResolver: name must be a non-empty string");
+  }
+  if (typeof resolver !== "function") {
+    throw new Error("registerConfigResolver: resolver must be a function");
+  }
+  globalResolvers.set(name, resolver);
+}
+function unregisterConfigResolver(name) {
+  return globalResolvers.delete(name);
+}
+function getConfigResolver(name) {
+  return globalResolvers.get(name);
+}
+function listConfigResolvers() {
+  return Array.from(globalResolvers.keys()).sort();
+}
+function resetConfigResolvers() {
+  globalResolvers.clear();
+}
+function isLazyConfigSentinel(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) return false;
+  const key = keys[0];
+  if (key !== "$env" && key !== "$resolver") return false;
+  const resolverName = value[key];
+  return typeof resolverName === "string" && resolverName.length > 0;
+}
+function getSentinelName(sentinel) {
+  return sentinel.$env ?? sentinel.$resolver;
+}
+function normalizeResolverMap(resolvers) {
+  if (resolvers instanceof Map) return resolvers;
+  return new Map(Object.entries(resolvers));
+}
+const REMOVE = /* @__PURE__ */ Symbol("LazyConfig.REMOVE");
+const MAX_DEPTH = 64;
+async function resolveValue(value, ctx, depth) {
+  if (isLazyConfigSentinel(value)) {
+    const name = getSentinelName(value);
+    const resolver = ctx.resolvers.get(name);
+    if (!resolver) {
+      if (ctx.onError === "throw") {
+        throw new Error(
+          `Lazy config sentinel references unknown resolver "${name}"`
+        );
+      }
+      if (ctx.onError === "omit") return REMOVE;
+      return value;
+    }
+    try {
+      return await resolver();
+    } catch (error) {
+      if (ctx.onError === "throw") throw error;
+      if (ctx.onError === "omit") return REMOVE;
+      return value;
+    }
+  }
+  if (depth > MAX_DEPTH) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const cached = ctx.resolved.get(value);
+    if (cached !== void 0) return cached;
+    const next = [];
+    ctx.resolved.set(value, next);
+    for (const entry of value) {
+      const resolved = await resolveValue(entry, ctx, depth + 1);
+      if (resolved !== REMOVE) next.push(resolved);
+    }
+    return next;
+  }
+  if (value && typeof value === "object") {
+    const cached = ctx.resolved.get(value);
+    if (cached !== void 0) return cached;
+    const next = {};
+    ctx.resolved.set(value, next);
+    for (const [key, entry] of Object.entries(
+      value
+    )) {
+      const resolved = await resolveValue(entry, ctx, depth + 1);
+      if (resolved !== REMOVE) next[key] = resolved;
+    }
+    return next;
+  }
+  return value;
+}
+async function resolveLazyConfig(config, options = {}) {
+  const onError = options.onError ?? "leave";
+  const resolvers = options.resolvers ? normalizeResolverMap(options.resolvers) : globalResolvers;
+  const ctx = {
+    resolvers,
+    onError,
+    resolved: /* @__PURE__ */ new WeakMap()
+  };
+  const sentinelResolved = await resolveValue(config, ctx, 0);
+  const result = { ...sentinelResolved };
+  if (options.classResolvers) {
+    for (const [key, resolver] of Object.entries(options.classResolvers)) {
+      try {
+        const value = await resolver();
+        if (value !== void 0 && value !== null) {
+          result[key] = value;
+        }
+      } catch (error) {
+        if (onError === "throw") throw error;
+        if (onError === "omit") {
+          delete result[key];
+        }
+      }
+    }
+  }
+  return result;
+}
+function getClassConfigResolvers(ctor) {
+  if (typeof ctor !== "function") return void 0;
+  let current = ctor;
+  let collected;
+  while (current && current !== Function.prototype) {
+    const resolvers = current.configResolvers;
+    if (resolvers && typeof resolvers === "object") {
+      collected = {
+        ...resolvers,
+        ...collected ?? {}
+      };
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return collected;
+}
+export {
+  getClassConfigResolvers,
+  getConfigResolver,
+  isLazyConfigSentinel,
+  listConfigResolvers,
+  registerConfigResolver,
+  resetConfigResolvers,
+  resolveLazyConfig,
+  unregisterConfigResolver
+};
+//# sourceMappingURL=lazy-config.js.map

package/dist/lazy-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-config.js","sources":["../src/lazy-config.ts"],"sourcesContent":["/**\n * Lazy / execute-time agent_config resolvers.\n *\n * Persisted agent configs (e.g. `_smrt_agent_schedules.agent_config`) freeze\n * any value resolved at sync time, including env-derived ones. When operators\n * rotate an env var the persisted snapshot goes stale until the schedule is\n * rewritten.\n *\n * To avoid that, callers can store **sentinel references** in the persisted\n * config and register matching resolvers that run at execute time. The\n * runtime walks the agent_config tree, replaces every recognised sentinel\n * with the resolver's current return value, and only then hands the config\n * to the agent.\n *\n * Two registration shapes are supported:\n *\n * 1. **Global named resolvers** — register a callback by name once at\n *    application startup. Use this for shared resolvers like\n *    `resolveSharedAssetStorage`.\n *\n *    ```ts\n *    import { registerConfigResolver } from '@happyvertical/smrt-agents';\n *\n *    registerConfigResolver('sharedAssetStorage', () =>\n *      resolveSharedAssetStorage(),\n *    );\n *    ```\n *\n *    Then in the persisted agent_config:\n *    ```jsonc\n *    { \"assetStorage\": { \"$env\": \"sharedAssetStorage\" } }\n *    ```\n *\n * 2. **Per-agent class resolvers** — declare them as a static\n *    `configResolvers` map on the agent class. The runtime applies them on\n *    top of the persisted config keyed by the same name as the resolver.\n *\n *    ```ts\n *    class Praeco extends Agent {\n *      static configResolvers = {\n *        assetStorage: () => resolveSharedAssetStorage(),\n *      };\n *    }\n *    ```\n *\n * Both shapes can be combined freely. Global resolvers always take precedence\n * for `$env` sentinels; class resolvers fill in / override fields by name.\n *\n * @module\n */\n\n/**\n * A lazy resolver — synchronous or async. Return values are merged into the\n * config tree at execute time. Throwing is allowed but is treated as a\n * resolution failure (see {@link ResolveLazyConfigOptions.onError}).\n */\nexport type ConfigResolver = () => unknown | Promise<unknown>;\n\n/**\n * Sentinel object recognised inside agent_config to defer a value to a named\n * resolver. The runtime accepts both `$env` (preferred) and `$resolver` for\n * symmetry with similar systems.\n */\nexport interface LazyConfigSentinel {\n  $env?: string;\n  $resolver?: string;\n}\n\n/**\n * Options for resolving the lazy parts of a config tree.\n */\nexport interface ResolveLazyConfigOptions {\n  /**\n   * Per-class resolvers — typically the agent class's static\n   * `configResolvers`. Applied as a key-by-key overlay on top of the\n   * sentinel-resolved config.\n   */\n  classResolvers?: Record<string, ConfigResolver>;\n\n  /**\n   * Optional override for the global resolver registry. When omitted the\n   * shared module-scoped registry is used. Useful for tests.\n   */\n  resolvers?: Map<string, ConfigResolver> | Record<string, ConfigResolver>;\n\n  /**\n   * What to do when a sentinel references a resolver that isn't registered,\n   * or when a resolver throws.\n   *\n   * - `'leave'` (default): the sentinel is left in place verbatim. The\n   *   downstream consumer is responsible for handling it.\n   * - `'omit'`: the sentinel key is removed from the parent object/array.\n   * - `'throw'`: re-throw the underlying error (or throw a new one for\n   *   missing resolvers).\n   */\n  onError?: 'leave' | 'omit' | 'throw';\n}\n\nconst globalResolvers = new Map<string, ConfigResolver>();\n\n/**\n * Register a named resolver that participates in lazy config resolution.\n *\n * Calling this with the same name twice replaces the previous resolver — the\n * registry is intentionally last-write-wins so application boot ordering\n * doesn't have to be fragile.\n */\nexport function registerConfigResolver(\n  name: string,\n  resolver: ConfigResolver,\n): void {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw new Error('registerConfigResolver: name must be a non-empty string');\n  }\n  if (typeof resolver !== 'function') {\n    throw new Error('registerConfigResolver: resolver must be a function');\n  }\n  globalResolvers.set(name, resolver);\n}\n\n/**\n * Remove a previously registered resolver. Returns `true` if a resolver was\n * removed.\n */\nexport function unregisterConfigResolver(name: string): boolean {\n  return globalResolvers.delete(name);\n}\n\n/**\n * Get the resolver registered under the given name, if any.\n */\nexport function getConfigResolver(name: string): ConfigResolver | undefined {\n  return globalResolvers.get(name);\n}\n\n/**\n * List the names of all currently-registered global resolvers.\n */\nexport function listConfigResolvers(): string[] {\n  return Array.from(globalResolvers.keys()).sort();\n}\n\n/**\n * Reset the global resolver registry. Primarily for tests.\n */\nexport function resetConfigResolvers(): void {\n  globalResolvers.clear();\n}\n\n/**\n * Type guard that returns `true` if `value` is a lazy config sentinel.\n *\n * Recognises objects of the form `{ $env: string }` or\n * `{ $resolver: string }` exactly — extra keys disqualify the value so\n * arbitrary user data isn't accidentally treated as a sentinel.\n */\nexport function isLazyConfigSentinel(\n  value: unknown,\n): value is LazyConfigSentinel {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) {\n    return false;\n  }\n  const keys = Object.keys(value as Record<string, unknown>);\n  if (keys.length !== 1) return false;\n  const key = keys[0];\n  if (key !== '$env' && key !== '$resolver') return false;\n  const resolverName = (value as Record<string, unknown>)[key];\n  return typeof resolverName === 'string' && resolverName.length > 0;\n}\n\n/**\n * Extract the resolver name from a sentinel.\n */\nfunction getSentinelName(sentinel: LazyConfigSentinel): string {\n  return (sentinel.$env ?? sentinel.$resolver) as string;\n}\n\nfunction normalizeResolverMap(\n  resolvers: Map<string, ConfigResolver> | Record<string, ConfigResolver>,\n): Map<string, ConfigResolver> {\n  if (resolvers instanceof Map) return resolvers;\n  return new Map(Object.entries(resolvers));\n}\n\nconst REMOVE = Symbol('LazyConfig.REMOVE');\n\n/**\n * Maximum traversal depth before {@link resolveValue} bails out. Real\n * `agent_config` payloads are shallow (2–3 levels); a high cap here exists\n * solely to prevent stack overflow from a malicious or buggy persisted\n * config without rejecting any legitimate input. When the cap is hit the\n * value is returned verbatim — same fail-soft as for a missing resolver.\n */\nconst MAX_DEPTH = 64;\n\ninterface ResolveContext {\n  resolvers: Map<string, ConfigResolver>;\n  onError: NonNullable<ResolveLazyConfigOptions['onError']>;\n  /**\n   * Map from input object/array to its resolved replacement. Serves two\n   * purposes simultaneously:\n   *   1. Cycle protection — without it, a self-referential config would\n   *      recurse forever.\n   *   2. DAG fidelity — a sub-tree referenced from two places gets cloned\n   *      once and the same clone is reused for every reference, preserving\n   *      structure and ensuring sentinels under shared references are still\n   *      resolved.\n   */\n  resolved: WeakMap<object, unknown>;\n}\n\nasync function resolveValue(\n  value: unknown,\n  ctx: ResolveContext,\n  depth: number,\n): Promise<unknown> {\n  if (isLazyConfigSentinel(value)) {\n    const name = getSentinelName(value);\n    const resolver = ctx.resolvers.get(name);\n    if (!resolver) {\n      if (ctx.onError === 'throw') {\n        throw new Error(\n          `Lazy config sentinel references unknown resolver \"${name}\"`,\n        );\n      }\n      if (ctx.onError === 'omit') return REMOVE;\n      return value;\n    }\n\n    try {\n      return await resolver();\n    } catch (error) {\n      if (ctx.onError === 'throw') throw error;\n      if (ctx.onError === 'omit') return REMOVE;\n      return value;\n    }\n  }\n\n  if (depth > MAX_DEPTH) {\n    // Defensive: refuse to recurse further. The original sub-tree is\n    // returned as-is; sentinels beyond this point will stay unresolved.\n    return value;\n  }\n\n  if (Array.isArray(value)) {\n    const cached = ctx.resolved.get(value);\n    if (cached !== undefined) return cached;\n    const next: unknown[] = [];\n    // Register the placeholder *before* descending so that a cycle pointing\n    // back at this array sees the in-progress array (and stops recursing).\n    ctx.resolved.set(value, next);\n    for (const entry of value) {\n      const resolved = await resolveValue(entry, ctx, depth + 1);\n      if (resolved !== REMOVE) next.push(resolved);\n    }\n    return next;\n  }\n\n  if (value && typeof value === 'object') {\n    const cached = ctx.resolved.get(value);\n    if (cached !== undefined) return cached;\n    const next: Record<string, unknown> = {};\n    ctx.resolved.set(value, next);\n    for (const [key, entry] of Object.entries(\n      value as Record<string, unknown>,\n    )) {\n      const resolved = await resolveValue(entry, ctx, depth + 1);\n      if (resolved !== REMOVE) next[key] = resolved;\n    }\n    return next;\n  }\n\n  return value;\n}\n\n/**\n * Resolve every lazy sentinel inside an `agent_config`-style record at\n * execute time. The input is not mutated; a new object is returned with\n * sentinel placeholders replaced by their resolver's current return value.\n *\n * Class-level resolvers from {@link ResolveLazyConfigOptions.classResolvers}\n * are applied as a final overlay so they always reflect the live value\n * regardless of what's persisted.\n *\n * @example Sentinel resolution\n * ```ts\n * registerConfigResolver('sharedAssetStorage', () => resolveStorage());\n *\n * const stored = { assetStorage: { $env: 'sharedAssetStorage' } };\n * const live = await resolveLazyConfig(stored);\n * // live.assetStorage === resolveStorage()\n * ```\n *\n * @example Class-level resolvers\n * ```ts\n * const live = await resolveLazyConfig(stored, {\n *   classResolvers: { assetStorage: () => resolveStorage() },\n * });\n * ```\n */\nexport async function resolveLazyConfig<T extends Record<string, unknown>>(\n  config: T,\n  options: ResolveLazyConfigOptions = {},\n): Promise<T> {\n  const onError = options.onError ?? 'leave';\n  const resolvers = options.resolvers\n    ? normalizeResolverMap(options.resolvers)\n    : globalResolvers;\n\n  const ctx: ResolveContext = {\n    resolvers,\n    onError,\n    resolved: new WeakMap<object, unknown>(),\n  };\n  const sentinelResolved = (await resolveValue(config, ctx, 0)) as Record<\n    string,\n    unknown\n  >;\n\n  const result: Record<string, unknown> = { ...sentinelResolved };\n\n  if (options.classResolvers) {\n    for (const [key, resolver] of Object.entries(options.classResolvers)) {\n      try {\n        const value = await resolver();\n        // Both `undefined` and `null` are treated as \"no overlay value\" —\n        // the persisted record's existing value (if any) is preserved.\n        // This matches the documented contract on `Agent.configResolvers`\n        // and makes the common pattern `() => process.env.X ?? null` safe.\n        if (value !== undefined && value !== null) {\n          result[key] = value;\n        }\n      } catch (error) {\n        if (onError === 'throw') throw error;\n        if (onError === 'omit') {\n          delete result[key];\n        }\n        // 'leave': preserve the existing (possibly persisted) value.\n      }\n    }\n  }\n\n  return result as T;\n}\n\n/**\n * Look up the static `configResolvers` map on a class (or any of its\n * ancestors). Returns `undefined` if none is declared.\n *\n * The lookup walks the prototype chain so a subclass can extend its parent's\n * resolvers without redeclaring them.\n */\nexport function getClassConfigResolvers(\n  ctor: unknown,\n): Record<string, ConfigResolver> | undefined {\n  if (typeof ctor !== 'function') return undefined;\n\n  let current: any = ctor;\n  let collected: Record<string, ConfigResolver> | undefined;\n\n  while (current && current !== Function.prototype) {\n    const resolvers = current.configResolvers;\n    if (resolvers && typeof resolvers === 'object') {\n      collected = {\n        ...(resolvers as Record<string, ConfigResolver>),\n        ...(collected ?? {}),\n      };\n    }\n    current = Object.getPrototypeOf(current);\n  }\n\n  return collected;\n}\n"],"names":[],"mappings":"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"}

package/dist/manifest/discover-base-classes.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Discover SMRT classes from external packages for inheritance detection
+ *
+ * Loads manifests from external SMRT packages and extracts all class names.
+ * These are used by the scanner for inheritance detection - to determine
+ * if a class extends a valid SMRT class from an external package.
+ *
+ * IMPORTANT: Despite the name, this function returns ALL SMRT classes from
+ * external packages, not just "base classes". The two have different uses:
+ *
+ * 1. DEFAULT_BASE_CLASSES (SmrtObject, SmrtClass, SmrtCollection):
+ *    Used by the scanner to SKIP these framework classes from the manifest.
+ *    These are the only classes that should be filtered out.
+ *
+ * 2. All discovered classes (return value of this function):
+ *    Used by the scanner for INHERITANCE DETECTION - to recognize when a
+ *    local class extends an external SMRT class.
+ *
+ * Issue #847 Fix: The scanner now uses DEFAULT_BASE_CLASSES for skipping,
+ * not the full return value of this function. This prevents local classes
+ * with names matching external classes from being incorrectly skipped.
+ */
+/**
+ * Framework base classes that should be skipped during manifest generation
+ *
+ * These are the ONLY classes that the scanner should skip - they are
+ * framework base classes that should not appear in the manifest themselves.
+ *
+ * Note: This is separate from inheritance detection. A local class named
+ * "Council" should NOT be skipped just because an external package has a
+ * class named "Council" - only these framework classes should be skipped.
+ */
+export declare const DEFAULT_BASE_CLASSES: readonly ["SmrtObject", "SmrtClass", "SmrtCollection"];
+/**
+ * Discover all available base classes for scanning
+ *
+ * Combines the default SMRT framework base classes with classes discovered
+ * from external SMRT package manifests.
+ *
+ * @param options - Discovery options
+ * @param options.includeDefaults - Include default base classes (default: true)
+ * @param options.cwd - Current working directory (default: process.cwd())
+ * @returns Array of base class names
+ *
+ * @example
+ * ```typescript
+ * // Discover all base classes
+ * const baseClasses = await discoverBaseClasses();
+ * // ['SmrtObject', 'SmrtClass', 'SmrtCollection', 'ProfileRelationship', ...]
+ *
+ * // Only external classes
+ * const external = await discoverBaseClasses({ includeDefaults: false });
+ * // ['ProfileRelationship', 'Event', 'Organization', ...]
+ * ```
+ */
+export declare function discoverBaseClasses(options?: {
+    includeDefaults?: boolean;
+    cwd?: string;
+}): Promise<string[]>;
+/**
+ * Synchronous version of discoverBaseClasses
+ *
+ * Uses readFileSync to load manifests synchronously. Works in both ESM and CJS.
+ *
+ * @param options - Discovery options
+ * @returns Array of base class names
+ *
+ * @example
+ * ```typescript
+ * const baseClasses = discoverBaseClassesSync();
+ * const scanner = new OxcScanner({ baseClasses });
+ * ```
+ */
+export declare function discoverBaseClassesSync(options?: {
+    includeDefaults?: boolean;
+    cwd?: string;
+}): string[];
+//# sourceMappingURL=discover-base-classes.d.ts.map

package/dist/manifest/discover-base-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-base-classes.d.ts","sourceRoot":"","sources":["../../src/manifest/discover-base-classes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAwCH;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,wDAIvB,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GACxD,OAAO,CAAC,MAAM,EAAE,CAAC,CAiDnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GACxD,MAAM,EAAE,CA+CV"}

package/dist/manifest/discover-base-classes.js

@@ -0,0 +1,85 @@
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createLogger } from "@happyvertical/logger";
+import { discoverSmrtPackages, resolveManifestPath } from "./discover-smrt-packages.js";
+const logger = createLogger({ level: "info" });
+function logBaseClassLoadError(pkgName, manifestPath, error) {
+  const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+  const message = error instanceof Error ? error.message : String(error);
+  if (code === "ENOENT") {
+    logger.debug(
+      `[discoverBaseClasses] No manifest for ${pkgName} at ${manifestPath}; skipping.`
+    );
+  } else {
+    logger.warn(
+      `[discoverBaseClasses] Failed to load manifest for ${pkgName} at ${manifestPath}: ${message}`
+    );
+  }
+}
+const DEFAULT_BASE_CLASSES = [
+  "SmrtObject",
+  "SmrtClass",
+  "SmrtCollection"
+];
+async function discoverBaseClasses(options = {}) {
+  const { includeDefaults = true, cwd = process.cwd() } = options;
+  const baseClasses = includeDefaults ? [...DEFAULT_BASE_CLASSES] : [];
+  const smrtDependencies = discoverSmrtPackages();
+  for (const pkgName of smrtDependencies) {
+    const manifestPath = resolveManifestPath(pkgName, cwd);
+    if (!manifestPath) {
+      logger.debug(
+        `[discoverBaseClasses] No SMRT manifest resolved for ${pkgName}; skipping.`
+      );
+      continue;
+    }
+    try {
+      const manifestContent = await readFile(manifestPath, "utf-8");
+      const manifest = JSON.parse(manifestContent);
+      if (manifest.objects && typeof manifest.objects === "object") {
+        for (const objDef of Object.values(manifest.objects)) {
+          if (objDef && typeof objDef === "object" && "className" in objDef && typeof objDef.className === "string") {
+            baseClasses.push(objDef.className);
+          }
+        }
+      }
+    } catch (error) {
+      logBaseClassLoadError(pkgName, manifestPath, error);
+    }
+  }
+  return baseClasses;
+}
+function discoverBaseClassesSync(options = {}) {
+  const { includeDefaults = true, cwd = process.cwd() } = options;
+  const baseClasses = includeDefaults ? [...DEFAULT_BASE_CLASSES] : [];
+  const smrtDependencies = discoverSmrtPackages();
+  for (const pkgName of smrtDependencies) {
+    const manifestPath = resolveManifestPath(pkgName, cwd);
+    if (!manifestPath) {
+      logger.debug(
+        `[discoverBaseClassesSync] No SMRT manifest resolved for ${pkgName}; skipping.`
+      );
+      continue;
+    }
+    try {
+      const manifestContent = readFileSync(manifestPath, "utf-8");
+      const manifest = JSON.parse(manifestContent);
+      if (manifest.objects && typeof manifest.objects === "object") {
+        for (const objDef of Object.values(manifest.objects)) {
+          if (objDef && typeof objDef === "object" && "className" in objDef && typeof objDef.className === "string") {
+            baseClasses.push(objDef.className);
+          }
+        }
+      }
+    } catch (error) {
+      logBaseClassLoadError(pkgName, manifestPath, error);
+    }
+  }
+  return baseClasses;
+}
+export {
+  DEFAULT_BASE_CLASSES,
+  discoverBaseClasses,
+  discoverBaseClassesSync
+};
+//# sourceMappingURL=discover-base-classes.js.map

package/dist/manifest/discover-base-classes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-base-classes.js","sources":["../../src/manifest/discover-base-classes.ts"],"sourcesContent":["/**\n * Discover SMRT classes from external packages for inheritance detection\n *\n * Loads manifests from external SMRT packages and extracts all class names.\n * These are used by the scanner for inheritance detection - to determine\n * if a class extends a valid SMRT class from an external package.\n *\n * IMPORTANT: Despite the name, this function returns ALL SMRT classes from\n * external packages, not just \"base classes\". The two have different uses:\n *\n * 1. DEFAULT_BASE_CLASSES (SmrtObject, SmrtClass, SmrtCollection):\n *    Used by the scanner to SKIP these framework classes from the manifest.\n *    These are the only classes that should be filtered out.\n *\n * 2. All discovered classes (return value of this function):\n *    Used by the scanner for INHERITANCE DETECTION - to recognize when a\n *    local class extends an external SMRT class.\n *\n * Issue #847 Fix: The scanner now uses DEFAULT_BASE_CLASSES for skipping,\n * not the full return value of this function. This prevents local classes\n * with names matching external classes from being incorrectly skipped.\n */\n\nimport { readFileSync } from 'node:fs';\nimport { readFile } from 'node:fs/promises';\nimport { createLogger } from '@happyvertical/logger';\nimport {\n  discoverSmrtPackages,\n  resolveManifestPath,\n} from './discover-smrt-packages.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Log a manifest-load failure during base-class discovery without aborting the\n * whole scan. ENOENT (a package that simply hasn't built/published a manifest)\n * is benign and logged at debug; malformed JSON or other read errors are\n * surfaced at warn so a stale/corrupt manifest is not silently ignored.\n */\nfunction logBaseClassLoadError(\n  pkgName: string,\n  manifestPath: string,\n  error: unknown,\n): void {\n  const code =\n    error && typeof error === 'object' && 'code' in error\n      ? (error as { code?: string }).code\n      : undefined;\n  const message = error instanceof Error ? error.message : String(error);\n\n  if (code === 'ENOENT') {\n    logger.debug(\n      `[discoverBaseClasses] No manifest for ${pkgName} at ${manifestPath}; skipping.`,\n    );\n  } else {\n    logger.warn(\n      `[discoverBaseClasses] Failed to load manifest for ${pkgName} at ${manifestPath}: ${message}`,\n    );\n  }\n}\n\n/**\n * Framework base classes that should be skipped during manifest generation\n *\n * These are the ONLY classes that the scanner should skip - they are\n * framework base classes that should not appear in the manifest themselves.\n *\n * Note: This is separate from inheritance detection. A local class named\n * \"Council\" should NOT be skipped just because an external package has a\n * class named \"Council\" - only these framework classes should be skipped.\n */\nexport const DEFAULT_BASE_CLASSES = [\n  'SmrtObject',\n  'SmrtClass',\n  'SmrtCollection',\n] as const;\n\n/**\n * Discover all available base classes for scanning\n *\n * Combines the default SMRT framework base classes with classes discovered\n * from external SMRT package manifests.\n *\n * @param options - Discovery options\n * @param options.includeDefaults - Include default base classes (default: true)\n * @param options.cwd - Current working directory (default: process.cwd())\n * @returns Array of base class names\n *\n * @example\n * ```typescript\n * // Discover all base classes\n * const baseClasses = await discoverBaseClasses();\n * // ['SmrtObject', 'SmrtClass', 'SmrtCollection', 'ProfileRelationship', ...]\n *\n * // Only external classes\n * const external = await discoverBaseClasses({ includeDefaults: false });\n * // ['ProfileRelationship', 'Event', 'Organization', ...]\n * ```\n */\nexport async function discoverBaseClasses(\n  options: { includeDefaults?: boolean; cwd?: string } = {},\n): Promise<string[]> {\n  const { includeDefaults = true, cwd = process.cwd() } = options;\n\n  // Start with default base classes\n  const baseClasses: string[] = includeDefaults\n    ? [...DEFAULT_BASE_CLASSES]\n    : [];\n\n  // Discover external SMRT packages\n  const smrtDependencies = discoverSmrtPackages();\n\n  // Load external base classes from SMRT package manifests.\n  // Resolve each manifest the same way discovery does (honoring `.smrt/` and\n  // `src/manifest/` in addition to `dist/`), so a workspace package not yet\n  // built to dist/ still contributes its base classes (#1378). A hardcoded\n  // `node_modules/{pkg}/dist/manifest.json` path silently degraded inheritance\n  // detection for source-only packages.\n  for (const pkgName of smrtDependencies) {\n    const manifestPath = resolveManifestPath(pkgName, cwd);\n    if (!manifestPath) {\n      logger.debug(\n        `[discoverBaseClasses] No SMRT manifest resolved for ${pkgName}; skipping.`,\n      );\n      continue;\n    }\n\n    try {\n      const manifestContent = await readFile(manifestPath, 'utf-8');\n      const manifest = JSON.parse(manifestContent);\n\n      // Extract all class names from this package\n      if (manifest.objects && typeof manifest.objects === 'object') {\n        for (const objDef of Object.values(manifest.objects)) {\n          if (\n            objDef &&\n            typeof objDef === 'object' &&\n            'className' in objDef &&\n            typeof objDef.className === 'string'\n          ) {\n            baseClasses.push(objDef.className);\n          }\n        }\n      }\n    } catch (error) {\n      logBaseClassLoadError(pkgName, manifestPath, error);\n    }\n  }\n\n  return baseClasses;\n}\n\n/**\n * Synchronous version of discoverBaseClasses\n *\n * Uses readFileSync to load manifests synchronously. Works in both ESM and CJS.\n *\n * @param options - Discovery options\n * @returns Array of base class names\n *\n * @example\n * ```typescript\n * const baseClasses = discoverBaseClassesSync();\n * const scanner = new OxcScanner({ baseClasses });\n * ```\n */\nexport function discoverBaseClassesSync(\n  options: { includeDefaults?: boolean; cwd?: string } = {},\n): string[] {\n  const { includeDefaults = true, cwd = process.cwd() } = options;\n\n  // Start with default base classes\n  const baseClasses: string[] = includeDefaults\n    ? [...DEFAULT_BASE_CLASSES]\n    : [];\n\n  // Discover external SMRT packages\n  const smrtDependencies = discoverSmrtPackages();\n\n  // Load external base classes from SMRT package manifests. Same resolution as\n  // the async variant (honors `.smrt/` and `src/manifest/`, not just `dist/`),\n  // so source-only workspace packages still contribute base classes (#1378).\n  for (const pkgName of smrtDependencies) {\n    const manifestPath = resolveManifestPath(pkgName, cwd);\n    if (!manifestPath) {\n      logger.debug(\n        `[discoverBaseClassesSync] No SMRT manifest resolved for ${pkgName}; skipping.`,\n      );\n      continue;\n    }\n\n    try {\n      // Use fs.readFileSync for synchronous loading (works in ESM)\n      const manifestContent = readFileSync(manifestPath, 'utf-8');\n      const manifest = JSON.parse(manifestContent);\n\n      // Extract all class names from this package\n      if (manifest.objects && typeof manifest.objects === 'object') {\n        for (const objDef of Object.values(manifest.objects)) {\n          if (\n            objDef &&\n            typeof objDef === 'object' &&\n            'className' in objDef &&\n            typeof objDef.className === 'string'\n          ) {\n            baseClasses.push(objDef.className);\n          }\n        }\n      }\n    } catch (error) {\n      logBaseClassLoadError(pkgName, manifestPath, error);\n    }\n  }\n\n  return baseClasses;\n}\n"],"names":[],"mappings":";;;;AA+BA,MAAM,SAAS,aAAa,EAAE,OAAO,QAAQ;AAQ7C,SAAS,sBACP,SACA,cACA,OACM;AACN,QAAM,OACJ,SAAS,OAAO,UAAU,YAAY,UAAU,QAC3C,MAA4B,OAC7B;AACN,QAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAErE,MAAI,SAAS,UAAU;AACrB,WAAO;AAAA,MACL,yCAAyC,OAAO,OAAO,YAAY;AAAA,IAAA;AAAA,EAEvE,OAAO;AACL,WAAO;AAAA,MACL,qDAAqD,OAAO,OAAO,YAAY,KAAK,OAAO;AAAA,IAAA;AAAA,EAE/F;AACF;AAYO,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF;AAwBA,eAAsB,oBACpB,UAAuD,IACpC;AACnB,QAAM,EAAE,kBAAkB,MAAM,MAAM,QAAQ,IAAA,MAAU;AAGxD,QAAM,cAAwB,kBAC1B,CAAC,GAAG,oBAAoB,IACxB,CAAA;AAGJ,QAAM,mBAAmB,qBAAA;AAQzB,aAAW,WAAW,kBAAkB;AACtC,UAAM,eAAe,oBAAoB,SAAS,GAAG;AACrD,QAAI,CAAC,cAAc;AACjB,aAAO;AAAA,QACL,uDAAuD,OAAO;AAAA,MAAA;AAEhE;AAAA,IACF;AAEA,QAAI;AACF,YAAM,kBAAkB,MAAM,SAAS,cAAc,OAAO;AAC5D,YAAM,WAAW,KAAK,MAAM,eAAe;AAG3C,UAAI,SAAS,WAAW,OAAO,SAAS,YAAY,UAAU;AAC5D,mBAAW,UAAU,OAAO,OAAO,SAAS,OAAO,GAAG;AACpD,cACE,UACA,OAAO,WAAW,YAClB,eAAe,UACf,OAAO,OAAO,cAAc,UAC5B;AACA,wBAAY,KAAK,OAAO,SAAS;AAAA,UACnC;AAAA,QACF;AAAA,MACF;AAAA,IACF,SAAS,OAAO;AACd,4BAAsB,SAAS,cAAc,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,SAAO;AACT;AAgBO,SAAS,wBACd,UAAuD,IAC7C;AACV,QAAM,EAAE,kBAAkB,MAAM,MAAM,QAAQ,IAAA,MAAU;AAGxD,QAAM,cAAwB,kBAC1B,CAAC,GAAG,oBAAoB,IACxB,CAAA;AAGJ,QAAM,mBAAmB,qBAAA;AAKzB,aAAW,WAAW,kBAAkB;AACtC,UAAM,eAAe,oBAAoB,SAAS,GAAG;AACrD,QAAI,CAAC,cAAc;AACjB,aAAO;AAAA,QACL,2DAA2D,OAAO;AAAA,MAAA;AAEpE;AAAA,IACF;AAEA,QAAI;AAEF,YAAM,kBAAkB,aAAa,cAAc,OAAO;AAC1D,YAAM,WAAW,KAAK,MAAM,eAAe;AAG3C,UAAI,SAAS,WAAW,OAAO,SAAS,YAAY,UAAU;AAC5D,mBAAW,UAAU,OAAO,OAAO,SAAS,OAAO,GAAG;AACpD,cACE,UACA,OAAO,WAAW,YAClB,eAAe,UACf,OAAO,OAAO,cAAc,UAC5B;AACA,wBAAY,KAAK,OAAO,SAAS;AAAA,UACnC;AAAA,QACF;AAAA,MACF;AAAA,IACF,SAAS,OAAO;AACd,4BAAsB,SAAS,cAAc,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,SAAO;AACT;"}

package/dist/manifest/discover-smrt-packages.d.ts

@@ -0,0 +1,48 @@
+/**
+ * SMRT Package Discovery
+ *
+ * Discovers all SMRT packages in node_modules by:
+ * 1. Scanning node_modules directory for installed packages
+ * 2. Following symlinks for workspace: dependencies
+ * 3. Checking for a package manifest (`dist/manifest.json`,
+ *    `.smrt/manifest.json`, or `src/manifest/manifest.json`) with moduleType: "smrt"
+ * 4. Caching results based on lockfile hash and manifest timestamps
+ *
+ * Cache Strategy:
+ * - ENABLED by default (5-50x faster startup)
+ * - Automatically invalidates when lockfile or any manifest.json changes
+ * - Disable with SMRT_DISABLE_DISCOVERY_CACHE=true for debugging
+ */
+/** Timing data for --timing flag */
+interface TimingData {
+    discovery?: number;
+    cacheCheck?: number;
+    total?: number;
+}
+/**
+ * Get timing data from last discovery operation
+ */
+export declare function getDiscoveryTiming(): TimingData;
+export declare function resolveManifestPath(packageName: string, baseDir?: string): string | null;
+export interface DiscoveryOptions {
+    /** Override project root for discovery/cache */
+    baseDir?: string;
+    /** Force fresh discovery, ignoring cache */
+    noCache?: boolean;
+    /** Show verbose output */
+    verbose?: boolean;
+    /** Record timing data */
+    timing?: boolean;
+}
+/**
+ * Main discovery function
+ *
+ * Cache ENABLED by default (5-50x faster startup)
+ * - Automatically invalidates when lockfile changes (dependencies updated)
+ * - Automatically invalidates when any manifest.json changes (packages rebuilt)
+ *
+ * Disable with SMRT_DISABLE_DISCOVERY_CACHE=true for debugging
+ */
+export declare function discoverSmrtPackages(options?: DiscoveryOptions): string[];
+export {};
+//# sourceMappingURL=discover-smrt-packages.d.ts.map

package/dist/manifest/discover-smrt-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-smrt-packages.d.ts","sourceRoot":"","sources":["../../src/manifest/discover-smrt-packages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAoBH,oCAAoC;AACpC,UAAU,UAAU;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAKD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,UAAU,CAE/C;AA2ID,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,MAAsB,GAC9B,MAAM,GAAG,IAAI,CAoBf;AAkPD,MAAM,WAAW,gBAAgB;IAC/B,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0BAA0B;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,yBAAyB;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,gBAAqB,GAAG,MAAM,EAAE,CAsE7E"}