synapse-db 0.0.0-stage → 0.2.3

package/dist/index.js

@@ -0,0 +1,942 @@
+// @bun
+// engine.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, unlinkSync as unlinkSync2, watch } from "fs";
+import { basename, join, resolve } from "path";
+
+// connectome.ts
+class SynapseConnectome {
+  documents = new Map;
+  collectionDocIds = new Map;
+  outgoingEdges = new Map;
+  incomingEdges = new Map;
+  edgeMeta = new Map;
+  tokenInvertedIndex = new Map;
+  documentTokens = new Map;
+  constructor() {}
+  static makeNodeId(collection, id) {
+    return `${collection}/${id}`;
+  }
+  clear() {
+    this.documents.clear();
+    this.collectionDocIds.clear();
+    this.outgoingEdges.clear();
+    this.incomingEdges.clear();
+    this.edgeMeta.clear();
+    this.tokenInvertedIndex.clear();
+    this.documentTokens.clear();
+  }
+  putDocument(doc) {
+    const nodeId = SynapseConnectome.makeNodeId(doc.collection, doc.id);
+    this.removeDocumentOwnedIndices(nodeId);
+    this.documents.set(nodeId, doc);
+    let colSet = this.collectionDocIds.get(doc.collection);
+    if (!colSet) {
+      colSet = new Set;
+      this.collectionDocIds.set(doc.collection, colSet);
+    }
+    colSet.add(doc.id);
+    for (const link of doc.wikilinks) {
+      const targetNodeId = SynapseConnectome.makeNodeId(link.targetCollection || doc.collection, link.targetId);
+      let outSet = this.outgoingEdges.get(nodeId);
+      if (!outSet) {
+        outSet = new Set;
+        this.outgoingEdges.set(nodeId, outSet);
+      }
+      outSet.add(targetNodeId);
+      let inSet = this.incomingEdges.get(targetNodeId);
+      if (!inSet) {
+        inSet = new Set;
+        this.incomingEdges.set(targetNodeId, inSet);
+      }
+      inSet.add(nodeId);
+      const edgeKey = `${nodeId}->${targetNodeId}`;
+      this.edgeMeta.set(edgeKey, {
+        fromNodeId: nodeId,
+        toNodeId: targetNodeId,
+        alias: link.alias
+      });
+    }
+    this.indexDocumentText(nodeId, doc);
+  }
+  removeDocument(collection, id) {
+    const nodeId = SynapseConnectome.makeNodeId(collection, id);
+    if (!this.documents.has(nodeId))
+      return false;
+    this.removeDocumentOwnedIndices(nodeId);
+    this.documents.delete(nodeId);
+    const colSet = this.collectionDocIds.get(collection);
+    if (colSet) {
+      colSet.delete(id);
+      if (colSet.size === 0) {
+        this.collectionDocIds.delete(collection);
+      }
+    }
+    return true;
+  }
+  removeDocumentOwnedIndices(nodeId) {
+    const outSet = this.outgoingEdges.get(nodeId);
+    if (outSet) {
+      for (const targetNodeId of outSet) {
+        const inSet = this.incomingEdges.get(targetNodeId);
+        if (inSet) {
+          inSet.delete(nodeId);
+          if (inSet.size === 0) {
+            this.incomingEdges.delete(targetNodeId);
+          }
+        }
+        this.edgeMeta.delete(`${nodeId}->${targetNodeId}`);
+      }
+      this.outgoingEdges.delete(nodeId);
+    }
+    const oldTokens = this.documentTokens.get(nodeId);
+    if (oldTokens) {
+      for (const token of oldTokens) {
+        const nodeSet = this.tokenInvertedIndex.get(token);
+        if (nodeSet) {
+          nodeSet.delete(nodeId);
+          if (nodeSet.size === 0) {
+            this.tokenInvertedIndex.delete(token);
+          }
+        }
+      }
+      this.documentTokens.delete(nodeId);
+    }
+  }
+  getDocument(collection, id) {
+    const nodeId = SynapseConnectome.makeNodeId(collection, id);
+    return this.documents.get(nodeId) || null;
+  }
+  getOutgoingDocuments(collection, id, targetCollectionFilter) {
+    const nodeId = SynapseConnectome.makeNodeId(collection, id);
+    const targetNodeIds = this.outgoingEdges.get(nodeId);
+    if (!targetNodeIds)
+      return [];
+    const results = [];
+    for (const tNodeId of targetNodeIds) {
+      if (targetCollectionFilter && !tNodeId.startsWith(`${targetCollectionFilter}/`)) {
+        continue;
+      }
+      const doc = this.documents.get(tNodeId);
+      if (doc)
+        results.push(doc);
+    }
+    return results;
+  }
+  getIncomingDocuments(collection, id, sourceCollectionFilter) {
+    const nodeId = SynapseConnectome.makeNodeId(collection, id);
+    const sourceNodeIds = this.incomingEdges.get(nodeId);
+    if (!sourceNodeIds)
+      return [];
+    const results = [];
+    for (const sNodeId of sourceNodeIds) {
+      if (sourceCollectionFilter && !sNodeId.startsWith(`${sourceCollectionFilter}/`)) {
+        continue;
+      }
+      const doc = this.documents.get(sNodeId);
+      if (doc)
+        results.push(doc);
+    }
+    return results;
+  }
+  verifyGraphInvariants() {
+    const brokenOutgoing = [];
+    const brokenIncoming = [];
+    const ghostTokens = [];
+    for (const [u, outTargets] of this.outgoingEdges) {
+      for (const v of outTargets) {
+        const inSources = this.incomingEdges.get(v);
+        if (!inSources || !inSources.has(u)) {
+          brokenOutgoing.push(`${u}->${v}`);
+        }
+      }
+    }
+    for (const [v, inSources] of this.incomingEdges) {
+      for (const u of inSources) {
+        const outTargets = this.outgoingEdges.get(u);
+        if (!outTargets || !outTargets.has(v)) {
+          brokenIncoming.push(`${u}->${v}`);
+        }
+      }
+    }
+    for (const [token, nodeSet] of this.tokenInvertedIndex) {
+      for (const nodeId of nodeSet) {
+        if (!this.documents.has(nodeId)) {
+          ghostTokens.push(`${token}@${nodeId}`);
+        }
+      }
+    }
+    return {
+      ok: brokenOutgoing.length === 0 && brokenIncoming.length === 0 && ghostTokens.length === 0,
+      brokenOutgoing,
+      brokenIncoming,
+      ghostTokens
+    };
+  }
+  getAllEdges() {
+    return Array.from(this.edgeMeta.values());
+  }
+  getAllDocuments() {
+    return Array.from(this.documents.values());
+  }
+  queryCollection(collection, options) {
+    const ids = this.collectionDocIds.get(collection);
+    if (!ids)
+      return [];
+    const docs = [];
+    for (const id of ids) {
+      const doc = this.documents.get(SynapseConnectome.makeNodeId(collection, id));
+      if (!doc)
+        continue;
+      if (options?.filter && !options.filter(doc))
+        continue;
+      docs.push(doc);
+    }
+    if (options?.sortBy) {
+      docs.sort(options.sortBy);
+    }
+    const offset = options?.offset || 0;
+    const limit = options?.limit !== undefined ? options.limit : docs.length;
+    return docs.slice(offset, offset + limit);
+  }
+  search(query, collectionFilter) {
+    const tokens = this.tokenize(query);
+    if (tokens.length === 0)
+      return [];
+    const scoreMap = new Map;
+    for (const token of tokens) {
+      const matchedNodeIds = this.tokenInvertedIndex.get(token);
+      if (!matchedNodeIds)
+        continue;
+      for (const nodeId of matchedNodeIds) {
+        if (collectionFilter && !nodeId.startsWith(`${collectionFilter}/`)) {
+          continue;
+        }
+        let entry = scoreMap.get(nodeId);
+        if (!entry) {
+          entry = { score: 0, matchedTerms: new Set };
+          scoreMap.set(nodeId, entry);
+        }
+        entry.score += 1;
+        entry.matchedTerms.add(token);
+      }
+    }
+    const results = [];
+    for (const [nodeId, { score, matchedTerms }] of scoreMap) {
+      const doc = this.documents.get(nodeId);
+      if (!doc)
+        continue;
+      results.push({
+        document: doc,
+        score,
+        matchedTerms: Array.from(matchedTerms)
+      });
+    }
+    return results.sort((a, b) => b.score - a.score);
+  }
+  tokenize(text) {
+    const normalized = text.toLowerCase().replace(/[\r\n\t]/g, " ");
+    const words = normalized.split(/[^a-zA-Z0-9\uAC00-\uD7A3]+/).filter((w) => w.length > 0);
+    const tokens = new Set;
+    for (const word of words) {
+      tokens.add(word);
+      if (/[\uAC00-\uD7A3]/.test(word) && word.length >= 2) {
+        for (let i = 0;i < word.length - 1; i++) {
+          tokens.add(word.slice(i, i + 2));
+        }
+      }
+    }
+    return Array.from(tokens);
+  }
+  indexDocumentText(nodeId, doc) {
+    const rawDataStr = JSON.stringify(doc.data);
+    const fullText = `${doc.id} ${doc.collection} ${rawDataStr} ${doc.body}`;
+    const tokens = this.tokenize(fullText);
+    const docTokenSet = new Set(tokens);
+    this.documentTokens.set(nodeId, docTokenSet);
+    for (const token of docTokenSet) {
+      let set = this.tokenInvertedIndex.get(token);
+      if (!set) {
+        set = new Set;
+        this.tokenInvertedIndex.set(token, set);
+      }
+      set.add(nodeId);
+    }
+  }
+  getStats() {
+    const breakdown = {};
+    for (const [col, ids] of this.collectionDocIds) {
+      breakdown[col] = ids.size;
+    }
+    return {
+      collectionsCount: this.collectionDocIds.size,
+      totalDocuments: this.documents.size,
+      totalSynapses: this.edgeMeta.size,
+      collectionBreakdown: breakdown
+    };
+  }
+}
+
+// serializer.ts
+import { existsSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname } from "path";
+function extractWikilinks(text, defaultCollection = "") {
+  const regex = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+  const links = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const rawTarget = match[1].trim();
+    if (!rawTarget)
+      continue;
+    const alias = match[2]?.trim();
+    let targetCollection = defaultCollection;
+    let targetId = rawTarget;
+    if (rawTarget.includes("/")) {
+      const parts = rawTarget.split("/");
+      targetCollection = parts[0].trim();
+      targetId = parts.slice(1).join("/").trim();
+    }
+    if (!targetId)
+      continue;
+    links.push({
+      raw: match[0],
+      targetCollection,
+      targetId,
+      alias
+    });
+  }
+  return links;
+}
+function parseMarkdownFile(rawContent, defaultCollection = "") {
+  const normalizedRaw = rawContent.replace(/\r\n/g, `
+`);
+  const trimmed = normalizedRaw.trimStart();
+  if (!trimmed.startsWith(`---
+`) && trimmed !== "---") {
+    const wikilinks = extractWikilinks(normalizedRaw, defaultCollection);
+    return { frontmatter: {}, body: normalizedRaw, wikilinks };
+  }
+  const endIdx = trimmed.indexOf(`
+---`, 3);
+  if (endIdx === -1) {
+    const wikilinks = extractWikilinks(normalizedRaw, defaultCollection);
+    return { frontmatter: {}, body: normalizedRaw, wikilinks };
+  }
+  const yamlBlock = trimmed.slice(4, endIdx);
+  const afterDelimiter = trimmed.slice(endIdx + 4);
+  const body = afterDelimiter.replace(/^\n+/, "").replace(/\n+$/, "");
+  const data = {};
+  const lines = yamlBlock.split(`
+`);
+  let currentKey = "";
+  let inArray = false;
+  let arrayItems = [];
+  let inObjectArray = false;
+  let currentObj = null;
+  for (let line of lines) {
+    line = line.replace(/\r$/, "");
+    if (!line.trim() || line.trim().startsWith("#"))
+      continue;
+    if (inObjectArray && currentObj && /^\s{4,}[a-zA-Z0-9_-]+:/.test(line)) {
+      const match = line.match(/^\s+([a-zA-Z0-9_-]+):\s*(.*)$/);
+      if (match) {
+        const subKey = match[1];
+        const subVal = parseYamlScalar(match[2].trim());
+        currentObj[subKey] = subVal;
+      }
+      continue;
+    }
+    if (inArray && /^\s*-\s+/.test(line)) {
+      const itemContent = line.replace(/^\s*-\s+/, "").trim();
+      const objMatch = !itemContent.startsWith('"') && !itemContent.startsWith("'") && !itemContent.startsWith("{") && !itemContent.startsWith("[") ? itemContent.match(/^([a-zA-Z0-9_-]+):\s*(.*)$/) : null;
+      if (objMatch) {
+        inObjectArray = true;
+        currentObj = {};
+        const subKey = objMatch[1];
+        const subVal = parseYamlScalar(objMatch[2].trim());
+        currentObj[subKey] = subVal;
+        arrayItems.push(currentObj);
+      } else {
+        inObjectArray = false;
+        currentObj = null;
+        arrayItems.push(parseYamlScalar(itemContent));
+      }
+      continue;
+    }
+    if (inArray && currentKey) {
+      data[currentKey] = arrayItems;
+      inArray = false;
+      inObjectArray = false;
+      currentObj = null;
+    }
+    const kvMatch = line.match(/^([a-zA-Z0-9_-]+):\s*(.*)$/);
+    if (kvMatch) {
+      currentKey = kvMatch[1];
+      const valStr = kvMatch[2].trim();
+      if (valStr === "") {
+        inArray = true;
+        arrayItems = [];
+      } else {
+        data[currentKey] = parseYamlScalar(valStr);
+      }
+    }
+  }
+  if (inArray && currentKey) {
+    data[currentKey] = arrayItems;
+  }
+  const wikilinks = extractWikilinks(normalizedRaw, defaultCollection);
+  return {
+    frontmatter: data,
+    body,
+    wikilinks
+  };
+}
+function parseYamlScalar(val) {
+  if (val === "true")
+    return true;
+  if (val === "false")
+    return false;
+  if (val === "null" || val === "~" || val === "")
+    return null;
+  if (val.startsWith('"') && val.endsWith('"') || val.startsWith("[") && val.endsWith("]") || val.startsWith("{") && val.endsWith("}")) {
+    try {
+      return JSON.parse(val);
+    } catch {
+      if (val.startsWith('"') && val.endsWith('"')) {
+        return val.slice(1, -1);
+      }
+    }
+  }
+  if (val.startsWith("'") && val.endsWith("'")) {
+    return val.slice(1, -1);
+  }
+  if (/^-?\d+$/.test(val)) {
+    const num = Number(val);
+    if (Number.isSafeInteger(num)) {
+      return num;
+    }
+    return val;
+  }
+  if (/^-?\d+\.\d+$/.test(val)) {
+    const num = Number(val);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  return val;
+}
+function serializeYamlValue(val, indent = 0) {
+  const pad = " ".repeat(indent);
+  if (val === null || val === undefined)
+    return "null";
+  if (typeof val === "boolean")
+    return String(val);
+  if (typeof val === "number")
+    return Number.isFinite(val) ? String(val) : "null";
+  if (typeof val === "string") {
+    return JSON.stringify(val);
+  }
+  if (Array.isArray(val)) {
+    if (val.length === 0)
+      return "[]";
+    if (indent > 0) {
+      return JSON.stringify(val);
+    }
+    const lines = [""];
+    for (const item of val) {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const entries = Object.entries(item).filter(([, v]) => v !== undefined);
+        if (entries.length === 0) {
+          lines.push(`${pad}  - {}`);
+          continue;
+        }
+        const [firstK, firstV] = entries[0];
+        lines.push(`${pad}  - ${firstK}: ${serializeYamlValue(firstV, indent + 4)}`);
+        for (let i = 1;i < entries.length; i++) {
+          const [k, v] = entries[i];
+          lines.push(`${pad}    ${k}: ${serializeYamlValue(v, indent + 4)}`);
+        }
+      } else {
+        lines.push(`${pad}  - ${serializeYamlValue(item, indent + 2)}`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+  return JSON.stringify(val);
+}
+function stringifyDocument(data, body = "") {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined)
+      continue;
+    if (Array.isArray(value) && value.length > 0) {
+      lines.push(`${key}:${serializeYamlValue(value, 0)}`);
+    } else {
+      lines.push(`${key}: ${serializeYamlValue(value, 0)}`);
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  const trimmedBody = body.replace(/\r\n/g, `
+`).replace(/^\n+/, "").replace(/\n+$/, "");
+  if (trimmedBody.length > 0) {
+    lines.push(trimmedBody);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function atomicWriteFile(targetPath, content) {
+  const dir = dirname(targetPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const tmpPath = `${targetPath}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  try {
+    writeFileSync(tmpPath, content, "utf-8");
+    renameSync(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      if (existsSync(tmpPath)) {
+        unlinkSync(tmpPath);
+      }
+    } catch {}
+    throw err;
+  }
+}
+
+// engine.ts
+class SynapseEngine {
+  vaultDir;
+  connectome;
+  config;
+  isInitialized = false;
+  pendingWriteQueue = new Map;
+  writeTimer = null;
+  watcherDebounceTimer = null;
+  internalWriteResetTimer = null;
+  fileWatcher = null;
+  isWritingInternally = false;
+  constructor(config) {
+    this.config = {
+      autoWatch: true,
+      persistDebounceMs: 100,
+      ...config,
+      vaultDir: resolve(config.vaultDir)
+    };
+    this.vaultDir = this.config.vaultDir;
+    this.connectome = new SynapseConnectome;
+  }
+  async init() {
+    if (this.isInitialized)
+      return;
+    if (!existsSync2(this.vaultDir)) {
+      mkdirSync2(this.vaultDir, { recursive: true });
+    }
+    this.reloadVault();
+    if (this.config.autoWatch) {
+      this.startWatcher();
+    }
+    this.isInitialized = true;
+  }
+  reloadVault() {
+    this.connectome.clear();
+    if (!existsSync2(this.vaultDir))
+      return;
+    const entries = readdirSync(this.vaultDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const collectionName = entry.name;
+        const colPath = join(this.vaultDir, collectionName);
+        this.loadCollectionDir(collectionName, colPath);
+      }
+    }
+  }
+  loadCollectionDir(collectionName, dirPath) {
+    try {
+      const files = readdirSync(dirPath);
+      for (const file of files) {
+        if (!file.endsWith(".md") || file.includes(".tmp"))
+          continue;
+        const id = basename(file, ".md");
+        const fullPath = join(dirPath, file);
+        try {
+          const raw = readFileSync2(fullPath, "utf-8");
+          const parsed = parseMarkdownFile(raw, collectionName);
+          const rawFm = { ...parsed.frontmatter };
+          const createdAt = typeof rawFm._createdAt === "string" ? rawFm._createdAt : typeof rawFm.createdAt === "string" ? rawFm.createdAt : new Date().toISOString();
+          const updatedAt = typeof rawFm._updatedAt === "string" ? rawFm._updatedAt : typeof rawFm.updatedAt === "string" ? rawFm.updatedAt : new Date().toISOString();
+          delete rawFm._createdAt;
+          delete rawFm._updatedAt;
+          const doc = {
+            id,
+            collection: collectionName,
+            data: rawFm,
+            body: parsed.body,
+            createdAt,
+            updatedAt,
+            wikilinks: parsed.wikilinks
+          };
+          this.connectome.putDocument(doc);
+        } catch (err) {
+          process.stderr.write(`[SynapseEngine] \uD30C\uC77C \uB85C\uB4DC \uC2E4\uD328 (${file}): ${err?.message || err}
+`);
+        }
+      }
+    } catch {}
+  }
+  async saveDocument(collection, input) {
+    const now = new Date().toISOString();
+    const existing = this.connectome.getDocument(collection, input.id);
+    const createdAt = input.createdAt || existing?.createdAt || now;
+    const updatedAt = input.updatedAt || now;
+    const cleanBody = (input.body || "").replace(/\r\n/g, `
+`).replace(/^\n+/, "").replace(/\n+$/, "");
+    const rawMarkdown = stringifyDocument({
+      ...input.data,
+      _createdAt: createdAt,
+      _updatedAt: updatedAt
+    }, cleanBody);
+    const parsed = parseMarkdownFile(rawMarkdown, collection);
+    const restoredFm = { ...parsed.frontmatter };
+    delete restoredFm._createdAt;
+    delete restoredFm._updatedAt;
+    const finalDoc = {
+      id: input.id,
+      collection,
+      data: restoredFm,
+      body: parsed.body,
+      createdAt,
+      updatedAt,
+      wikilinks: parsed.wikilinks
+    };
+    this.connectome.putDocument(finalDoc);
+    const safeCol = collection.replace(/[\/\\:*?"<>|]/g, "_");
+    const safeId = input.id.replace(/[\/\\:*?"<>|]/g, "_");
+    const targetDir = join(this.vaultDir, safeCol);
+    const targetPath = join(targetDir, `${safeId}.md`);
+    const writeKey = `${collection}/${input.id}`;
+    this.scheduleWrite(writeKey, () => {
+      this.markInternalWrite();
+      atomicWriteFile(targetPath, rawMarkdown);
+    });
+    return finalDoc;
+  }
+  markInternalWrite() {
+    this.isWritingInternally = true;
+    if (this.internalWriteResetTimer) {
+      clearTimeout(this.internalWriteResetTimer);
+    }
+    this.internalWriteResetTimer = setTimeout(() => {
+      this.isWritingInternally = false;
+      this.internalWriteResetTimer = null;
+    }, 120);
+  }
+  async deleteDocument(collection, id) {
+    const deleted = this.connectome.removeDocument(collection, id);
+    if (!deleted)
+      return false;
+    const safeCol = collection.replace(/[\/\\:*?"<>|]/g, "_");
+    const safeId = id.replace(/[\/\\:*?"<>|]/g, "_");
+    const targetPath = join(this.vaultDir, safeCol, `${safeId}.md`);
+    const writeKey = `${collection}/${id}`;
+    this.pendingWriteQueue.delete(writeKey);
+    try {
+      if (existsSync2(targetPath)) {
+        this.markInternalWrite();
+        unlinkSync2(targetPath);
+      }
+    } catch {}
+    return true;
+  }
+  scheduleWrite(key, fn) {
+    this.pendingWriteQueue.set(key, fn);
+    if (this.writeTimer)
+      clearTimeout(this.writeTimer);
+    const debounceMs = this.config.persistDebounceMs || 100;
+    this.writeTimer = setTimeout(() => {
+      this.flushPendingWrites();
+    }, debounceMs);
+  }
+  flushPendingWrites() {
+    if (this.writeTimer) {
+      clearTimeout(this.writeTimer);
+      this.writeTimer = null;
+    }
+    if (this.pendingWriteQueue.size === 0)
+      return;
+    for (const [key, fn] of this.pendingWriteQueue) {
+      try {
+        fn();
+      } catch (err) {
+        process.stderr.write(`[SynapseEngine] \uB514\uC2A4\uD06C \uC4F0\uAE30 \uC2E4\uD328 (${key}): ${err?.message || err}
+`);
+      }
+    }
+    this.pendingWriteQueue.clear();
+  }
+  startWatcher() {
+    try {
+      this.fileWatcher = watch(this.vaultDir, { recursive: true }, (_eventType, filename) => {
+        if (!filename || !filename.endsWith(".md") || filename.includes(".tmp"))
+          return;
+        if (this.isWritingInternally)
+          return;
+        if (this.watcherDebounceTimer) {
+          clearTimeout(this.watcherDebounceTimer);
+        }
+        this.watcherDebounceTimer = setTimeout(() => {
+          this.watcherDebounceTimer = null;
+          if (!this.isWritingInternally) {
+            this.reloadVault();
+          }
+        }, 80);
+      });
+    } catch {}
+  }
+  getStats() {
+    return this.connectome.getStats();
+  }
+  close() {
+    if (this.writeTimer) {
+      clearTimeout(this.writeTimer);
+      this.writeTimer = null;
+    }
+    if (this.watcherDebounceTimer) {
+      clearTimeout(this.watcherDebounceTimer);
+      this.watcherDebounceTimer = null;
+    }
+    if (this.internalWriteResetTimer) {
+      clearTimeout(this.internalWriteResetTimer);
+      this.internalWriteResetTimer = null;
+    }
+    this.flushPendingWrites();
+    if (this.fileWatcher) {
+      this.fileWatcher.close();
+      this.fileWatcher = null;
+    }
+  }
+}
+
+// collection.ts
+class SynapseCollection {
+  name;
+  engine;
+  constructor(name, engine) {
+    this.name = name;
+    this.engine = engine;
+  }
+  async save(input) {
+    return this.engine.saveDocument(this.name, input);
+  }
+  get(id) {
+    return this.engine.connectome.getDocument(this.name, id);
+  }
+  has(id) {
+    return this.engine.connectome.getDocument(this.name, id) !== null;
+  }
+  async delete(id) {
+    return this.engine.deleteDocument(this.name, id);
+  }
+  query(options) {
+    return this.engine.connectome.queryCollection(this.name, options);
+  }
+  all() {
+    return this.engine.connectome.queryCollection(this.name);
+  }
+  count() {
+    return this.engine.connectome.queryCollection(this.name).length;
+  }
+  search(queryText) {
+    return this.engine.connectome.search(queryText, this.name);
+  }
+  synapses(id) {
+    const engine = this.engine;
+    const colName = this.name;
+    return {
+      outgoing: (targetCollectionFilter) => {
+        return engine.connectome.getOutgoingDocuments(colName, id, targetCollectionFilter);
+      },
+      incoming: (sourceCollectionFilter) => {
+        return engine.connectome.getIncomingDocuments(colName, id, sourceCollectionFilter);
+      }
+    };
+  }
+}
+
+// migrator.ts
+import { existsSync as existsSync3 } from "fs";
+
+class SynapseMigrator {
+  engine;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  async migrateFromSqlite(sqliteDbPath, mappings) {
+    if (!existsSync3(sqliteDbPath)) {
+      throw new Error(`[SynapseMigrator] SQLite DB \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${sqliteDbPath}`);
+    }
+    for (const m of mappings) {
+      if (!/^[a-zA-Z0-9_]+$/.test(m.tableName)) {
+        throw new Error(`[SynapseMigrator] \uD5C8\uC6A9\uB418\uC9C0 \uC54A\uB294 SQLite \uD14C\uC774\uBE14 \uC2DD\uBCC4\uC790\uC785\uB2C8\uB2E4 (\uBCF4\uC548 \uCC28\uB2E8): ${m.tableName}`);
+      }
+    }
+    const { Database } = await import("bun:sqlite");
+    const sqlite = new Database(sqliteDbPath, { readonly: true });
+    const stats = {};
+    try {
+      for (const m of mappings) {
+        let count = 0;
+        try {
+          const rows = sqlite.query(`SELECT * FROM "${m.tableName}"`).all();
+          for (const row of rows) {
+            const mapped = m.mapRow(row);
+            await this.engine.saveDocument(m.targetCollection, {
+              id: mapped.id,
+              data: mapped.data,
+              body: mapped.body
+            });
+            count++;
+          }
+        } catch (err) {
+          process.stderr.write(`[SynapseMigrator] \uD14C\uC774\uBE14(${m.tableName}) \uBCC0\uD658 \uC911 \uC624\uB958: ${err?.message || err}
+`);
+        }
+        stats[m.targetCollection] = count;
+      }
+      this.engine.flushPendingWrites();
+      sqlite.close();
+      return stats;
+    } catch (err) {
+      sqlite.close();
+      throw err;
+    }
+  }
+  async migrateFromJsonArray(targetCollection, items, mapItem) {
+    let count = 0;
+    for (const item of items) {
+      const input = mapItem(item);
+      await this.engine.saveDocument(targetCollection, input);
+      count++;
+    }
+    this.engine.flushPendingWrites();
+    return count;
+  }
+}
+
+// canvasExporter.ts
+var COLLECTION_COLOR_PALETTE = {
+  guilds: "5",
+  streamers: "4",
+  clips: "1",
+  categories: "2",
+  settings: "6",
+  users: "3"
+};
+function exportToObsidianCanvas(connectome, targetFilePath, options) {
+  const nodeWidth = options?.nodeWidth || 280;
+  const nodeHeight = options?.nodeHeight || 160;
+  const hGap = options?.horizontalGap || 80;
+  const vGap = options?.verticalGap || 60;
+  const allDocs = connectome.getAllDocuments();
+  const allEdges = connectome.getAllEdges();
+  const groupedByCollection = new Map;
+  for (const doc of allDocs) {
+    let list = groupedByCollection.get(doc.collection);
+    if (!list) {
+      list = [];
+      groupedByCollection.set(doc.collection, list);
+    }
+    list.push(doc);
+  }
+  const nodes = [];
+  const nodeIdToCanvasId = new Map;
+  let colIndex = 0;
+  for (const [colName, docs] of groupedByCollection) {
+    const color = COLLECTION_COLOR_PALETTE[colName] || "5";
+    const x = colIndex * (nodeWidth + hGap);
+    docs.forEach((doc, rowIndex) => {
+      const internalId = `${doc.collection}/${doc.id}`;
+      const canvasNodeId = `node_${doc.collection}_${doc.id.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+      nodeIdToCanvasId.set(internalId, canvasNodeId);
+      const y = rowIndex * (nodeHeight + vGap);
+      nodes.push({
+        id: canvasNodeId,
+        type: "file",
+        file: `${doc.collection}/${doc.id}.md`,
+        x,
+        y,
+        width: nodeWidth,
+        height: nodeHeight,
+        color
+      });
+    });
+    colIndex++;
+  }
+  const edges = [];
+  let edgeCounter = 0;
+  for (const edge of allEdges) {
+    const fromCanvasId = nodeIdToCanvasId.get(edge.fromNodeId);
+    const toCanvasId = nodeIdToCanvasId.get(edge.toNodeId);
+    if (fromCanvasId && toCanvasId) {
+      edges.push({
+        id: `edge_${++edgeCounter}`,
+        fromNode: fromCanvasId,
+        toNode: toCanvasId,
+        label: edge.alias || edge.relation,
+        toEnd: "arrow"
+      });
+    }
+  }
+  const canvasData = { nodes, edges };
+  atomicWriteFile(targetFilePath, JSON.stringify(canvasData, null, 2));
+  return canvasData;
+}
+
+// index.ts
+class SynapseDB {
+  engine;
+  collections = new Map;
+  constructor(config) {
+    this.engine = new SynapseEngine(config);
+  }
+  async init() {
+    await this.engine.init();
+  }
+  collection(name) {
+    let col = this.collections.get(name);
+    if (!col) {
+      col = new SynapseCollection(name, this.engine);
+      this.collections.set(name, col);
+    }
+    return col;
+  }
+  exportCanvas(targetFilePath, options) {
+    return exportToObsidianCanvas(this.engine.connectome, targetFilePath, options);
+  }
+  createMigrator() {
+    return new SynapseMigrator(this.engine);
+  }
+  stats() {
+    return this.engine.getStats();
+  }
+  flush() {
+    this.engine.flushPendingWrites();
+  }
+  close() {
+    this.engine.close();
+  }
+}
+export {
+  SynapseCollection,
+  SynapseConnectome,
+  SynapseDB,
+  SynapseEngine,
+  SynapseMigrator,
+  atomicWriteFile,
+  exportToObsidianCanvas,
+  extractWikilinks,
+  parseMarkdownFile,
+  parseYamlScalar,
+  stringifyDocument
+};