@remnic/core 10.0.14 → 10.0.15

package/src/storage/supersession-audit.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { stripAttributesSuffix } from "../structured-attributes.js";
 import type { MemoryFile } from "../types.js";
 import { isErrnoCode } from "../utils/errno.js";
+import { isMacOsReplicationJunkBasename } from "../utils/macos-replication-junk.js";
 
 export interface SupersessionAuditLookup {
   correctionsDir: string;
@@ -27,6 +28,7 @@ export async function hasSupersessionAudit(
   }
 
   for (const entry of entries) {
+    if (isMacOsReplicationJunkBasename(entry.name)) continue;
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
     const memory = await lookup.readMemoryByPath(path.join(lookup.correctionsDir, entry.name));
     if (

package/src/storage.ts

@@ -65,6 +65,7 @@ import { readEntityAliasConfigSync } from "./storage/entity-alias-config.js";
 import { assertSafeEntityId } from "./storage/entity-id-safety.js";
 export { normalizeEntityName } from "./entity-id-normalization.js";
 import { isErrnoCode } from "./utils/errno.js";
+import { isMacOsReplicationJunkBasename } from "./utils/macos-replication-junk.js";
 import { getCategoryDir, categoryDirName } from "./utils/category-dir.js";
 import { decodeYamlScalar } from "./utils/yaml-scalar.js";
 import { qmdCollectionPathParts, qmdResultPathCandidates } from "./orchestration/qmd-result-resolver.js";
@@ -4882,7 +4883,7 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
 
     const readDir = async (dir: string) => {
       try {
-        const entries = await readdir(dir, { withFileTypes: true });
+        const entries = (await readdir(dir, { withFileTypes: true })).filter((e) => !isMacOsReplicationJunkBasename(e.name));
         for (const entry of entries) {
           checkCorpusReadAbort(options);
           const fullPath = path.join(dir, entry.name);
@@ -7133,7 +7134,7 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
       const summaries: MemorySummary[] = [];
 
       for (const file of files) {
-        if (!file.endsWith(".json")) continue;
+        if (isMacOsReplicationJunkBasename(file) || !file.endsWith(".json")) continue;
         const filePath = path.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw) as MemorySummary);

package/src/transcript.ts

@@ -6,6 +6,7 @@ import { analyzeSessionIntegrity, type SessionIntegrityReport } from "./session-
 import { isDailyFileDatedBefore, resolveSafeStoragePath } from "./storage-paths.js";
 import { sessionStoragePaths } from "./session-identity.js";
 import { estimateTokenCount } from "./token-estimate.js";
+import { isMacOsReplicationJunkBasename } from "./utils/macos-replication-junk.js";
 
 type DirectorySessionStatus = "missing" | "empty" | "matches" | "occupied";
 type DirectoryOwnershipCacheEntry = {
@@ -166,7 +167,7 @@ export class TranscriptManager {
         for (const idEnt of idEntries) {
           if (!idEnt.isDirectory()) continue;
           const chanDir = path.join(typeDir, idEnt.name);
-          const files = (await readdir(chanDir)).filter((f) => f.endsWith(".jsonl")).sort();
+          const files = (await readdir(chanDir)).filter((f) => f.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(f)).sort();
           const last = files[files.length - 1];
           if (!last) continue;
           try {
@@ -261,7 +262,7 @@ export class TranscriptManager {
 
     let names: string[];
     try {
-      names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl"));
+      names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(file));
     } catch {
       return "occupied";
     }
@@ -345,7 +346,7 @@ export class TranscriptManager {
   ): Promise<void> {
     try {
       const channelDir = await resolveSafeStoragePath(root, dir);
-      const names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl"));
+      const names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(file));
       const fileSizes = await this.directoryJsonlFileSizes(root, dir, names);
       if (!fileSizes) return;
       this.directoryOwnershipCache.set(
@@ -380,7 +381,7 @@ export class TranscriptManager {
 
       let names: string[];
       try {
-        names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl")).sort();
+        names = (await readdir(channelDir)).filter((file) => file.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(file)).sort();
       } catch {
         continue;
       }
@@ -641,14 +642,14 @@ export class TranscriptManager {
                 try {
                   const channelFiles = await readdir(channelDir);
                   for (const file of channelFiles) {
-                    if (file.endsWith(".jsonl")) {
+                    if (file.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(file)) {
                       files.push(path.join(entry.name, channelTypeEntry.name, file));
                     }
                   }
                 } catch {
                   // Skip unreadable directories
                 }
-              } else if (channelTypeEntry.isFile() && channelTypeEntry.name.endsWith(".jsonl")) {
+              } else if (channelTypeEntry.isFile() && channelTypeEntry.name.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(channelTypeEntry.name)) {
                 // Legacy: channel type dir contains .jsonl files directly
                 files.push(path.join(entry.name, channelTypeEntry.name));
               }
@@ -656,7 +657,7 @@ export class TranscriptManager {
           } catch {
             // Skip unreadable directories
           }
-        } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        } else if (entry.isFile() && entry.name.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(entry.name)) {
           // Legacy flat file - still include for backward compatibility
           files.push(entry.name);
         }
@@ -865,7 +866,7 @@ export class TranscriptManager {
                 try {
                   const channelFiles = await readdir(channelDir);
                   for (const file of channelFiles) {
-                    if (!file.endsWith(".jsonl")) continue;
+                    if (isMacOsReplicationJunkBasename(file) || !file.endsWith(".jsonl")) continue;
 
                     const filePath = path.join(channelDir, file);
 
@@ -894,7 +895,7 @@ export class TranscriptManager {
                 } catch (err) {
                   log.debug(`failed to process channel directory ${entry.name}/${channelTypeEntry.name}:`, err);
                 }
-              } else if (channelTypeEntry.isFile() && channelTypeEntry.name.endsWith(".jsonl")) {
+              } else if (channelTypeEntry.isFile() && channelTypeEntry.name.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(channelTypeEntry.name)) {
                 // Legacy: channel type dir contains .jsonl files directly
                 const filePath = path.join(channelTypeDir, channelTypeEntry.name);
                 const cleaned = await this.cleanupTranscriptFile(filePath, cutoff);
@@ -906,7 +907,7 @@ export class TranscriptManager {
           } catch (err) {
             log.debug(`failed to process channel type directory ${entry.name}:`, err);
           }
-        } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        } else if (entry.isFile() && entry.name.endsWith(".jsonl") && !isMacOsReplicationJunkBasename(entry.name)) {
           // Handle legacy flat files - delete if older than retentionDays
           if (this.isLegacyTranscriptFile(entry.name)) {
             const dateStr = entry.name.slice(0, 10);

package/src/utils/macos-replication-junk.test.ts

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  isMacOsReplicationJunkBasename,
+  isMacOsReplicationJunkRelativePath,
+  warnIgnoredMacOsReplicationJunk,
+  withoutMacOsReplicationJunk,
+} from "./macos-replication-junk.js";
+
+test("macOS replication junk is AppleDouble sidecars and .DS_Store only", () => {
+  assert.equal(isMacOsReplicationJunkBasename("._project-notes.md"), true);
+  assert.equal(isMacOsReplicationJunkBasename("._"), true);
+  assert.equal(isMacOsReplicationJunkBasename(".DS_Store"), true);
+  assert.equal(isMacOsReplicationJunkBasename("project-notes.md"), false);
+  assert.equal(isMacOsReplicationJunkBasename(".gitignore"), false);
+  assert.equal(isMacOsReplicationJunkBasename("DS_Store"), false);
+  assert.equal(isMacOsReplicationJunkRelativePath("namespaces/lab/entities/._project-notes.md"), true);
+  assert.equal(isMacOsReplicationJunkRelativePath("namespaces\\lab\\.DS_Store"), true);
+  assert.equal(isMacOsReplicationJunkRelativePath("entities/project-notes.md"), false);
+});
+
+test("withoutMacOsReplicationJunk keeps real names and counts junk once", () => {
+  const { kept, ignored } = withoutMacOsReplicationJunk(
+    ["project-notes.md", "._project-notes.md", ".DS_Store", "correction-1.md"],
+    (name) => name
+  );
+  assert.deepEqual(kept, ["project-notes.md", "correction-1.md"]);
+  assert.equal(ignored, 2);
+});
+
+test("warnIgnoredMacOsReplicationJunk emits one summary per directory and count", () => {
+  const messages: string[] = [];
+  const warn = (message: string) => {
+    messages.push(message);
+  };
+  const directory = `junk-warn-${process.pid}-${Date.now()}`;
+  warnIgnoredMacOsReplicationJunk(directory, 2, warn);
+  warnIgnoredMacOsReplicationJunk(directory, 2, warn);
+  warnIgnoredMacOsReplicationJunk(directory, 0, warn);
+  warnIgnoredMacOsReplicationJunk(directory, 3, warn);
+  assert.deepEqual(messages, [
+    "ignored 2 macOS replication junk file(s) (._* and .DS_Store)",
+    "ignored 3 macOS replication junk file(s) (._* and .DS_Store)",
+  ]);
+});

package/src/utils/macos-replication-junk.ts

@@ -0,0 +1,65 @@
+/**
+ * macOS Finder metadata that arrives through Mac-to-Linux copies.
+ *
+ * AppleDouble sidecars are named `._` plus the real file's basename
+ * (`._project-notes.md` beside `project-notes.md`). Finder also writes
+ * `.DS_Store` into any directory it opens. Neither is a Remnic record.
+ * Directory scanners and replication must ignore them so they are never
+ * parsed as entities, memories, or sync objects.
+ *
+ * QMD's own indexer already drops every hidden path (`dot: false` plus a
+ * hidden-segment filter). Callers that build index inputs themselves still
+ * use this helper so the non-QMD scanners stay in parity.
+ */
+
+const warnedJunkDirectories = new Set<string>();
+
+/** True for an AppleDouble sidecar or a Finder `.DS_Store` file. */
+export function isMacOsReplicationJunkBasename(basename: string): boolean {
+  return basename === ".DS_Store" || basename.startsWith("._");
+}
+
+/** True when the final path segment is macOS replication junk. */
+export function isMacOsReplicationJunkRelativePath(relPath: string): boolean {
+  const normalized = relPath.includes("\\") ? relPath.replaceAll("\\", "/") : relPath;
+  const slash = normalized.lastIndexOf("/");
+  const basename = slash === -1 ? normalized : normalized.slice(slash + 1);
+  return isMacOsReplicationJunkBasename(basename);
+}
+
+/**
+ * Drop junk names from a directory listing. `ignored` is the count of
+ * names removed, so the caller can emit one summary warning.
+ */
+export function withoutMacOsReplicationJunk<T>(
+  entries: readonly T[],
+  basenameOf: (entry: T) => string
+): { kept: T[]; ignored: number } {
+  const kept: T[] = [];
+  let ignored = 0;
+  for (const entry of entries) {
+    if (isMacOsReplicationJunkBasename(basenameOf(entry))) {
+      ignored += 1;
+      continue;
+    }
+    kept.push(entry);
+  }
+  return { kept, ignored };
+}
+
+/**
+ * Emit at most one junk warning per directory and count. A later scan of
+ * the same directory (entity migration, then entity load) stays quiet
+ * instead of repeating the same summary.
+ */
+export function warnIgnoredMacOsReplicationJunk(
+  directoryKey: string,
+  count: number,
+  warn: (message: string) => void
+): void {
+  if (count <= 0) return;
+  const key = `${directoryKey}\0${count}`;
+  if (warnedJunkDirectories.has(key)) return;
+  warnedJunkDirectories.add(key);
+  warn(`ignored ${count} macOS replication junk file(s) (._* and .DS_Store)`);
+}

package/src/utils/malformed-entity-record.ts

@@ -0,0 +1,101 @@
+/**
+ * Heading and type flags for an entity markdown body.
+ *
+ * The heading rule matches `parseEntityFile`: a line must start with `# `
+ * (hash, space) and the remainder must contain a name. A tab after `#`
+ * is not a heading. The type rule matches a `**Type:**` line with a
+ * non-empty value. A missing type line is still readable: the parser
+ * defaults the type to `other`.
+ */
+function entityRecordFlags(content: string): { hasName: boolean; hasType: boolean } {
+  const body = entityRecordBody(content);
+  let hasName = false;
+  let hasType = false;
+  let start = 0;
+  while (start <= body.length) {
+    const newline = body.indexOf("\n", start);
+    const end = newline === -1 ? body.length : newline;
+    let line = body.slice(start, end);
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    if (!hasName && line.startsWith("# ") && line.slice(2).trim().length > 0) hasName = true;
+    if (!hasType && line.startsWith("**Type:**") && line.slice("**Type:**".length).trim().length > 0) {
+      hasType = true;
+    }
+    if (hasName && hasType) return { hasName, hasType };
+    if (newline === -1) break;
+    start = newline + 1;
+  }
+  return { hasName, hasType };
+}
+
+/**
+ * No `# ` name. A named file whose type line is absent stays readable:
+ * `parseEntityFile` defaults the type to `other`.
+ */
+export function isUnnamedEntityRecord(content: string): boolean {
+  return !entityRecordFlags(content).hasName;
+}
+
+function entityBodyHasText(content: string): boolean {
+  const body = entityRecordBody(content);
+  for (let i = 0; i < body.length; i++) {
+    const char = body.charCodeAt(i);
+    if (char !== 32 && char !== 9 && char !== 10 && char !== 13) return true;
+  }
+  return false;
+}
+
+/**
+ * Unnamed entity body that still has text. An empty body under frontmatter
+ * stays readable so a canonical filename can supply the type. A tab heading,
+ * a blank `# ` heading, or prose with no name does not.
+ */
+export function isPopulatedUnnamedEntityRecord(content: string): boolean {
+  return isUnnamedEntityRecord(content) && entityBodyHasText(content);
+}
+
+/**
+ * Unnamed file that still looks like an entity record (`#` or `**Type:**`).
+ * Direct filename recall keeps unstructured placeholders such as "content".
+ */
+export function isShapedUnnamedEntityRecord(content: string): boolean {
+  if (!isUnnamedEntityRecord(content)) return false;
+  const body = entityRecordBody(content);
+  let start = 0;
+  while (start <= body.length) {
+    const newline = body.indexOf("\n", start);
+    const end = newline === -1 ? body.length : newline;
+    let line = body.slice(start, end);
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    if (line.startsWith("#") || line.startsWith("**Type:**")) return true;
+    if (newline === -1) break;
+    start = newline + 1;
+  }
+  return false;
+}
+
+/**
+ * Migration gate. Canonical ids are derived from name and type, and the
+ * old startup throw required an explicit `**Type:**` line. Files that
+ * only have a heading stay on disk and are not renamed. Listing does not
+ * use this predicate: `parseEntityFile` defaults a missing type to `other`.
+ */
+export function isMalformedEntityRecord(content: string): boolean {
+  const flags = entityRecordFlags(content);
+  return !flags.hasName || !flags.hasType;
+}
+
+function entityRecordBody(content: string): string {
+  const firstNewline = content.indexOf("\n");
+  if (firstNewline === -1) return content;
+  const firstLine = content.slice(0, firstNewline).endsWith("\r")
+    ? content.slice(0, firstNewline - 1)
+    : content.slice(0, firstNewline);
+  if (firstLine !== "---") return content;
+  const close = content.indexOf("\n---", firstNewline + 1);
+  if (close === -1) return content;
+  let rest = close + "\n---".length;
+  if (content.charAt(rest) === "\r") rest += 1;
+  if (content.charAt(rest) === "\n") rest += 1;
+  return content.slice(rest);
+}

package/dist/chunk-4O6WRBGE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/search/document-scanner.ts"],"sourcesContent":["import path from \"node:path\";\nimport { lstat, readdir, readFile, realpath } from \"node:fs/promises\";\nimport { RECALL_FALLBACK_DIRS } from \"../utils/category-dir.js\";\nimport { assertPathInsideRoot } from \"../utils/path-containment.js\";\nimport { isErrnoCode } from \"../utils/errno.js\";\n\nexport interface IndexableDocument {\n  /** Memory ID from frontmatter or filename stem */\n  docid: string;\n  /** Absolute file path */\n  path: string;\n  /** Markdown body (no YAML frontmatter) */\n  content: string;\n  /** First ~200 chars for display */\n  snippet: string;\n}\n\n/**\n * Parse YAML frontmatter from a markdown string.\n * Returns the frontmatter key-value pairs and body, or null if no frontmatter block.\n */\nfunction parseFrontmatter(raw: string): { data: Record<string, string>; body: string } | null {\n  // Support both LF and CRLF line endings\n  const normalized = raw.replace(/\\r\\n/g, \"\\n\");\n  const match = normalized.match(/^---\\n([\\s\\S]*?)\\n---\\n?([\\s\\S]*)$/);\n  if (!match) return null;\n\n  const fmBlock = match[1];\n  const body = (match[2] ?? \"\").trim();\n  const data: Record<string, string> = {};\n\n  for (const line of fmBlock.split(\"\\n\")) {\n    const colonIdx = line.indexOf(\":\");\n    if (colonIdx === -1) continue;\n    const key = line.slice(0, colonIdx).trim();\n    const value = line.slice(colonIdx + 1).trim();\n    data[key] = value;\n  }\n\n  return { data, body };\n}\n\n/**\n * Recursively scan a directory for `.md` files and return IndexableDocuments.\n */\nasync function scanDir(dir: string, memoryRootReal: string): Promise<IndexableDocument[]> {\n  const docs: IndexableDocument[] = [];\n  try {\n    const dirStat = await lstat(dir);\n    if (dirStat.isSymbolicLink()) {\n      throw new Error(`Refusing to scan symlinked memory category directory: ${dir}`);\n    }\n    if (!dirStat.isDirectory()) {\n      const error = new Error(`Memory category path is not a directory: ${dir}`) as NodeJS.ErrnoException;\n      error.code = \"ENOTDIR\";\n      throw error;\n    }\n    assertPathInsideRoot(memoryRootReal, await realpath(dir), dir);\n\n    const entries = await readdir(dir, { withFileTypes: true });\n    for (const entry of entries) {\n      if (entry.isSymbolicLink()) continue;\n      const fullPath = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);\n        const sub = await scanDir(fullPath, memoryRootReal);\n        docs.push(...sub);\n      } else if (entry.name.endsWith(\".md\")) {\n        try {\n          assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);\n          const raw = await readFile(fullPath, \"utf-8\");\n          const parsed = parseFrontmatter(raw);\n          const body = parsed ? parsed.body : raw.trim();\n          const docid = parsed?.data.id || path.basename(entry.name, \".md\");\n          docs.push({\n            docid,\n            path: fullPath,\n            content: body,\n            snippet: body.slice(0, 200),\n          });\n        } catch {\n          // Skip unreadable files\n        }\n      }\n    }\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) {\n      // Optional category directories may not exist yet.\n      return docs;\n    }\n    throw err;\n  }\n  return docs;\n}\n\n/**\n * Scan every recall category subdir of memoryDir for indexable markdown\n * documents. The directory set is derived from `RECALL_FALLBACK_DIRS`\n * (utils/category-dir.ts → ALL_CATEGORY_DIRS minus non-recall queue dirs) —\n * the single source of truth — so adding a new category never requires\n * touching this scanner. Non-QMD backends (Orama / Meilisearch / LanceDB)\n * build their index through this helper; deriving from RECALL_FALLBACK_DIRS\n * keeps them in parity with writeMemory's category-dir routing (issue #1546)\n * and the QMD filesystem-fallback corpus. reasoning-traces/ and the other\n * category dirs are covered automatically (issue #564 PR 3 no longer needs a\n * hand-maintained list). scanDir tolerates missing dirs (ENOENT), so category\n * dirs that do not exist yet are skipped.\n */\nexport async function scanMemoryDir(memoryDir: string): Promise<IndexableDocument[]> {\n  let memoryRootReal: string;\n  try {\n    memoryRootReal = await realpath(memoryDir);\n  } catch (err) {\n    if (isErrnoCode(err, \"ENOENT\")) {\n      return [];\n    }\n    throw err;\n  }\n  const perDir = await Promise.all(\n    RECALL_FALLBACK_DIRS.map((dir) => scanDir(path.join(memoryDir, dir), memoryRootReal)),\n  );\n  return perDir.flat();\n}\n"],"mappings":";;;;;;;;;;;AAAA,OAAO,UAAU;AACjB,SAAS,OAAO,SAAS,UAAU,gBAAgB;AAoBnD,SAAS,iBAAiB,KAAoE;AAE5F,QAAM,aAAa,IAAI,QAAQ,SAAS,IAAI;AAC5C,QAAM,QAAQ,WAAW,MAAM,oCAAoC;AACnE,MAAI,CAAC,MAAO,QAAO;AAEnB,QAAM,UAAU,MAAM,CAAC;AACvB,QAAM,QAAQ,MAAM,CAAC,KAAK,IAAI,KAAK;AACnC,QAAM,OAA+B,CAAC;AAEtC,aAAW,QAAQ,QAAQ,MAAM,IAAI,GAAG;AACtC,UAAM,WAAW,KAAK,QAAQ,GAAG;AACjC,QAAI,aAAa,GAAI;AACrB,UAAM,MAAM,KAAK,MAAM,GAAG,QAAQ,EAAE,KAAK;AACzC,UAAM,QAAQ,KAAK,MAAM,WAAW,CAAC,EAAE,KAAK;AAC5C,SAAK,GAAG,IAAI;AAAA,EACd;AAEA,SAAO,EAAE,MAAM,KAAK;AACtB;AAKA,eAAe,QAAQ,KAAa,gBAAsD;AACxF,QAAM,OAA4B,CAAC;AACnC,MAAI;AACF,UAAM,UAAU,MAAM,MAAM,GAAG;AAC/B,QAAI,QAAQ,eAAe,GAAG;AAC5B,YAAM,IAAI,MAAM,yDAAyD,GAAG,EAAE;AAAA,IAChF;AACA,QAAI,CAAC,QAAQ,YAAY,GAAG;AAC1B,YAAM,QAAQ,IAAI,MAAM,4CAA4C,GAAG,EAAE;AACzE,YAAM,OAAO;AACb,YAAM;AAAA,IACR;AACA,yBAAqB,gBAAgB,MAAM,SAAS,GAAG,GAAG,GAAG;AAE7D,UAAM,UAAU,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAC1D,eAAW,SAAS,SAAS;AAC3B,UAAI,MAAM,eAAe,EAAG;AAC5B,YAAM,WAAW,KAAK,KAAK,KAAK,MAAM,IAAI;AAC1C,UAAI,MAAM,YAAY,GAAG;AACvB,6BAAqB,gBAAgB,MAAM,SAAS,QAAQ,GAAG,QAAQ;AACvE,cAAM,MAAM,MAAM,QAAQ,UAAU,cAAc;AAClD,aAAK,KAAK,GAAG,GAAG;AAAA,MAClB,WAAW,MAAM,KAAK,SAAS,KAAK,GAAG;AACrC,YAAI;AACF,+BAAqB,gBAAgB,MAAM,SAAS,QAAQ,GAAG,QAAQ;AACvE,gBAAM,MAAM,MAAM,SAAS,UAAU,OAAO;AAC5C,gBAAM,SAAS,iBAAiB,GAAG;AACnC,gBAAM,OAAO,SAAS,OAAO,OAAO,IAAI,KAAK;AAC7C,gBAAM,QAAQ,QAAQ,KAAK,MAAM,KAAK,SAAS,MAAM,MAAM,KAAK;AAChE,eAAK,KAAK;AAAA,YACR;AAAA,YACA,MAAM;AAAA,YACN,SAAS;AAAA,YACT,SAAS,KAAK,MAAM,GAAG,GAAG;AAAA,UAC5B,CAAC;AAAA,QACH,QAAQ;AAAA,QAER;AAAA,MACF;AAAA,IACF;AAAA,EACF,SAAS,KAAK;AACZ,QAAI,YAAY,KAAK,QAAQ,GAAG;AAE9B,aAAO;AAAA,IACT;AACA,UAAM;AAAA,EACR;AACA,SAAO;AACT;AAeA,eAAsB,cAAc,WAAiD;AACnF,MAAI;AACJ,MAAI;AACF,qBAAiB,MAAM,SAAS,SAAS;AAAA,EAC3C,SAAS,KAAK;AACZ,QAAI,YAAY,KAAK,QAAQ,GAAG;AAC9B,aAAO,CAAC;AAAA,IACV;AACA,UAAM;AAAA,EACR;AACA,QAAM,SAAS,MAAM,QAAQ;AAAA,IAC3B,qBAAqB,IAAI,CAAC,QAAQ,QAAQ,KAAK,KAAK,WAAW,GAAG,GAAG,cAAc,CAAC;AAAA,EACtF;AACA,SAAO,OAAO,KAAK;AACrB;","names":[]}