@remnic/core 9.3.651 → 9.3.652

package/src/qmd.test.ts

@@ -183,6 +183,108 @@ test("QmdClient preserves configured qmdPath diagnostics when all probes fail",
   }
 });
 
+test("QmdClient read-only availability failures preserve operational state", async () => {
+  const { QmdClient } = await import("./qmd.js");
+  const originalPath = process.env.PATH;
+  const originalWindowsPath = process.env.Path;
+  const missingQmdPath = path.join(
+    os.tmpdir(),
+    `remnic-missing-readonly-qmd-${process.pid}-${Date.now()}`,
+    "qmd.cmd",
+  );
+
+  process.env.PATH = "";
+  process.env.Path = "";
+  try {
+    const client = new QmdClient("test-collection", 10, {
+      qmdPath: missingQmdPath,
+      qmdFallbackPaths: [],
+    });
+    (client as any).available = true;
+    (client as any).qmdPath = "qmd";
+    (client as any).qmdPathSource = "auto-path";
+    (client as any).cliVersion = "qmd 2.5.3";
+    (client as any).qmdCapabilities = resolveQmdCapabilities("qmd 2.5.3");
+    (client as any).lastCliProbeError = null;
+
+    assert.equal(await client.checkAvailability(), false);
+
+    assert.equal(client.isAvailable(), true);
+    assert.equal((client as any).qmdPath, "qmd");
+    assert.equal((client as any).qmdPathSource, "auto-path");
+    assert.equal((client as any).cliVersion, "qmd 2.5.3");
+    assert.equal((client as any).lastCliProbeError, null);
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+    if (originalWindowsPath === undefined) delete process.env.Path;
+    else process.env.Path = originalWindowsPath;
+  }
+});
+
+test("QmdClient read-only availability preserves live daemon availability", async () => {
+  const { QmdClient } = await import("./qmd.js");
+  const originalPath = process.env.PATH;
+  const originalWindowsPath = process.env.Path;
+  const missingQmdPath = path.join(
+    os.tmpdir(),
+    `remnic-missing-daemon-qmd-${process.pid}-${Date.now()}`,
+    "qmd.cmd",
+  );
+
+  process.env.PATH = "";
+  process.env.Path = "";
+  try {
+    const client = new QmdClient("test-collection", 10, {
+      qmdPath: missingQmdPath,
+      qmdFallbackPaths: [],
+    });
+    (client as any).daemonAvailable = true;
+    (client as any).daemonSession = { isActive: () => true };
+
+    assert.equal(await client.checkAvailability(), true);
+    assert.equal(client.isAvailable(), true);
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+    if (originalWindowsPath === undefined) delete process.env.Path;
+    else process.env.Path = originalWindowsPath;
+  }
+});
+
+test("QmdClient read-only availability clears stale daemon availability", async () => {
+  const { QmdClient } = await import("./qmd.js");
+  const originalPath = process.env.PATH;
+  const originalWindowsPath = process.env.Path;
+  const missingQmdPath = path.join(
+    os.tmpdir(),
+    `remnic-missing-stale-daemon-qmd-${process.pid}-${Date.now()}`,
+    "qmd.cmd",
+  );
+
+  process.env.PATH = "";
+  process.env.Path = "";
+  try {
+    const client = new QmdClient("test-collection", 10, {
+      qmdPath: missingQmdPath,
+      qmdFallbackPaths: [],
+    });
+    (client as any).daemonAvailable = true;
+    (client as any).daemonSession = { isActive: () => false };
+    (client as any).lastDaemonCheckAtMs = Date.now();
+
+    assert.equal(await client.checkAvailability(), false);
+    assert.equal(client.isAvailable(), false);
+    assert.equal((client as any).daemonAvailable, false);
+    assert.equal((client as any).lastDaemonCheckAtMs, 0);
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+    if (originalWindowsPath === undefined) delete process.env.Path;
+    else process.env.Path = originalWindowsPath;
+  }
+});
+
 test("QmdClient applies chunk strategy to normal and forced embed args", async () => {
   const { QmdClient } = await import("./qmd.js");
   const client = new QmdClient("test", 5, {

package/src/qmd.ts

@@ -1362,6 +1362,22 @@ export class QmdClient implements SearchBackend {
     return cliOk || this.daemonAvailable;
   }
 
+  async checkAvailability(execution?: SearchExecutionOptions): Promise<boolean> {
+    const cliAvailable = await this.probeCli({
+      allowAutoUpgrade: false,
+      preserveStateOnFailure: true,
+      signal: execution?.signal,
+    });
+    if (this.daemonAvailable && this.daemonSession?.isActive()) {
+      return true;
+    }
+    if (this.daemonAvailable) {
+      this.daemonAvailable = false;
+      this.lastDaemonCheckAtMs = 0;
+    }
+    return cliAvailable;
+  }
+
   private async probeDaemon(): Promise<boolean> {
     this.lastDaemonCheckAtMs = Date.now();
     const normalizedPath = this.qmdPath.trim() || "qmd";
@@ -1409,7 +1425,32 @@ export class QmdClient implements SearchBackend {
     }
   }
 
-  private async probeCli(): Promise<boolean> {
+  private async probeCli(
+    options: {
+      allowAutoUpgrade?: boolean;
+      preserveStateOnFailure?: boolean;
+      signal?: AbortSignal;
+    } = {},
+  ): Promise<boolean> {
+    const priorState = options.preserveStateOnFailure === true
+      ? {
+        available: this.available,
+        qmdPath: this.qmdPath,
+        qmdPathSource: this.qmdPathSource,
+        cliVersion: this.cliVersion,
+        lastCliProbeError: this.lastCliProbeError,
+        qmdCapabilities: this.qmdCapabilities,
+      }
+      : null;
+    const restorePriorState = (): void => {
+      if (!priorState) return;
+      this.available = priorState.available;
+      this.qmdPath = priorState.qmdPath;
+      this.qmdPathSource = priorState.qmdPathSource;
+      this.cliVersion = priorState.cliVersion;
+      this.lastCliProbeError = priorState.lastCliProbeError;
+      this.qmdCapabilities = priorState.qmdCapabilities;
+    };
     let configuredProbeFailure: string | null = null;
     const markProbeFailure = (err: unknown): void => {
       this.lastCliProbeError = err instanceof Error ? err.message : String(err);
@@ -1431,12 +1472,14 @@ export class QmdClient implements SearchBackend {
       this.cliVersion = parseQmdVersionOutput(result.stdout, result.stderr);
       this.qmdCapabilities = resolveQmdCapabilities(this.cliVersion);
       this.lastCliProbeError = null;
-      await this.maybeAutoUpgradeQmd();
+      if (options.allowAutoUpgrade !== false) {
+        await this.maybeAutoUpgradeQmd();
+      }
     };
 
     if (this.configuredQmdPath) {
       try {
-        const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, this.configuredQmdPath, undefined, this.qmdRuntimeEnv);
+        const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, this.configuredQmdPath, options.signal, this.qmdRuntimeEnv);
         await recordProbeSuccess(result, this.configuredQmdPath, "configured");
         return true;
       } catch (err) {
@@ -1452,7 +1495,7 @@ export class QmdClient implements SearchBackend {
 
     // Try PATH first
     try {
-      const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, "qmd", undefined, this.qmdRuntimeEnv);
+      const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, "qmd", options.signal, this.qmdRuntimeEnv);
       await recordProbeSuccess(result, "qmd", "auto-path");
       return true;
     } catch (err) {
@@ -1460,7 +1503,7 @@ export class QmdClient implements SearchBackend {
       // Try fallback paths
       for (const fallbackPath of this.qmdFallbackPaths) {
         try {
-          const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, fallbackPath, undefined, this.qmdRuntimeEnv);
+          const result = await runQmd(["--version"], QMD_PROBE_TIMEOUT_MS, fallbackPath, options.signal, this.qmdRuntimeEnv);
           await recordProbeSuccess(result, fallbackPath, "auto-fallback");
           log.info(`QMD: found at ${fallbackPath}`);
           return true;
@@ -1469,8 +1512,12 @@ export class QmdClient implements SearchBackend {
           // Continue to next fallback
         }
       }
-      this.available = false;
-      restoreConfiguredProbeFailure();
+      if (priorState) {
+        restorePriorState();
+      } else {
+        this.available = false;
+        restoreConfiguredProbeFailure();
+      }
       return false;
     }
   }

package/src/search/port.ts

@@ -42,6 +42,12 @@ export function resolveEnsureCollectionArgs(
 export interface SearchBackend {
   // ── Lifecycle ──
   probe(): Promise<boolean>;
+  /**
+   * Optional non-mutating availability probe for health/readiness checks.
+   * Implementations must avoid auto-upgrades, collection creation, daemon
+   * startup, or any other runtime-modifying side effects.
+   */
+  checkAvailability?(execution?: SearchExecutionOptions): Promise<boolean>;
   isAvailable(): boolean;
   debugStatus(): string;
 

package/dist/chunk-4PTKFBST.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\ntype CollectionState = \"present\" | \"missing\" | \"unknown\" | \"skipped\";\n\ntype NamespaceScopedSearchConfig = PluginConfig & {\n  hostEmbeddingProviderScope?: string;\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  /** 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 = (async (): Promise<NamespaceBackendRecord> => {\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      const available = await backend.probe().catch(() => false);\n      const collectionState = available\n        ? await this.collectionStateForBackend(backend, storage.dir, scopedConfig.qmdCollection, {\n          skipAutoCreate: filtersNestedNamespaces,\n          execution,\n        })\n        : \"unknown\";\n      return {\n        backend,\n        collection: scopedConfig.qmdCollection,\n        memoryDir: storage.dir,\n        available,\n        collectionState,\n        filtersNestedNamespaces,\n      };\n    })();\n\n    this.cache.set(key, pending);\n    return await pending;\n  }\n\n  private async collectionStateForBackend(\n    backend: SearchBackend,\n    memoryDir: string,\n    collection: string,\n    options: {\n      skipAutoCreate: boolean;\n      execution?: SearchExecutionOptions;\n    },\n  ): Promise<CollectionState> {\n    if (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 collectionState === \"missing\" ? \"unknown\" : collectionState;\n    }\n    return await backend.ensureCollection(memoryDir, collection, options.execution).catch(() => \"unknown\" as const);\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 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":";;;;;;;;;AAAA,OAAO,UAAU;AAUjB,IAAM,2CAA2C;AACjD,IAAM,wCAAwC;AAEvC,SAAS,wBACd,gBACA,WACA,SAIQ;AACR,QAAM,UAAU,2BAA2B,SAAS;AACpD,QAAM,mBAAmB,2BAA2B,SAAS,oBAAoB,EAAE,KAAK;AACxF,MACE,SAAS,+BAA+B,QACxC,YAAY,kBACZ;AACA,WAAO;AAAA,EACT;AAEA,SAAO,GAAG,cAAc,KAAK,uBAAuB,WAAW,gBAAgB,CAAC;AAClF;AAqBO,IAAM,wBAAN,MAA4B;AAAA,EAGjC,YACmB,QACA,eACA,gBAAyD,qBAC1E;AAHiB;AACA;AACA;AAAA,EAChB;AAAA,EAHgB;AAAA,EACA;AAAA,EACA;AAAA,EALF,QAAQ,oBAAI,IAA6C;AAAA,EAQ1E,MAAM,uBAAuB,WAAoC;AAC/D,YAAQ,MAAM,KAAK,iBAAiB,SAAS,GAAG;AAAA,EAClD;AAAA,EAEA,MAAM,uBAAuB,SAOE;AAC7B,UAAM,QAAQ,QAAQ,MAAM,KAAK;AACjC,QAAI,CAAC,MAAO,QAAO,CAAC;AACpB,UAAM,aAAa,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,cAAc,KAAK,OAAO,aAAa,CAAC;AAC1F,QAAI,eAAe,EAAG,QAAO,CAAC;AAE9B,UAAM,SAAS,QAAQ,QAAQ;AAC/B,UAAM,aAAa,MAAM,KAAK,IAAI,IAAI,QAAQ,WAAW,IAAI,CAAC,UAAU,MAAM,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,CAAC;AACtG,QAAI,WAAW,WAAW,EAAG,QAAO,CAAC;AAErC,UAAM,qBAAqB,MAAM,QAAQ;AAAA,MACvC,WAAW,IAAI,OAAO,cAAc;AAClC,cAAM,SAAS,MAAM,KAAK,iBAAiB,SAAS;AACpD,YAAI,CAAC,OAAO,aAAa,OAAO,oBAAoB,WAAW;AAC7D,iBAAO,EAAE,WAAW,SAAS,CAAC,EAAuB;AAAA,QACvD;AACA,cAAM,eAAe,mBAAmB,QAAQ,UAAU;AAC1D,YAAI;AACJ,gBAAQ,QAAQ;AAAA,UACd,KAAK;AACH,sBAAU,MAAM,OAAO,QAAQ;AAAA,cAC7B;AAAA,cACA,OAAO;AAAA,cACP;AAAA,cACA,QAAQ;AAAA,YACV;AACA;AAAA,UACF,KAAK;AACH,sBAAU,MAAM,OAAO,QAAQ;AAAA,cAC7B;AAAA,cACA,OAAO;AAAA,cACP;AAAA,cACA,QAAQ;AAAA,YACV;AACA;AAAA,UACF,KAAK;AACH,sBAAU,MAAM,OAAO,QAAQ;AAAA,cAC7B;AAAA,cACA,OAAO;AAAA,cACP;AAAA,cACA,QAAQ;AAAA,YACV;AACA;AAAA,UACF;AACE,sBAAU,MAAM,OAAO,QAAQ;AAAA,cAC7B;AAAA,cACA,OAAO;AAAA,cACP;AAAA,cACA,QAAQ;AAAA,cACR,QAAQ;AAAA,YACV;AACA;AAAA,QACJ;AACA,kBAAU,8BAA8B,QAAQ,OAAO;AACvD,eAAO,EAAE,WAAW,QAAQ;AAAA,MAC9B,CAAC;AAAA,IACH;AAEA,WAAO,4BAA4B,oBAAoB,UAAU;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,iBACJ,YACA,WACiB;AACjB,UAAM,SAAS,MAAM,KAAK,IAAI,IAAI,WAAW,IAAI,CAAC,UAAU,MAAM,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,CAAC;AAC1F,UAAM,YAAY,MAAM,QAAQ;AAAA,MAC9B,OAAO,IAAI,OAAO,cAAc;AAC9B,cAAM,SAAS,MAAM,KAAK,iBAAiB,SAAS;AACpD,eAAO,OAAO,aAAa,OAAO,oBAAoB,YAClD,SACA;AAAA,MACN,CAAC;AAAA,IACH,GAAG,OAAO,CAAC,WAA6C,WAAW,IAAI;AAEvE,UAAM,eAAe,SAAS,KAAK,CAAC,WAAW,OAAO,QAAQ,wBAAwB,MAAM,IAAI;AAChG,UAAM,gBAAgB,eAClB,SAAS,OAAO,CAAC,WAAW,OAAO,QAAQ,wBAAwB,MAAM,IAAI,IAC7E;AAEJ,UAAM,QAAQ,IAAI;AAAA,MAChB,eAAe,aAAa,QAAQ,OAAO,SAAS,IAAI,QAAQ,QAAQ;AAAA,MACxE,GAAG,cAAc,IAAI,CAAC,WAAW,OAAO,QAAQ,OAAO,SAAS,CAAC;AAAA,IACnE,CAAC;AAED,YAAQ,eAAe,IAAI,KAAK,cAAc;AAAA,EAChD;AAAA,EAEA,MAAM,gBAAgB,YAAqC;AACzD,UAAM,SAAS,MAAM,KAAK,IAAI,IAAI,WAAW,IAAI,CAAC,UAAU,MAAM,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,CAAC;AAC1F,UAAM,QAAQ;AAAA,MACZ,OAAO,IAAI,OAAO,cAAc;AAC9B,cAAM,SAAS,MAAM,KAAK,iBAAiB,SAAS;AACpD,YAAI,CAAC,OAAO,aAAa,OAAO,oBAAoB,UAAW;AAC/D,cAAM,OAAO,QAAQ,MAAM;AAAA,MAC7B,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,MAAM,0BACJ,WACA,WACwD;AACxD,UAAM,SAAS,MAAM,KAAK,iBAAiB,WAAW,SAAS;AAC/D,WAAO,OAAO;AAAA,EAChB;AAAA;AAAA,EAGA,aAAmB;AACjB,SAAK,MAAM,MAAM;AAAA,EACnB;AAAA;AAAA,EAGA,MAAM,UAAyB;AAC7B,UAAM,iBAAiB,MAAM,KAAK,KAAK,MAAM,OAAO,CAAC;AACrD,SAAK,MAAM,MAAM;AACjB,UAAM,UAAU,MAAM,QAAQ,WAAW,cAAc;AACvD,UAAM,QAAQ;AAAA,MACZ,QAAQ,QAAQ,CAAC,UAAU;AACzB,YAAI,MAAM,WAAW,YAAa,QAAO,CAAC;AAC1C,cAAM,UAAW,MAAM,MAAM,QAAqD;AAClF,eAAO,UAAU,CAAC,QAAQ,KAAK,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC;AAAA,MAC1D,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,MAAc,iBACZ,WACA,WACiC;AACjC,UAAM,MAAM,UAAU,KAAK,KAAK,KAAK,OAAO;AAC5C,UAAM,WAAW,KAAK,MAAM,IAAI,GAAG;AACnC,QAAI,SAAU,QAAO,MAAM;AAE3B,UAAM,WAAW,YAA6C;AAC5D,YAAM,UAAU,MAAM,KAAK,cAAc,WAAW,GAAG;AACvD,YAAM,6BACJ,QAAQ,KAAK,OAAO,oBAAoB,QAAQ,QAAQ,KAAK,OAAO;AACtE,YAAM,0BACJ,KAAK,OAAO,sBAAsB,QAAQ;AAC5C,YAAM,yBACH,KAAK,OAAuC,8BAC7C,KAAK,OAAO;AACd,YAAM,eAA4C;AAAA,QAChD,GAAG,KAAK;AAAA,QACR,WAAW,QAAQ;AAAA,QACnB,4BAA4B;AAAA,QAC5B,eAAe,wBAAwB,KAAK,OAAO,eAAe,KAAK;AAAA,UACrE,kBAAkB,KAAK,OAAO;AAAA,UAC9B;AAAA,QACF,CAAC;AAAA,MACH;AAEA,YAAM,UAAU,KAAK,cAAc,YAAY;AAC/C,YAAM,YAAY,MAAM,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAK;AACzD,YAAM,kBAAkB,YACpB,MAAM,KAAK,0BAA0B,SAAS,QAAQ,KAAK,aAAa,eAAe;AAAA,QACvF,gBAAgB;AAAA,QAChB;AAAA,MACF,CAAC,IACC;AACJ,aAAO;AAAA,QACL;AAAA,QACA,YAAY,aAAa;AAAA,QACzB,WAAW,QAAQ;AAAA,QACnB;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,GAAG;AAEH,SAAK,MAAM,IAAI,KAAK,OAAO;AAC3B,WAAO,MAAM;AAAA,EACf;AAAA,EAEA,MAAc,0BACZ,SACA,WACA,YACA,SAI0B;AAC1B,QAAI,QAAQ,gBAAgB;AAC1B,UAAI,CAAC,QAAQ,gBAAiB,QAAO;AACrC,YAAM,kBAAkB,MAAM,QAC3B,gBAAgB,YAAY,QAAQ,SAAS,EAC7C,MAAM,MAAM,SAAkB;AACjC,aAAO,oBAAoB,YAAY,YAAY;AAAA,IACrD;AACA,WAAO,MAAM,QAAQ,iBAAiB,WAAW,YAAY,QAAQ,SAAS,EAAE,MAAM,MAAM,SAAkB;AAAA,EAChH;AACF;AAEA,SAAS,8BACP,QACA,SACmB;AACnB,MAAI,CAAC,OAAO,wBAAyB,QAAO;AAC5C,SAAO,QAAQ;AAAA,IAAO,CAAC,WACrB,CAAC,6BAA6B,OAAO,WAAW,OAAO,YAAY,OAAO,IAAI;AAAA,EAChF;AACF;AAEA,SAAS,mBACP,QACA,YACQ;AACR,MAAI,CAAC,OAAO,wBAAyB,QAAO;AAC5C,SAAO,KAAK;AAAA,IACV;AAAA,IACA,aAAa;AAAA,IACb;AAAA,EACF;AACF;AAEA,SAAS,6BACP,WACA,YACA,YACS;AACT,MAAI,CAAC,WAAY,QAAO;AACxB,QAAM,uBAAuB,uBAAuB,YAAY,UAAU;AAC1E,QAAM,aAAa,KAAK,QAAQ,SAAS;AACzC,QAAM,iBAAiB,KAAK,KAAK,YAAY,YAAY;AACzD,QAAM,YAAY,KAAK,WAAW,oBAAoB,IAClD,KAAK,UAAU,oBAAoB,IACnC,KAAK,QAAQ,YAAY,oBAAoB;AACjD,QAAM,WAAW,KAAK,SAAS,gBAAgB,SAAS;AACxD,SAAO,aAAa,MAAO,CAAC,SAAS,WAAW,IAAI,KAAK,CAAC,KAAK,WAAW,QAAQ;AACpF;AAEA,SAAS,uBAAuB,YAAoB,YAA4B;AAC9E,MAAI,QAAQ,WAAW,KAAK;AAC5B,MAAI,MAAM,WAAW,QAAQ,GAAG;AAC9B,QAAI;AACF,YAAM,SAAS,IAAI,IAAI,KAAK;AAC5B,UAAI,OAAO,aAAa,UAAU,OAAO,aAAa,YAAY;AAChE,gBAAQ,mBAAmB,OAAO,SAAS,QAAQ,QAAQ,EAAE,CAAC;AAAA,MAChE;AAAA,IACF,QAAQ;AACN,YAAM,YAAY,MAAM,MAAM,SAAS,MAAM;AAC7C,YAAM,aAAa,UAAU,QAAQ,GAAG;AACxC,UAAI,eAAe,IAAI;AACrB,gBAAQ,UAAU,MAAM,aAAa,CAAC;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AAEA,QAAM,mBAAmB,GAAG,UAAU;AACtC,MAAI,MAAM,WAAW,gBAAgB,GAAG;AACtC,YAAQ,MAAM,MAAM,iBAAiB,MAAM;AAAA,EAC7C;AACA,SAAO;AACT;AAEA,SAAS,4BACP,OACA,YACmB;AACnB,QAAM,SAAS,oBAAI,IAA6B;AAEhD,aAAW,EAAE,WAAW,QAAQ,KAAK,OAAO;AAC1C,eAAW,UAAU,SAAS;AAC5B,YAAM,MAAM,GAAG,SAAS,KAAK,OAAO,QAAQ,OAAO,KAAK;AACxD,YAAM,WAAW,OAAO,IAAI,GAAG;AAC/B,UAAI,CAAC,UAAU;AACb,eAAO,IAAI,KAAK,MAAM;AACtB;AAAA,MACF;AACA,UAAI,OAAO,QAAQ,SAAS,OAAO;AACjC,eAAO,IAAI,KAAK;AAAA,UACd,GAAG;AAAA,UACH,SAAS,SAAS,WAAW,OAAO,WAAW;AAAA,QACjD,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAEA,SAAO,CAAC,GAAG,OAAO,OAAO,CAAC,EACvB,KAAK,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK,EAChC,MAAM,GAAG,UAAU;AACxB;","names":[]}