@remnic/core 9.3.654 → 9.3.656

package/src/qmd-client.test.ts

@@ -70,6 +70,65 @@ function captureSubprocessArgs(client: QmdClient): string[][] {
   return calls;
 }
 
+test("updateStrict respects QMD update min-interval throttles", async () => {
+  const client = new QmdClient("memories", 3, { updateMinIntervalMs: 60_000 });
+  client.resetUpdateThrottles();
+  const calls = captureSubprocessArgs(client);
+
+  try {
+    await client.updateStrict();
+    await assert.rejects(
+      () => client.updateStrict(),
+      /QMD update skipped by min-interval gate|QMD update skipped by global min-interval gate/,
+    );
+  } finally {
+    client.resetUpdateThrottles();
+  }
+
+  assert.equal(calls.length, 1);
+});
+
+test("embedCollectionStrict rejects QMD embed subprocess failures", async () => {
+  const client = new QmdClient("memories", 3, { updateMinIntervalMs: 60_000 });
+  client.resetUpdateThrottles();
+  const internals = client as unknown as SubprocessInternals;
+  const calls: string[][] = [];
+  internals.available = true;
+  internals.runQmdCommand = async (args: string[]) => {
+    calls.push(args);
+    throw new Error("embed subprocess failed");
+  };
+
+  try {
+    await assert.rejects(
+      () => client.embedCollectionStrict("memories--project"),
+      /embed subprocess failed/,
+    );
+  } finally {
+    client.resetUpdateThrottles();
+  }
+
+  assert.deepEqual(calls, [["embed", "-c", "memories--project"]]);
+});
+
+test("embedCollectionStrict respects QMD embed min-interval throttles", async () => {
+  const client = new QmdClient("memories", 3, { updateMinIntervalMs: 60_000 });
+  client.resetUpdateThrottles();
+  const calls = captureSubprocessArgs(client);
+
+  try {
+    await client.embedCollectionStrict("memories--project");
+    await assert.rejects(
+      () => client.embedCollectionStrict("memories--project"),
+      /QMD embed skipped by per-collection min-interval gate/,
+    );
+  } finally {
+    client.resetUpdateThrottles();
+  }
+
+  assert.equal(calls.length, 1);
+});
+
 test("ensureCollection treats cancelled auto-create as unknown", async () => {
   const client = new QmdClient("memories", 3, {});
   const internals = client as unknown as SubprocessInternals & {

package/src/qmd.ts

@@ -1232,9 +1232,14 @@ export class QmdClient implements SearchBackend {
   resetUpdateThrottles(): void {
     this._lastUpdateFailAtMs = null;
     this.lastUpdateRunAtMs = null;
+    this.lastEmbedFailAtMs = null;
     const gs = getGlobalQmdState();
     gs.lastGlobalUpdateRunAtMs = null;
     gs.lastGlobalUpdateFailAtMs = null;
+    gs.lastGlobalEmbedRunAtMs = null;
+    gs.lastGlobalEmbedFailAtMs = null;
+    gs.lastEmbedByCollectionMs = {};
+    gs.lastEmbedFailByCollectionMs = {};
   }
 
   private readonly updateTimeoutMs: number;
@@ -2493,6 +2498,14 @@ export class QmdClient implements SearchBackend {
     );
   }
 
+  async updateStrict(execution?: SearchExecutionOptions): Promise<void> {
+    await this.runUpdateForCollection(
+      this.collection,
+      { perCollectionThrottle: false, strict: true },
+      execution?.signal,
+    );
+  }
+
   async updateCollection(
     collection: string,
     execution?: SearchExecutionOptions,
@@ -2510,7 +2523,7 @@ export class QmdClient implements SearchBackend {
   ): Promise<void> {
     await this.runUpdateForCollection(
       collection,
-      { perCollectionThrottle: true, strict: true },
+      { perCollectionThrottle: true, strict: true, force: true },
       execution?.signal,
     );
   }
@@ -2521,7 +2534,7 @@ export class QmdClient implements SearchBackend {
 
   private async runUpdateForCollection(
     collection: string,
-    options: { perCollectionThrottle: boolean; strict?: boolean },
+    options: { perCollectionThrottle: boolean; strict?: boolean; force?: boolean },
     signal?: AbortSignal,
   ): Promise<void> {
     if (this.available === false) {
@@ -2539,12 +2552,13 @@ export class QmdClient implements SearchBackend {
     }
     const globalState = getGlobalQmdState();
     const now = Date.now();
-    if (!options.strict && options.perCollectionThrottle) {
+    if (!options.force && options.perCollectionThrottle) {
       if (
         globalState.lastGlobalUpdateFailAtMs &&
         now - globalState.lastGlobalUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS
       ) {
         log.debug("QMD update: suppressed by global failure backoff");
+        if (options.strict) throw new Error("QMD update skipped by global failure backoff");
         return;
       }
       const lastCollectionRun = globalState.lastUpdateByCollectionMs[name];
@@ -2553,6 +2567,7 @@ export class QmdClient implements SearchBackend {
         now - lastCollectionRun < this.updateMinIntervalMs
       ) {
         log.debug(`QMD update: suppressed by per-collection min-interval gate (${name})`);
+        if (options.strict) throw new Error("QMD update skipped by per-collection min-interval gate");
         return;
       }
       const lastCollectionFail = globalState.lastUpdateFailByCollectionMs[name];
@@ -2561,14 +2576,16 @@ export class QmdClient implements SearchBackend {
         now - lastCollectionFail < QMD_UPDATE_BACKOFF_MS
       ) {
         log.debug(`QMD update: suppressed by per-collection failure backoff (${name})`);
+        if (options.strict) throw new Error("QMD update skipped by per-collection failure backoff");
         return;
       }
-    } else if (!options.strict) {
+    } else if (!options.force) {
       if (
         this.lastUpdateRunAtMs &&
         now - this.lastUpdateRunAtMs < this.updateMinIntervalMs
       ) {
         log.debug("QMD update: suppressed due to min-interval gate");
+        if (options.strict) throw new Error("QMD update skipped by min-interval gate");
         return;
       }
       if (
@@ -2576,6 +2593,7 @@ export class QmdClient implements SearchBackend {
         now - this._lastUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS
       ) {
         log.debug("QMD update: suppressed due to recent failures (backoff)");
+        if (options.strict) throw new Error("QMD update skipped by recent failure backoff");
         return;
       }
       if (
@@ -2583,6 +2601,7 @@ export class QmdClient implements SearchBackend {
         now - globalState.lastGlobalUpdateRunAtMs < this.updateMinIntervalMs
       ) {
         log.debug("QMD update: suppressed by global min-interval gate");
+        if (options.strict) throw new Error("QMD update skipped by global min-interval gate");
         return;
       }
       if (
@@ -2590,6 +2609,7 @@ export class QmdClient implements SearchBackend {
         now - globalState.lastGlobalUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS
       ) {
         log.debug("QMD update: suppressed by global failure backoff");
+        if (options.strict) throw new Error("QMD update skipped by global failure backoff");
         return;
       }
     }
@@ -2633,117 +2653,137 @@ export class QmdClient implements SearchBackend {
   }
 
   async embed(): Promise<void> {
-    if (this.available === false) return;
-    const globalState = getGlobalQmdState();
-    if (
-      this.lastEmbedFailAtMs &&
-      Date.now() - this.lastEmbedFailAtMs < QMD_EMBED_BACKOFF_MS
-    ) {
-      log.debug("QMD embed: suppressed due to recent failures (backoff)");
+    await this.runEmbedForCollection(this.collection, { perCollectionThrottle: false });
+  }
+
+  async embedStrict(): Promise<void> {
+    await this.runEmbedForCollection(this.collection, { perCollectionThrottle: false, strict: true });
+  }
+
+  async embedCollection(collection: string): Promise<void> {
+    await this.runEmbedForCollection(collection, { perCollectionThrottle: true });
+  }
+
+  async embedCollectionStrict(collection: string): Promise<void> {
+    await this.runEmbedForCollection(collection, { perCollectionThrottle: true, strict: true });
+  }
+
+  private async runEmbedForCollection(
+    collection: string,
+    options: { perCollectionThrottle: boolean; strict?: boolean },
+  ): Promise<void> {
+    if (this.available === false) {
+      if (options.strict) throw new Error("QMD unavailable");
       return;
     }
-    if (
-      globalState.lastGlobalEmbedRunAtMs &&
-      Date.now() - globalState.lastGlobalEmbedRunAtMs < this.updateMinIntervalMs
-    ) {
-      log.debug("QMD embed: suppressed by global min-interval gate");
+    const name = collection.trim();
+    if (!name) {
+      if (options.strict) throw new Error("QMD collection name is required");
       return;
     }
-    if (
-      globalState.lastGlobalEmbedFailAtMs &&
-      Date.now() - globalState.lastGlobalEmbedFailAtMs < QMD_EMBED_BACKOFF_MS
-    ) {
-      log.debug("QMD embed: suppressed by global failure backoff");
-      return;
+    const globalState = getGlobalQmdState();
+    const now = Date.now();
+    if (options.perCollectionThrottle) {
+      if (
+        globalState.lastGlobalEmbedFailAtMs &&
+        now - globalState.lastGlobalEmbedFailAtMs < QMD_EMBED_BACKOFF_MS
+      ) {
+        log.debug(`QMD embed: suppressed by global failure backoff (${name})`);
+        if (options.strict) throw new Error("QMD embed skipped by global failure backoff");
+        return;
+      }
+      const lastCollectionRun = globalState.lastEmbedByCollectionMs[name];
+      if (
+        Number.isFinite(lastCollectionRun) &&
+        now - lastCollectionRun < this.updateMinIntervalMs
+      ) {
+        log.debug(`QMD embed: suppressed by per-collection min-interval gate (${name})`);
+        if (options.strict) throw new Error("QMD embed skipped by per-collection min-interval gate");
+        return;
+      }
+      const lastCollectionFail = globalState.lastEmbedFailByCollectionMs[name];
+      if (
+        Number.isFinite(lastCollectionFail) &&
+        now - lastCollectionFail < QMD_EMBED_BACKOFF_MS
+      ) {
+        log.debug(`QMD embed: suppressed by per-collection failure backoff (${name})`);
+        if (options.strict) throw new Error("QMD embed skipped by per-collection failure backoff");
+        return;
+      }
+    } else {
+      if (
+        this.lastEmbedFailAtMs &&
+        now - this.lastEmbedFailAtMs < QMD_EMBED_BACKOFF_MS
+      ) {
+        log.debug("QMD embed: suppressed due to recent failures (backoff)");
+        if (options.strict) throw new Error("QMD embed skipped by recent failure backoff");
+        return;
+      }
+      if (
+        globalState.lastGlobalEmbedRunAtMs &&
+        now - globalState.lastGlobalEmbedRunAtMs < this.updateMinIntervalMs
+      ) {
+        log.debug("QMD embed: suppressed by global min-interval gate");
+        if (options.strict) throw new Error("QMD embed skipped by global min-interval gate");
+        return;
+      }
+      if (
+        globalState.lastGlobalEmbedFailAtMs &&
+        now - globalState.lastGlobalEmbedFailAtMs < QMD_EMBED_BACKOFF_MS
+      ) {
+        log.debug("QMD embed: suppressed by global failure backoff");
+        if (options.strict) throw new Error("QMD embed skipped by global failure backoff");
+        return;
+      }
     }
     try {
       const startedAtMs = Date.now();
-      await this.runQmdCommand(this.buildEmbedArgs(this.collection), 300_000);
+      await this.runQmdCommand(this.buildEmbedArgs(name), 300_000);
       const durationMs = Date.now() - startedAtMs;
       if (this.slowLog?.enabled && durationMs >= this.slowLog.thresholdMs) {
         log.warn(`SLOW QMD embed: durationMs=${durationMs}`);
       }
-      globalState.lastGlobalEmbedRunAtMs = Date.now();
-      log.debug("QMD embed completed");
-    } catch (err) {
-      if (isVectorDimensionMismatchError(err)) {
-        try {
-          log.warn("QMD embed hit a vector dimension mismatch; retrying with force re-embed");
-          await this.runQmdCommand(this.buildEmbedArgs(this.collection, true), 300_000);
-          globalState.lastGlobalEmbedRunAtMs = Date.now();
-          this.lastEmbedFailAtMs = null;
-          globalState.lastGlobalEmbedFailAtMs = null;
-          log.warn("QMD embed recovered by forcing a full vector rebuild");
-          return;
-        } catch (retryErr) {
-          const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-          log.warn(`QMD force re-embed failed after dimension mismatch: ${retryMsg}`);
-        }
-      }
-      const now = Date.now();
-      this.lastEmbedFailAtMs = now;
-      globalState.lastGlobalEmbedFailAtMs = now;
-      const msg = err instanceof Error ? err.message : String(err);
-      log.warn(`QMD embed failed: ${msg}`);
-    }
-  }
-
-  async embedCollection(collection: string): Promise<void> {
-    if (this.available === false) return;
-    const name = collection.trim();
-    if (!name) return;
-    const globalState = getGlobalQmdState();
-    const now = Date.now();
-    if (
-      globalState.lastGlobalEmbedFailAtMs &&
-      now - globalState.lastGlobalEmbedFailAtMs < QMD_EMBED_BACKOFF_MS
-    ) {
-      log.debug(`QMD embed: suppressed by global failure backoff (${name})`);
-      return;
-    }
-    const lastCollectionRun = globalState.lastEmbedByCollectionMs[name];
-    if (
-      Number.isFinite(lastCollectionRun) &&
-      now - lastCollectionRun < this.updateMinIntervalMs
-    ) {
-      log.debug(`QMD embed: suppressed by per-collection min-interval gate (${name})`);
-      return;
-    }
-    const lastCollectionFail = globalState.lastEmbedFailByCollectionMs[name];
-    if (
-      Number.isFinite(lastCollectionFail) &&
-      now - lastCollectionFail < QMD_EMBED_BACKOFF_MS
-    ) {
-      log.debug(`QMD embed: suppressed by per-collection failure backoff (${name})`);
-      return;
-    }
-    try {
-      await this.runQmdCommand(this.buildEmbedArgs(name), 300_000);
       const at = Date.now();
-      globalState.lastEmbedByCollectionMs[name] = at;
+      if (options.perCollectionThrottle) {
+        globalState.lastEmbedByCollectionMs[name] = at;
+      }
       globalState.lastGlobalEmbedRunAtMs = at;
+      log.debug(`QMD embed completed for collection=${name}`);
     } catch (err) {
+      let failure: unknown = err;
       if (isVectorDimensionMismatchError(err)) {
         try {
           log.warn(`QMD embed for collection ${name} hit a vector dimension mismatch; retrying with force re-embed`);
           await this.runQmdCommand(this.buildEmbedArgs(name, true), 300_000);
           const recoveredAt = Date.now();
-          globalState.lastEmbedByCollectionMs[name] = recoveredAt;
+          if (options.perCollectionThrottle) {
+            globalState.lastEmbedByCollectionMs[name] = recoveredAt;
+            delete globalState.lastEmbedFailByCollectionMs[name];
+          } else {
+            this.lastEmbedFailAtMs = null;
+          }
           globalState.lastGlobalEmbedRunAtMs = recoveredAt;
-          delete globalState.lastEmbedFailByCollectionMs[name];
           globalState.lastGlobalEmbedFailAtMs = null;
           log.warn(`QMD embed for collection ${name} recovered by forcing a full vector rebuild`);
           return;
         } catch (retryErr) {
+          failure = retryErr;
           const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
           log.warn(`QMD force re-embed failed for collection ${name}: ${retryMsg}`);
         }
       }
       const at = Date.now();
-      globalState.lastEmbedFailByCollectionMs[name] = at;
+      if (options.perCollectionThrottle) {
+        globalState.lastEmbedFailByCollectionMs[name] = at;
+      } else {
+        this.lastEmbedFailAtMs = at;
+      }
       globalState.lastGlobalEmbedFailAtMs = at;
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg = failure instanceof Error ? failure.message : String(failure);
       log.warn(`QMD embed failed for collection ${name}: ${msg}`);
+      if (options.strict) {
+        throw failure;
+      }
     }
   }
 

package/src/search/port.ts

@@ -81,6 +81,12 @@ export interface SearchBackend {
 
   // ── Maintenance ──
   update(execution?: SearchExecutionOptions): Promise<void>;
+  /**
+   * Optional strict refresh used by callers that must know whether the backend
+   * was actually refreshed before writing success markers. Ordinary update
+   * calls remain fail-open for migration/maintenance resilience.
+   */
+  updateStrict?(execution?: SearchExecutionOptions): Promise<void>;
   updateCollection(collection: string, execution?: SearchExecutionOptions): Promise<void>;
   updateCollectionFromDir?(collection: string, memoryDir: string, execution?: SearchExecutionOptions): Promise<void>;
   /**
@@ -96,7 +102,17 @@ export interface SearchBackend {
    */
   updateCollectionStrict?(collection: string, execution?: SearchExecutionOptions): Promise<void>;
   embed(): Promise<void>;
+  /**
+   * Optional strict embed used by callers that must know vectors were actually
+   * refreshed before writing success markers.
+   */
+  embedStrict?(): Promise<void>;
   embedCollection(collection: string): Promise<void>;
+  /**
+   * Optional strict collection embed used by callers that must know vectors were
+   * actually refreshed before writing success markers.
+   */
+  embedCollectionStrict?(collection: string): Promise<void>;
 
   // ── Collection management ──
   /**

package/src/semantic-rule-verifier.ts

@@ -99,6 +99,18 @@ function scoreVerifiedSemanticRuleCandidate(
   return { score, matchedFields };
 }
 
+export function compareVerifiedSemanticRuleResults(
+  left: VerifiedSemanticRuleResult,
+  right: VerifiedSemanticRuleResult,
+): number {
+  return (
+    right.score - left.score ||
+    right.effectiveConfidence - left.effectiveConfidence ||
+    right.rule.frontmatter.updated.localeCompare(left.rule.frontmatter.updated) ||
+    left.rule.frontmatter.id.localeCompare(right.rule.frontmatter.id)
+  );
+}
+
 export async function searchVerifiedSemanticRules(options: {
   memoryDir: string;
   query: string;
@@ -150,11 +162,6 @@ export async function searchVerifiedSemanticRules(options: {
   }
 
   return candidates
-    .sort(
-      (left, right) =>
-        right.score - left.score
-        || right.effectiveConfidence - left.effectiveConfidence
-        || right.rule.frontmatter.updated.localeCompare(left.rule.frontmatter.updated),
-    )
+    .sort(compareVerifiedSemanticRuleResults)
     .slice(0, options.maxResults);
 }

package/src/types.ts

@@ -442,6 +442,55 @@ export interface CodingContext {
   defaultBranch: string | null;
 }
 
+export type ScopeProfileLayerId =
+  | "userProject"
+  | "teamProject"
+  | "userGlobal"
+  | "serverShared";
+
+export type ScopeProfilePromotionTarget =
+  | ScopeProfileLayerId
+  | "serverShared"
+  | "teamProject"
+  | "userGlobal";
+
+export interface ScopeProfileTeamProjectConfig {
+  /**
+   * Namespace template for team-project layers. Supported placeholders:
+   * `{teamId}`, `{principal}`, `{projectId}`, `{projectHash}`, and
+   * `{projectNamespace}`. The resolved namespace is validated at use time.
+   */
+  namespaceTemplate?: string;
+  /**
+   * Optional trusted team id for this profile. When omitted, the resolver uses
+   * the first configured team whose principal lists include the caller.
+   */
+  teamId?: string;
+}
+
+export interface ScopeProfileAutoPromoteConfig {
+  enabled: boolean;
+  targets: ScopeProfilePromotionTarget[];
+  categories: Array<"fact" | "correction" | "decision" | "preference" | "rule" | "procedure">;
+  minConfidenceTier: ConfidenceTier;
+}
+
+export interface ScopeProfileConfig {
+  readOrder: ScopeProfileLayerId[];
+  writeDefault: ScopeProfileLayerId;
+  promotionTargets: ScopeProfilePromotionTarget[];
+  teamProject?: ScopeProfileTeamProjectConfig;
+  autoPromote: ScopeProfileAutoPromoteConfig;
+}
+
+export interface ScopeTeamConfig {
+  principals: string[];
+  projectNamespaceTemplate?: string;
+  read: string[];
+  write: string[];
+  promote: string[];
+}
+
 /** Configuration for the nightly contradiction-scan cron (issue #520). */
 export interface ContradictionScanConfig {
   /** Master switch for the contradiction scan cron. Default true. */
@@ -1216,6 +1265,18 @@ export interface PluginConfig {
   // QMD maintenance (debounced singleflight)
   qmdMaintenanceEnabled: boolean;
   qmdMaintenanceDebounceMs: number;
+  /**
+   * Namespace-aware maintenance fanout (issue #1500). When namespaces are
+   * enabled, background maintenance jobs use the rebuildable namespace catalog
+   * to discover dynamic project/team namespaces rather than only processing the
+   * configured default/shared/policy set.
+   */
+  maintenanceNamespaceFanoutEnabled: boolean;
+  maintenanceMaxNamespacesPerCycle: number;
+  maintenanceIncludeProjectNamespaces: boolean;
+  maintenanceIncludeBranchNamespaces: boolean;
+  maintenanceIncludeTeamProjectNamespaces: boolean;
+  maintenanceNamespaceLockStaleMs: number;
   qmdAutoEmbedEnabled: boolean;
   qmdEmbedMinIntervalMs: number;
   qmdUpdateTimeoutMs: number;
@@ -1309,6 +1370,9 @@ export interface PluginConfig {
   principalFromSessionKeyRules: PrincipalRule[];
   namespacePolicies: NamespacePolicy[];
   defaultRecallNamespaces: Array<"self" | "shared">;
+  scopeProfiles: Record<string, ScopeProfileConfig>;
+  defaultScopeProfile: string | undefined;
+  teams: Record<string, ScopeTeamConfig>;
   cronRecallMode: CronRecallMode;
   cronRecallAllowlist: string[];
   cronRecallPolicyEnabled: boolean;

package/src/verified-recall.ts

@@ -84,6 +84,15 @@ function resolveVerifiedEpisodeMemoriesFromMap(
   return verified;
 }
 
+export function compareVerifiedEpisodeResults(left: VerifiedEpisodeResult, right: VerifiedEpisodeResult): number {
+  return (
+    right.score - left.score ||
+    right.verifiedEpisodeCount - left.verifiedEpisodeCount ||
+    right.box.sealedAt.localeCompare(left.box.sealedAt) ||
+    left.box.id.localeCompare(right.box.id)
+  );
+}
+
 export async function searchVerifiedEpisodes(options: {
   memoryDir: string;
   query: string;
@@ -128,11 +137,6 @@ export async function searchVerifiedEpisodes(options: {
       verifiedMemoryIds: candidate.verifiedMemories.map((memory) => memory.frontmatter.id),
       matchedFields: [...candidate.matchedFields].sort(),
     }))
-    .sort(
-      (left, right) =>
-        right.score - left.score
-        || right.verifiedEpisodeCount - left.verifiedEpisodeCount
-        || right.box.sealedAt.localeCompare(left.box.sealedAt),
-    )
+    .sort(compareVerifiedEpisodeResults)
     .slice(0, options.maxResults);
 }

package/dist/chunk-JVRPJ7D4.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/namespaces/search.ts"],"sourcesContent":["import path from \"node:path\";\nimport type { PluginConfig, QmdSearchResult } from \"../types.js\";\nimport type {\n  SearchBackend,\n  SearchExecutionOptions,\n  SearchQueryOptions,\n} from \"../search/port.js\";\nimport { createSearchBackend } from \"../search/factory.js\";\nimport { namespaceIdentityToken, normalizeNamespaceIdentity } from \"./identity.js\";\n\nconst NESTED_NAMESPACE_FILTER_OVERFETCH_FACTOR = 4;\nconst NESTED_NAMESPACE_FILTER_OVERFETCH_MIN = 50;\n\nexport function namespaceCollectionName(\n  baseCollection: string,\n  namespace: string,\n  options?: {\n    defaultNamespace?: string;\n    useLegacyDefaultCollection?: boolean;\n  },\n): string {\n  const trimmed = normalizeNamespaceIdentity(namespace);\n  const defaultNamespace = normalizeNamespaceIdentity(options?.defaultNamespace ?? \"\") || \"default\";\n  if (\n    options?.useLegacyDefaultCollection === true &&\n    trimmed === defaultNamespace\n  ) {\n    return baseCollection;\n  }\n\n  return `${baseCollection}--${namespaceIdentityToken(trimmed || defaultNamespace)}`;\n}\n\ntype StorageRouterLike = {\n  storageFor(namespace: string): Promise<{ dir: string }>;\n};\n\ntype NamespaceBackendRecord = {\n  backend: SearchBackend;\n  collection: string;\n  memoryDir: string;\n  available: boolean;\n  collectionState: CollectionState;\n  filtersNestedNamespaces: boolean;\n};\n\nexport type CollectionState = \"present\" | \"missing\" | \"unknown\" | \"skipped\";\n\nexport interface NamespaceSearchHealth {\n  collection: string;\n  memoryDir: string;\n  available: boolean;\n  collectionState: CollectionState;\n  debugStatus: string;\n  installedVersion: string | null;\n  supportedVersion: string | null;\n  supported: boolean | null;\n  upgradeAvailable: boolean | null;\n  doctorAvailable: boolean | null;\n  daemonMode: boolean | null;\n}\n\ntype NamespaceScopedSearchConfig = PluginConfig & {\n  hostEmbeddingProviderScope?: string;\n};\n\ntype BackendRecordOptions = {\n  autoCreateCollection: boolean;\n  abortAsUnavailable: boolean;\n  failOpenMissingGuardedCollection: boolean;\n};\n\nexport class NamespaceSearchRouter {\n  private readonly cache = new Map<string, Promise<NamespaceBackendRecord>>();\n\n  constructor(\n    private readonly config: PluginConfig,\n    private readonly storageRouter: StorageRouterLike,\n    private readonly createBackend: (config: PluginConfig) => SearchBackend = createSearchBackend,\n  ) {}\n\n  async collectionForNamespace(namespace: string): Promise<string> {\n    return (await this.backendRecordFor(namespace)).collection;\n  }\n\n  async searchAcrossNamespaces(options: {\n    query: string;\n    namespaces: string[];\n    maxResults?: number;\n    mode?: \"search\" | \"hybrid\" | \"bm25\" | \"vector\";\n    searchOptions?: SearchQueryOptions;\n    execution?: SearchExecutionOptions;\n  }): Promise<QmdSearchResult[]> {\n    const query = options.query.trim();\n    if (!query) return [];\n    const maxResults = Math.max(0, Math.floor(options.maxResults ?? this.config.qmdMaxResults));\n    if (maxResults === 0) return [];\n\n    const method = options.mode ?? \"search\";\n    const namespaces = Array.from(new Set(options.namespaces.map((value) => value.trim()).filter(Boolean)));\n    if (namespaces.length === 0) return [];\n\n    const resultsByNamespace = await Promise.all(\n      namespaces.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        if (!record.available || record.collectionState === \"missing\") {\n          return { namespace, results: [] as QmdSearchResult[] };\n        }\n        const backendLimit = backendSearchLimit(record, maxResults);\n        let results: QmdSearchResult[];\n        switch (method) {\n          case \"hybrid\":\n            results = await record.backend.hybridSearch(\n              query,\n              record.collection,\n              backendLimit,\n              options.execution,\n            );\n            break;\n          case \"bm25\":\n            results = await record.backend.bm25Search(\n              query,\n              record.collection,\n              backendLimit,\n              options.execution,\n            );\n            break;\n          case \"vector\":\n            results = await record.backend.vectorSearch(\n              query,\n              record.collection,\n              backendLimit,\n              options.execution,\n            );\n            break;\n          default:\n            results = await record.backend.search(\n              query,\n              record.collection,\n              backendLimit,\n              options.searchOptions,\n              options.execution,\n            );\n            break;\n        }\n        results = filterNamespaceSubtreeResults(record, results);\n        return { namespace, results };\n      }),\n    );\n\n    return mergeNamespaceSearchResults(resultsByNamespace, maxResults);\n  }\n\n  /**\n   * Update all namespace backends.\n   * Returns the number of backends for which an update was attempted\n   * (i.e., available and collection present).  Callers can treat 0 as a\n   * signal that no backend was eligible — useful for success-verification in\n   * startup-sync when namespacesEnabled is true.\n   */\n  async updateNamespaces(\n    namespaces: string[],\n    execution?: SearchExecutionOptions,\n  ): Promise<number> {\n    const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));\n    const eligible = (await Promise.all(\n      unique.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        return record.available && record.collectionState !== \"missing\"\n          ? record\n          : null;\n      }),\n    )).filter((record): record is NamespaceBackendRecord => record !== null);\n\n    const globalRecord = eligible.find((record) => record.backend.updatesAllCollections?.() === true);\n    const scopedRecords = globalRecord\n      ? eligible.filter((record) => record.backend.updatesAllCollections?.() !== true)\n      : eligible;\n\n    await Promise.all([\n      globalRecord ? globalRecord.backend.update(execution) : Promise.resolve(),\n      ...scopedRecords.map((record) => record.backend.update(execution)),\n    ]);\n\n    return (globalRecord ? 1 : 0) + scopedRecords.length;\n  }\n\n  async embedNamespaces(namespaces: string[]): Promise<void> {\n    const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));\n    await Promise.all(\n      unique.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        if (!record.available || record.collectionState === \"missing\") return;\n        await record.backend.embed();\n      }),\n    );\n  }\n\n  async ensureNamespaceCollection(\n    namespace: string,\n    execution?: SearchExecutionOptions,\n  ): Promise<\"present\" | \"missing\" | \"unknown\" | \"skipped\"> {\n    const record = await this.backendRecordFor(namespace, execution);\n    return record.collectionState;\n  }\n\n  async healthForNamespace(\n    namespace: string,\n    execution?: SearchExecutionOptions,\n  ): Promise<NamespaceSearchHealth> {\n    const key = namespace.trim() || this.config.defaultNamespace;\n    const record = await this.createBackendRecordFor(\n      key,\n      execution,\n      {\n        autoCreateCollection: false,\n        abortAsUnavailable: true,\n        failOpenMissingGuardedCollection: false,\n      },\n    );\n    try {\n      const liveRecord = await this.liveCachedRecordForHealth(key, record, execution);\n      const diagnosticBackend = liveRecord?.backend ?? record.backend;\n      const versionStatus =\n        \"getVersionStatus\" in diagnosticBackend &&\n        typeof diagnosticBackend.getVersionStatus === \"function\"\n          ? diagnosticBackend.getVersionStatus()\n          : null;\n      const daemonMode = daemonModeForBackend(diagnosticBackend);\n      const collectionState =\n        liveRecord?.collectionState === \"missing\"\n          ? \"missing\"\n          : record.collectionState;\n\n      return {\n        collection: record.collection,\n        memoryDir: record.memoryDir,\n        available: liveRecord?.available ?? record.available,\n        collectionState,\n        debugStatus: diagnosticBackend.debugStatus(),\n        installedVersion: versionStatus?.installedVersion ?? null,\n        supportedVersion: versionStatus?.supportedVersion ?? null,\n        supported: versionStatus?.supported ?? null,\n        upgradeAvailable: versionStatus?.upgradeAvailable ?? null,\n        doctorAvailable: versionStatus?.capabilities?.doctor ?? null,\n        daemonMode,\n      };\n    } finally {\n      const dispose = (record.backend as { dispose?: () => void | Promise<void> }).dispose;\n      await dispose?.call(record.backend);\n    }\n  }\n\n  private async liveCachedRecordForHealth(\n    key: string,\n    disposableRecord: NamespaceBackendRecord,\n    execution?: SearchExecutionOptions,\n  ): Promise<NamespaceBackendRecord | null> {\n    const pending = this.cache.get(key);\n    if (!pending) return null;\n    const cachedRecord = await awaitWithAbort(pending, execution?.signal).catch(() => null);\n    if (!cachedRecord) return null;\n    if (cachedRecord.collection !== disposableRecord.collection) return null;\n    if (cachedRecord.memoryDir !== disposableRecord.memoryDir) return null;\n    return cachedRecord;\n  }\n\n  /** Clear cached backend records so the next access re-probes availability. */\n  clearCache(): void {\n    this.cache.clear();\n  }\n\n  /** Release any per-namespace backend handles held by cached records. */\n  async dispose(): Promise<void> {\n    const pendingRecords = Array.from(this.cache.values());\n    this.cache.clear();\n    const settled = await Promise.allSettled(pendingRecords);\n    await Promise.allSettled(\n      settled.flatMap((entry) => {\n        if (entry.status !== \"fulfilled\") return [];\n        const dispose = (entry.value.backend as { dispose?: () => void | Promise<void> }).dispose;\n        return dispose ? [dispose.call(entry.value.backend)] : [];\n      }),\n    );\n  }\n\n  private async backendRecordFor(\n    namespace: string,\n    execution?: SearchExecutionOptions,\n  ): Promise<NamespaceBackendRecord> {\n    const key = namespace.trim() || this.config.defaultNamespace;\n    const existing = this.cache.get(key);\n    if (existing) return await existing;\n\n    const pending = this.createBackendRecordFor(key, execution, {\n      autoCreateCollection: true,\n      abortAsUnavailable: false,\n      failOpenMissingGuardedCollection: true,\n    }).catch((error) => {\n      this.cache.delete(key);\n      throw error;\n    });\n\n    this.cache.set(key, pending);\n    return await pending;\n  }\n\n  private async createBackendRecordFor(\n    namespace: string,\n    execution: SearchExecutionOptions | undefined,\n    options: BackendRecordOptions,\n  ): Promise<NamespaceBackendRecord> {\n    const key = namespace.trim() || this.config.defaultNamespace;\n    const storage = await this.storageRouter.storageFor(key);\n    const useLegacyDefaultCollection =\n      key === this.config.defaultNamespace && storage.dir === this.config.memoryDir;\n    const filtersNestedNamespaces =\n      this.config.namespacesEnabled === true && useLegacyDefaultCollection;\n    const rootHostEmbeddingScope =\n      (this.config as NamespaceScopedSearchConfig).hostEmbeddingProviderScope ??\n      this.config.memoryDir;\n    const scopedConfig: NamespaceScopedSearchConfig = {\n      ...this.config,\n      memoryDir: storage.dir,\n      hostEmbeddingProviderScope: rootHostEmbeddingScope,\n      qmdCollection: namespaceCollectionName(this.config.qmdCollection, key, {\n        defaultNamespace: this.config.defaultNamespace,\n        useLegacyDefaultCollection,\n      }),\n    };\n\n    const backend = this.createBackend(scopedConfig);\n    try {\n      const availabilityProbe =\n        options.autoCreateCollection || typeof backend.checkAvailability !== \"function\"\n          ? backend.probe()\n          : backend.checkAvailability({ signal: execution?.signal });\n      const available = await awaitWithAbort(availabilityProbe, execution?.signal).catch((error) => {\n        if (error instanceof NamespaceSearchAbortError && !options.abortAsUnavailable) {\n          throw error;\n        }\n        return false;\n      });\n      const collectionState = available\n        ? await awaitWithAbort(\n          this.collectionStateForBackend(backend, storage.dir, scopedConfig.qmdCollection, {\n            autoCreate: options.autoCreateCollection,\n            failOpenMissingGuardedCollection: options.failOpenMissingGuardedCollection,\n            skipAutoCreate: filtersNestedNamespaces,\n            execution,\n          }),\n          execution?.signal,\n        ).catch((error) => {\n          if (error instanceof NamespaceSearchAbortError && !options.abortAsUnavailable) {\n            throw error;\n          }\n          return \"unknown\" as const;\n        })\n        : \"unknown\";\n      return {\n        backend,\n        collection: scopedConfig.qmdCollection,\n        memoryDir: storage.dir,\n        available,\n        collectionState,\n        filtersNestedNamespaces,\n      };\n    } catch (error) {\n      const dispose = (backend as { dispose?: () => void | Promise<void> }).dispose;\n      if (dispose) {\n        await Promise.resolve(dispose.call(backend)).catch(() => {});\n      }\n      throw error;\n    }\n  }\n\n  private async collectionStateForBackend(\n    backend: SearchBackend,\n    memoryDir: string,\n    collection: string,\n    options: {\n      autoCreate: boolean;\n      failOpenMissingGuardedCollection: boolean;\n      skipAutoCreate: boolean;\n      execution?: SearchExecutionOptions;\n    },\n  ): Promise<CollectionState> {\n    if (!options.autoCreate || options.skipAutoCreate) {\n      if (!backend.checkCollection) return \"unknown\";\n      const collectionState = await backend\n        .checkCollection(collection, options.execution)\n        .catch(() => \"unknown\" as const);\n      return options.failOpenMissingGuardedCollection && collectionState === \"missing\"\n        ? \"unknown\"\n        : collectionState;\n    }\n    return await backend.ensureCollection(memoryDir, collection, options.execution).catch(() => \"unknown\" as const);\n  }\n}\n\nclass NamespaceSearchAbortError extends Error {\n  constructor() {\n    super(\"operation aborted\");\n  }\n}\n\nfunction awaitWithAbort<T>(operation: Promise<T>, signal?: AbortSignal): Promise<T> {\n  if (!signal) return operation;\n  if (signal.aborted) return Promise.reject(new NamespaceSearchAbortError());\n\n  return new Promise<T>((resolve, reject) => {\n    const onAbort = () => {\n      signal.removeEventListener(\"abort\", onAbort);\n      reject(new NamespaceSearchAbortError());\n    };\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n    operation.then(resolve, reject).finally(() => {\n      signal.removeEventListener(\"abort\", onAbort);\n    });\n  });\n}\n\nfunction filterNamespaceSubtreeResults(\n  record: NamespaceBackendRecord,\n  results: QmdSearchResult[],\n): QmdSearchResult[] {\n  if (!record.filtersNestedNamespaces) return results;\n  return results.filter((result) =>\n    !pathIsInsideNamespaceSubtree(record.memoryDir, record.collection, result.path)\n  );\n}\n\nfunction backendSearchLimit(\n  record: NamespaceBackendRecord,\n  maxResults: number,\n): number {\n  if (!record.filtersNestedNamespaces) return maxResults;\n  return Math.max(\n    maxResults,\n    maxResults * NESTED_NAMESPACE_FILTER_OVERFETCH_FACTOR,\n    NESTED_NAMESPACE_FILTER_OVERFETCH_MIN,\n  );\n}\n\nfunction daemonModeForBackend(backend: SearchBackend): boolean | null {\n  return \"isDaemonMode\" in backend && typeof backend.isDaemonMode === \"function\"\n    ? backend.isDaemonMode() === true\n    : null;\n}\n\nfunction pathIsInsideNamespaceSubtree(\n  memoryDir: string,\n  collection: string,\n  resultPath: string | undefined,\n): boolean {\n  if (!resultPath) return false;\n  const normalizedResultPath = normalizeQmdResultPath(resultPath, collection);\n  const memoryRoot = path.resolve(memoryDir);\n  const namespacesRoot = path.join(memoryRoot, \"namespaces\");\n  const candidate = path.isAbsolute(normalizedResultPath)\n    ? path.normalize(normalizedResultPath)\n    : path.resolve(memoryRoot, normalizedResultPath);\n  const relative = path.relative(namespacesRoot, candidate);\n  return relative === \"\" || (!relative.startsWith(\"..\") && !path.isAbsolute(relative));\n}\n\nfunction normalizeQmdResultPath(resultPath: string, collection: string): string {\n  let value = resultPath.trim();\n  if (value.startsWith(\"qmd://\")) {\n    try {\n      const parsed = new URL(value);\n      if (parsed.protocol === \"qmd:\" && parsed.hostname === collection) {\n        value = decodeURIComponent(parsed.pathname.replace(/^\\/+/, \"\"));\n      }\n    } catch {\n      const remainder = value.slice(\"qmd://\".length);\n      const slashIndex = remainder.indexOf(\"/\");\n      if (slashIndex !== -1) {\n        value = remainder.slice(slashIndex + 1);\n      }\n    }\n  }\n\n  const collectionPrefix = `${collection}/`;\n  if (value.startsWith(collectionPrefix)) {\n    value = value.slice(collectionPrefix.length);\n  }\n  return value;\n}\n\nfunction mergeNamespaceSearchResults(\n  lists: Array<{ namespace: string; results: QmdSearchResult[] }>,\n  maxResults: number,\n): QmdSearchResult[] {\n  const merged = new Map<string, QmdSearchResult>();\n\n  for (const { namespace, results } of lists) {\n    for (const result of results) {\n      const key = `${namespace}\\0${result.path || result.docid}`;\n      const existing = merged.get(key);\n      if (!existing) {\n        merged.set(key, result);\n        continue;\n      }\n      if (result.score > existing.score) {\n        merged.set(key, {\n          ...result,\n          snippet: existing.snippet || result.snippet || \"\",\n        });\n      }\n    }\n  }\n\n  return [...merged.values()]\n    .sort((a, b) => b.score - a.score)\n    .slice(0, maxResults);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-K6X553JB.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/semantic-rule-verifier.ts"],"sourcesContent":["import { getCachedRuleMemories, setCachedRuleMemories } from \"./memory-cache.js\";\nimport { StorageManager } from \"./storage.js\";\nimport type { MemoryFile } from \"./types.js\";\nimport { countRecallTokenOverlap, normalizeRecallTokens } from \"./recall-tokenization.js\";\n\nexport type SemanticRuleVerificationStatus =\n  | \"verified\"\n  | \"source-memory-missing\"\n  | \"source-memory-archived\"\n  | \"source-memory-forgotten\"\n  | \"source-memory-not-episode\";\n\nexport interface VerifiedSemanticRuleResult {\n  rule: MemoryFile;\n  score: number;\n  sourceMemoryId: string;\n  verificationStatus: SemanticRuleVerificationStatus;\n  effectiveConfidence: number;\n  matchedFields: string[];\n}\n\nconst DEFAULT_MIN_EFFECTIVE_CONFIDENCE = 0.45;\n\nfunction verificationConfidenceMultiplier(status: SemanticRuleVerificationStatus): number {\n  switch (status) {\n    case \"verified\":\n      return 1;\n    case \"source-memory-not-episode\":\n      return 0.45;\n    case \"source-memory-archived\":\n      return 0.4;\n    case \"source-memory-forgotten\":\n      return 0.3;\n    case \"source-memory-missing\":\n      return 0.35;\n    default:\n      return 0.35;\n  }\n}\n\nfunction resolveVerificationStatus(sourceMemory: MemoryFile | undefined): SemanticRuleVerificationStatus {\n  if (!sourceMemory) return \"source-memory-missing\";\n  if (sourceMemory.frontmatter.status === \"archived\") {\n    return \"source-memory-archived\";\n  }\n  if (sourceMemory.frontmatter.status === \"forgotten\") return \"source-memory-forgotten\";\n  if (sourceMemory.frontmatter.memoryKind !== \"episode\") return \"source-memory-not-episode\";\n  return \"verified\";\n}\n\nfunction resolveEffectiveConfidence(rule: MemoryFile, sourceMemory: MemoryFile | undefined): {\n  status: SemanticRuleVerificationStatus;\n  effectiveConfidence: number;\n} {\n  const status = resolveVerificationStatus(sourceMemory);\n  const ruleConfidence = Number.isFinite(rule.frontmatter.confidence) ? rule.frontmatter.confidence : 0.8;\n  const sourceConfidence = Number.isFinite(sourceMemory?.frontmatter.confidence)\n    ? sourceMemory!.frontmatter.confidence\n    : ruleConfidence;\n  const anchoredConfidence = Math.min(ruleConfidence, sourceConfidence);\n  const effectiveConfidence = Math.max(\n    0,\n    Math.min(1, anchoredConfidence * verificationConfidenceMultiplier(status)),\n  );\n  return { status, effectiveConfidence };\n}\n\nfunction scoreVerifiedSemanticRuleCandidate(\n  rule: MemoryFile,\n  sourceMemory: MemoryFile | undefined,\n  queryTokens: Set<string>,\n  effectiveConfidence: number,\n): { score: number; matchedFields: Set<string> } {\n  const matchedFields = new Set<string>();\n  let score = 0;\n\n  const ruleContentMatches = countRecallTokenOverlap(queryTokens, rule.content);\n  if (ruleContentMatches > 0) {\n    score += ruleContentMatches * 5;\n    matchedFields.add(\"ruleContent\");\n  }\n\n  const tagMatches = countRecallTokenOverlap(queryTokens, rule.frontmatter.tags?.join(\" \"));\n  if (tagMatches > 0) {\n    score += tagMatches * 2;\n    matchedFields.add(\"tags\");\n  }\n\n  const sourceContentMatches = countRecallTokenOverlap(queryTokens, sourceMemory?.content);\n  if (sourceContentMatches > 0) {\n    score += sourceContentMatches * 2;\n    matchedFields.add(\"sourceContent\");\n  }\n\n  if (score > 0) {\n    score += effectiveConfidence;\n  }\n\n  return { score, matchedFields };\n}\n\nexport async function searchVerifiedSemanticRules(options: {\n  memoryDir: string;\n  query: string;\n  maxResults: number;\n  minEffectiveConfidence?: number;\n}): Promise<VerifiedSemanticRuleResult[]> {\n  const queryTokens = new Set(normalizeRecallTokens(options.query, [\"what\", \"which\"]));\n  if (queryTokens.size === 0 || options.maxResults <= 0) return [];\n\n  const storage = new StorageManager(options.memoryDir);\n  const version = storage.getMemoryStatusVersion();\n\n  // Use derived rule cache to avoid O(146K) iteration on every call.\n  let cachedRules = getCachedRuleMemories(storage.dir, version);\n  if (!cachedRules) {\n    const allMems = await storage.readAllMemories();\n    cachedRules = setCachedRuleMemories(storage.dir, allMems, version);\n  }\n  const { all: ruleMemories, byId: memoryById } = cachedRules;\n  const minEffectiveConfidence = options.minEffectiveConfidence ?? DEFAULT_MIN_EFFECTIVE_CONFIDENCE;\n\n  const candidates: VerifiedSemanticRuleResult[] = [];\n  // ruleMemories is pre-filtered to category=rule and recall-hidden statuses.\n  for (const memory of ruleMemories) {\n    if (memory.frontmatter.source !== \"semantic-rule-promotion\") continue;\n    const sourceMemoryId = memory.frontmatter.sourceMemoryId;\n    if (!sourceMemoryId) continue;\n\n    const sourceMemory = memoryById.get(sourceMemoryId);\n    const { status, effectiveConfidence } = resolveEffectiveConfidence(memory, sourceMemory);\n    if (effectiveConfidence < minEffectiveConfidence) continue;\n\n    const { score, matchedFields } = scoreVerifiedSemanticRuleCandidate(\n      memory,\n      sourceMemory,\n      queryTokens,\n      effectiveConfidence,\n    );\n    if (score <= 0) continue;\n\n    candidates.push({\n      rule: memory,\n      score,\n      sourceMemoryId,\n      verificationStatus: status,\n      effectiveConfidence,\n      matchedFields: [...matchedFields].sort(),\n    });\n  }\n\n  return candidates\n    .sort(\n      (left, right) =>\n        right.score - left.score\n        || right.effectiveConfidence - left.effectiveConfidence\n        || right.rule.frontmatter.updated.localeCompare(left.rule.frontmatter.updated),\n    )\n    .slice(0, options.maxResults);\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,IAAM,mCAAmC;AAEzC,SAAS,iCAAiC,QAAgD;AACxF,UAAQ,QAAQ;AAAA,IACd,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT;AACE,aAAO;AAAA,EACX;AACF;AAEA,SAAS,0BAA0B,cAAsE;AACvG,MAAI,CAAC,aAAc,QAAO;AAC1B,MAAI,aAAa,YAAY,WAAW,YAAY;AAClD,WAAO;AAAA,EACT;AACA,MAAI,aAAa,YAAY,WAAW,YAAa,QAAO;AAC5D,MAAI,aAAa,YAAY,eAAe,UAAW,QAAO;AAC9D,SAAO;AACT;AAEA,SAAS,2BAA2B,MAAkB,cAGpD;AACA,QAAM,SAAS,0BAA0B,YAAY;AACrD,QAAM,iBAAiB,OAAO,SAAS,KAAK,YAAY,UAAU,IAAI,KAAK,YAAY,aAAa;AACpG,QAAM,mBAAmB,OAAO,SAAS,cAAc,YAAY,UAAU,IACzE,aAAc,YAAY,aAC1B;AACJ,QAAM,qBAAqB,KAAK,IAAI,gBAAgB,gBAAgB;AACpE,QAAM,sBAAsB,KAAK;AAAA,IAC/B;AAAA,IACA,KAAK,IAAI,GAAG,qBAAqB,iCAAiC,MAAM,CAAC;AAAA,EAC3E;AACA,SAAO,EAAE,QAAQ,oBAAoB;AACvC;AAEA,SAAS,mCACP,MACA,cACA,aACA,qBAC+C;AAC/C,QAAM,gBAAgB,oBAAI,IAAY;AACtC,MAAI,QAAQ;AAEZ,QAAM,qBAAqB,wBAAwB,aAAa,KAAK,OAAO;AAC5E,MAAI,qBAAqB,GAAG;AAC1B,aAAS,qBAAqB;AAC9B,kBAAc,IAAI,aAAa;AAAA,EACjC;AAEA,QAAM,aAAa,wBAAwB,aAAa,KAAK,YAAY,MAAM,KAAK,GAAG,CAAC;AACxF,MAAI,aAAa,GAAG;AAClB,aAAS,aAAa;AACtB,kBAAc,IAAI,MAAM;AAAA,EAC1B;AAEA,QAAM,uBAAuB,wBAAwB,aAAa,cAAc,OAAO;AACvF,MAAI,uBAAuB,GAAG;AAC5B,aAAS,uBAAuB;AAChC,kBAAc,IAAI,eAAe;AAAA,EACnC;AAEA,MAAI,QAAQ,GAAG;AACb,aAAS;AAAA,EACX;AAEA,SAAO,EAAE,OAAO,cAAc;AAChC;AAEA,eAAsB,4BAA4B,SAKR;AACxC,QAAM,cAAc,IAAI,IAAI,sBAAsB,QAAQ,OAAO,CAAC,QAAQ,OAAO,CAAC,CAAC;AACnF,MAAI,YAAY,SAAS,KAAK,QAAQ,cAAc,EAAG,QAAO,CAAC;AAE/D,QAAM,UAAU,IAAI,eAAe,QAAQ,SAAS;AACpD,QAAM,UAAU,QAAQ,uBAAuB;AAG/C,MAAI,cAAc,sBAAsB,QAAQ,KAAK,OAAO;AAC5D,MAAI,CAAC,aAAa;AAChB,UAAM,UAAU,MAAM,QAAQ,gBAAgB;AAC9C,kBAAc,sBAAsB,QAAQ,KAAK,SAAS,OAAO;AAAA,EACnE;AACA,QAAM,EAAE,KAAK,cAAc,MAAM,WAAW,IAAI;AAChD,QAAM,yBAAyB,QAAQ,0BAA0B;AAEjE,QAAM,aAA2C,CAAC;AAElD,aAAW,UAAU,cAAc;AACjC,QAAI,OAAO,YAAY,WAAW,0BAA2B;AAC7D,UAAM,iBAAiB,OAAO,YAAY;AAC1C,QAAI,CAAC,eAAgB;AAErB,UAAM,eAAe,WAAW,IAAI,cAAc;AAClD,UAAM,EAAE,QAAQ,oBAAoB,IAAI,2BAA2B,QAAQ,YAAY;AACvF,QAAI,sBAAsB,uBAAwB;AAElD,UAAM,EAAE,OAAO,cAAc,IAAI;AAAA,MAC/B;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,QAAI,SAAS,EAAG;AAEhB,eAAW,KAAK;AAAA,MACd,MAAM;AAAA,MACN;AAAA,MACA;AAAA,MACA,oBAAoB;AAAA,MACpB;AAAA,MACA,eAAe,CAAC,GAAG,aAAa,EAAE,KAAK;AAAA,IACzC,CAAC;AAAA,EACH;AAEA,SAAO,WACJ;AAAA,IACC,CAAC,MAAM,UACL,MAAM,QAAQ,KAAK,SAChB,MAAM,sBAAsB,KAAK,uBACjC,MAAM,KAAK,YAAY,QAAQ,cAAc,KAAK,KAAK,YAAY,OAAO;AAAA,EACjF,EACC,MAAM,GAAG,QAAQ,UAAU;AAChC;","names":[]}