@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/memory-claims.js

@@ -0,0 +1,153 @@
+const LIMITS = { entries: 500, bodyChars: 2e4, claimsPerEntry: 12, claims: 1e3, comparedPairs: 5e4, findings: 100, snippetChars: 512, structuredChars: 8192 };
+const ACTIONS = { use: ["use", true], utilize: ["use", true], employ: ["use", true], allow: ["allow", true], permit: ["allow", true], accept: ["allow", true], deny: ["allow", false], block: ["allow", false], disallow: ["allow", false], forbid: ["allow", false], reject: ["allow", false], require: ["require", true], enforce: ["require", true], encrypt: ["encrypt", true], cache: ["cache", true], memoize: ["cache", true], validate: ["validate", true], verify: ["validate", true], store: ["store", true], log: ["log", true], record: ["log", true], enable: ["enable", true], disable: ["enable", false] };
+function normalized(value) {
+  return value.normalize("NFKC").toLowerCase().replace(/[`"']/g, "").replace(/time[ -]+to[ -]+live/g, "ttl").replace(/\s+/g, " ").trim().replace(/^(?:the|an?|all) /, "").replace(/\b(requests|records|responses|tokens|secrets|passwords|guests)\b/g, (word) => word.slice(0, -1));
+}
+const reference = (entry) => ({ id: entry.id, revision: entry.revision });
+function unit(value) {
+  const text = String(value ?? "count").toLowerCase();
+  if (["count", "retry", "retries", "request", "requests"].includes(text)) return { name: "count", scale: 1 };
+  if (["ms", "millisecond", "milliseconds"].includes(text)) return { name: "ms", scale: 1 };
+  if (["s", "sec", "secs", "second", "seconds"].includes(text)) return { name: "ms", scale: 1e3 };
+  if (["m", "min", "mins", "minute", "minutes"].includes(text)) return { name: "ms", scale: 6e4 };
+  if (["h", "hour", "hours"].includes(text)) return { name: "ms", scale: 36e5 };
+  if (["b", "byte", "bytes"].includes(text)) return { name: "bytes", scale: 1 };
+  const sizes = { kb: 1e3, mb: 1e6, gb: 1e9, kib: 1024, mib: 1024 ** 2, gib: 1024 ** 3 };
+  return sizes[text] ? { name: "bytes", scale: sizes[text] } : void 0;
+}
+function numeric(min, max, rawUnit, minInclusive = true, maxInclusive = true) {
+  const dimension = unit(rawUnit);
+  if (!dimension || [min, max].some((number) => number !== null && (!Number.isFinite(number) || Math.abs(number * dimension.scale) > Number.MAX_SAFE_INTEGER)) || min !== null && max !== null && min > max) return;
+  return { kind: "number", min: min === null ? null : min * dimension.scale, max: max === null ? null : max * dimension.scale, minInclusive, maxInclusive, unit: dimension.name };
+}
+function structured(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+  const input = raw;
+  if (Object.keys(input).some((key) => !["subject", "predicate", "value", "min", "max", "unit"].includes(key)) || typeof input.subject !== "string" || !input.subject.trim() || input.subject.length > 120 || typeof input.predicate !== "string" || !/^[a-z][a-z-]{0,39}$/.test(input.predicate)) return;
+  let value;
+  if (input.value !== void 0 && (input.min !== void 0 || input.max !== void 0)) return;
+  if (typeof input.value === "boolean" && input.unit === void 0) value = { kind: "boolean", value: input.value };
+  else if (typeof input.value === "string" && input.value.trim() && input.value.length <= 120 && input.unit === void 0) value = { kind: "text", value: normalized(input.value) };
+  else if (typeof input.value === "number") value = numeric(input.value, input.value, input.unit);
+  else if (input.value === void 0 && (typeof input.min === "number" || typeof input.max === "number") && (input.min === void 0 || typeof input.min === "number") && (input.max === void 0 || typeof input.max === "number")) value = numeric(input.min ?? null, input.max ?? null, input.unit);
+  if (!value) return;
+  const action = ACTIONS[input.predicate];
+  if (value.kind === "boolean" && action && !action[1]) value = { ...value, value: !value.value };
+  return { subject: normalized(input.subject), predicate: action?.[0] ?? input.predicate, value };
+}
+function language(text) {
+  const sentence = text.trim().replace(/^[-*]\s+/, "").replace(/[.!]$/, "").trim();
+  if (sentence.length > 512 || new RegExp("\\b(if|unless|except|when|until|only|but|or|and|may|might|could)\\b|;|\\.\\s+\\p{L}", "u").test(sentence.toLowerCase())) return;
+  const setting = sentence.match(/^(?:set\s+)?(.{1,100}?)\s*(?:\s+(?:to|is|equals?)\s+|\s*[=:]\s*)(?:(at least|at most|no more than|no less than|>=|<=|>|<)\s*)?(-?\d+(?:\.\d+)?)\s*([a-z]+)?$/i);
+  if (setting) {
+    const number = Number(setting[3]), relation = setting[2]?.toLowerCase();
+    const lower = ["at least", "no less than", ">=", ">"].includes(relation ?? ""), upper = ["at most", "no more than", "<=", "<"].includes(relation ?? "");
+    const value = numeric(upper ? null : number, lower ? null : number, setting[4], relation !== ">", relation !== "<");
+    if (value) return { subject: normalized(setting[1]), predicate: "setting", value };
+    return;
+  }
+  const string = sentence.match(/^(?:set\s+)?(.{1,100}?)\s*(?:\s+(?:to|is|equals?)\s+|\s*[=:]\s*)["'`]([^"'`]{1,120})["'`]$/i);
+  if (string) return { subject: normalized(string[1]), predicate: "setting", value: { kind: "text", value: normalized(string[2]) } };
+  const policy = sentence.match(/^(?:(always|never|do not|don't|must not|should not|cannot)\s+)?(?:(?:must|should)\s+)?(use|utilize|employ|allow|permit|accept|deny|block|disallow|forbid|reject|require|enforce|encrypt|cache|memoize|validate|verify|store|log|record|enable|disable)\s+(.+)$/i);
+  if (policy) {
+    const action = ACTIONS[policy[2].toLowerCase()];
+    const negative = !!policy[1] && policy[1].toLowerCase() !== "always";
+    return { subject: normalized(policy[3]), predicate: action[0], value: { kind: "boolean", value: negative ? !action[1] : action[1] } };
+  }
+}
+function overlap(a, b) {
+  if (a.applicability.kind === "branch" && b.applicability.kind === "branch" && (a.applicability.branch !== b.applicability.branch || a.applicability.commit && b.applicability.commit && a.applicability.commit !== b.applicability.commit)) return false;
+  if (!a.paths.length || !b.paths.length) return true;
+  return a.paths.some((left) => b.paths.some((right) => {
+    const a2 = left.replace(/\/$/, ""), b2 = right.replace(/\/$/, "");
+    return a2 === b2 || a2.startsWith(`${b2}/`) || b2.startsWith(`${a2}/`);
+  }));
+}
+function compare(a, b) {
+  if (a.kind !== b.kind) return;
+  if (a.kind === "boolean" && b.kind === "boolean" || a.kind === "text" && b.kind === "text") return a.value === b.value ? "equivalent" : "contradiction";
+  if (a.kind !== "number" || b.kind !== "number" || a.unit !== b.unit) return;
+  if (a.min === b.min && a.max === b.max && a.minInclusive === b.minInclusive && a.maxInclusive === b.maxInclusive) return "equivalent";
+  const disjoint = (left, right) => left.max !== null && right.min !== null && (left.max < right.min || left.max === right.min && (!left.maxInclusive || !right.minInclusive));
+  if (disjoint(a, b) || disjoint(b, a)) return "contradiction";
+}
+function analyzeMemoryClaims(input) {
+  const scoped = input.entries.filter((entry) => entry.scope === "project" && entry.repo === input.repo && entry.projectId === input.projectId && entry.status !== "deleted");
+  const entries = scoped.slice(0, LIMITS.entries);
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const result = { claims: [], findings: [], inspectedEntries: entries.length, unsupported: 0, comparedPairs: 0, truncated: scoped.length > entries.length, limits: { ...LIMITS }, method: "Local claim grammar v1: explicit facts, policy polarity, setting values and normalized numeric intervals. Suggestions require human review; unsupported prose has no semantic correctness guarantee." };
+  for (const entry of entries) {
+    if (result.claims.length >= LIMITS.claims) {
+      result.truncated = true;
+      break;
+    }
+    let count = 0;
+    const body = entry.body.slice(0, LIMITS.bodyChars);
+    if (body.length < entry.body.length) result.truncated = true;
+    const add = (claim, start2, end, method) => {
+      if (!claim) {
+        result.unsupported++;
+        return;
+      }
+      if (count >= LIMITS.claimsPerEntry || result.claims.length >= LIMITS.claims) {
+        result.truncated = true;
+        return;
+      }
+      count++;
+      result.claims.push({ ...claim, source: reference(entry), evidence: { start: start2, end, text: body.slice(start2, Math.min(end, start2 + LIMITS.snippetChars)), method } });
+    };
+    const fenced = [];
+    for (const match of body.matchAll(/```codeflow-claims[ \t]*\r?\n([\s\S]*?)\r?\n```/g)) {
+      const start2 = match.index, end = start2 + match[0].length;
+      fenced.push([start2, end]);
+      if (match[1].length > LIMITS.structuredChars) {
+        result.truncated = true;
+        result.unsupported++;
+        continue;
+      }
+      try {
+        const value = JSON.parse(match[1]);
+        if (!Array.isArray(value) || value.length > LIMITS.claimsPerEntry) {
+          if (Array.isArray(value)) result.truncated = true;
+          result.unsupported++;
+          continue;
+        }
+        for (const fact of value) add(structured(fact), start2, end, "structured");
+      } catch {
+        result.unsupported++;
+      }
+    }
+    let start = 0;
+    for (const line of body.split(/\n/)) {
+      const end = start + line.length;
+      if (line.trim() && !fenced.some(([a, b]) => start < b && end > a)) {
+        const claim = language(line);
+        add(claim, start, end, claim?.value.kind === "boolean" ? "policy" : "setting");
+      }
+      start = end + 1;
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const claim of result.claims) {
+    const key = `${claim.subject}\0${claim.predicate}`;
+    const group = groups.get(key) ?? [];
+    group.push(claim);
+    groups.set(key, group);
+  }
+  outer: for (const claims of groups.values()) for (let a = 0; a < claims.length; a++) for (let b = a + 1; b < claims.length; b++) {
+    const left = claims[a], right = claims[b];
+    if (!overlap(byId.get(left.source.id), byId.get(right.source.id))) continue;
+    if (result.comparedPairs >= LIMITS.comparedPairs || result.findings.length >= LIMITS.findings) {
+      result.truncated = true;
+      break outer;
+    }
+    result.comparedPairs++;
+    const kind = compare(left.value, right.value);
+    if (!kind || left.source.id === right.source.id && kind !== "contradiction") continue;
+    result.findings.push({ a: left.source, b: right.source, kind, subject: left.subject, predicate: left.predicate, left, right, explanation: kind === "equivalent" ? "These supported claims normalize to the same meaning and overlapping applicability. Review their remaining context before combining entries." : "These supported claims impose opposite policy values, different explicit settings, or disjoint numeric constraints in overlapping applicability. Review both source revisions; this does not decide which is correct." });
+  }
+  return result;
+}
+export {
+  analyzeMemoryClaims
+};

package/src/memory-sqlite.js

@@ -0,0 +1,236 @@
+import { DatabaseSync } from "node:sqlite";
+import { createHash } from "node:crypto";
+import { chmodSync, closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync } from "node:fs";
+import { basename, dirname } from "node:path";
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const idFor = (entry, kind, key) => digest(JSON.stringify([entry.repo, entry.projectId ?? null, kind, key]));
+class MemoryDatabase {
+  constructor(file, validate) {
+    this.file = file;
+    this.validate = validate;
+    this.legacy = file.replace(/\.sqlite$/, "") + ".json";
+    this.backup = `${this.legacy}.pre-sqlite`;
+  }
+  legacy;
+  backup;
+  withDatabase(action) {
+    let db;
+    try {
+      mkdirSync(dirname(this.file), { recursive: true });
+      const fresh = !existsSync(this.file);
+      if (fresh && existsSync(this.backup) && !existsSync(this.legacy)) throw new Error("Database is missing but a migration backup exists; restore it explicitly before continuing");
+      const legacyRaw = this.readLegacyIfPresent();
+      const legacy = legacyRaw === void 0 ? void 0 : this.validate(legacyRaw);
+      if (fresh) {
+        try {
+          closeSync(openSync(this.file, "wx", 384));
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+        }
+      }
+      if (!lstatSync(this.file).isFile() || lstatSync(this.file).isSymbolicLink()) throw new Error("Memory database must be a regular file");
+      if ((lstatSync(this.file).mode & 511) !== 384) chmodSync(this.file, 384);
+      db = new DatabaseSync(this.file);
+      db.exec("PRAGMA busy_timeout=5000; PRAGMA foreign_keys=ON; PRAGMA secure_delete=ON; PRAGMA synchronous=FULL;");
+      const version = Number(db.prepare("PRAGMA user_version").get().user_version);
+      if (version !== 0 && version !== 1) throw new Error(`Unsupported memory database schema ${version}`);
+      if (!version) {
+        db.exec("PRAGMA journal_mode=DELETE; BEGIN IMMEDIATE");
+        try {
+          if (Number(db.prepare("PRAGMA user_version").get().user_version) === 0) {
+            if (db.prepare("SELECT name FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'").get()) throw new Error("Unrecognized memory database");
+            db.exec(`
+              CREATE TABLE metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL) STRICT;
+              CREATE TABLE memories (id TEXT PRIMARY KEY, repo TEXT NOT NULL, project_id TEXT,
+                scope TEXT NOT NULL, run_id TEXT, member_id TEXT, status TEXT NOT NULL,
+                revision INTEGER NOT NULL, document TEXT NOT NULL) STRICT;
+              CREATE INDEX memory_scope ON memories(repo, project_id, scope, run_id, member_id);
+              CREATE TABLE memory_terms (memory_id TEXT NOT NULL REFERENCES memories(id), term TEXT NOT NULL,
+                weight INTEGER NOT NULL, PRIMARY KEY(memory_id, term)) STRICT;
+              CREATE INDEX memory_term_lookup ON memory_terms(term);
+              CREATE TABLE entities (id TEXT PRIMARY KEY, kind TEXT NOT NULL, key TEXT NOT NULL) STRICT;
+              CREATE TABLE relationships (owner TEXT NOT NULL REFERENCES memories(id), revision INTEGER NOT NULL,
+                source TEXT NOT NULL REFERENCES entities(id), target TEXT NOT NULL REFERENCES entities(id),
+                relation TEXT NOT NULL, target_revision INTEGER,
+                PRIMARY KEY(owner, source, target, relation)) STRICT;
+              CREATE INDEX graph_source ON relationships(source);
+              CREATE INDEX graph_target ON relationships(target);
+              PRAGMA user_version=1;
+            `);
+            for (const entry of legacy?.entries ?? []) this.writeEntry(db, entry);
+            if (legacyRaw !== void 0) {
+              const imported = this.read(db);
+              if (JSON.stringify(imported.entries) !== JSON.stringify(legacy.entries)) throw new Error("Legacy memory verification failed");
+              db.prepare("INSERT INTO metadata VALUES('legacy_hash', ?)").run(digest(legacyRaw));
+            }
+          }
+          db.exec("COMMIT");
+        } catch (error) {
+          db.exec("ROLLBACK");
+          throw error;
+        }
+      }
+      if (existsSync(this.legacy)) {
+        db.exec("BEGIN IMMEDIATE");
+        try {
+          const current = this.readLegacyIfPresent();
+          if (current !== void 0) {
+            const hash = db.prepare("SELECT value FROM metadata WHERE key='legacy_hash'").get()?.value;
+            if (hash !== digest(current)) throw new Error("Legacy JSON differs from the imported database; resolve it explicitly before continuing");
+            if (existsSync(this.backup)) throw new Error("Both legacy JSON and migration backup exist; resolve them explicitly");
+            renameSync(this.legacy, this.backup);
+            chmodSync(this.backup, 384);
+            this.syncDirectory();
+          }
+          db.exec("COMMIT");
+        } catch (error) {
+          db.exec("ROLLBACK");
+          throw error;
+        }
+      }
+      return action(db);
+    } catch (error) {
+      if (error.code?.startsWith("ERR_SQLITE")) {
+        throw new Error(`Memory store cannot be read or updated; no operation was acknowledged: ${error.message}`, { cause: error });
+      }
+      throw error;
+    } finally {
+      db?.close();
+    }
+  }
+  read(db, query) {
+    const rows = query ? db.prepare("SELECT document FROM memories WHERE repo=? AND project_id IS ? AND (? IS NULL OR scope=?) ORDER BY rowid").all(query.repo, query.projectId ?? null, query.scope ?? null, query.scope ?? null) : db.prepare("SELECT document FROM memories ORDER BY rowid").all();
+    return this.validate(JSON.stringify({ schemaVersion: 1, entries: rows.map((row) => JSON.parse(String(row.document))) }));
+  }
+  change(db, fn) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const doc = this.read(db);
+      const before = new Map(doc.entries.map((entry) => [entry.id, JSON.stringify(entry)]));
+      const result = fn(doc);
+      const changed = doc.entries.filter((entry) => before.get(entry.id) !== JSON.stringify(entry));
+      if (changed.length) {
+        this.validate(JSON.stringify(doc));
+        this.cleanLegacyCopies();
+        db.exec("DELETE FROM metadata WHERE key='legacy_hash'");
+        for (const entry of changed) this.writeEntry(db, entry);
+        db.exec("DELETE FROM entities WHERE id NOT IN (SELECT source FROM relationships UNION SELECT target FROM relationships)");
+      }
+      db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  /** An indexed Unicode token search also works on Node builds without FTS5. */
+  search(db, query, eligible) {
+    const terms = [...new Set(tokenize(query.query ?? ""))].slice(0, 32);
+    if (!terms.length || !eligible.length) return /* @__PURE__ */ new Map();
+    return new Map(db.prepare(`SELECT memory_id, SUM(weight) AS relevance FROM memory_terms
+      WHERE term IN (SELECT value FROM json_each(?)) AND memory_id IN (SELECT value FROM json_each(?))
+      GROUP BY memory_id ORDER BY relevance DESC, memory_id LIMIT 512`).all(JSON.stringify(terms), JSON.stringify(eligible)).map((row) => [String(row.memory_id), Number(row.relevance)]));
+  }
+  graph(db, entries, limit = 1e3) {
+    const allowed = new Map(entries.map((entry) => [entry.id, entry]));
+    const memoryNodes = new Map(entries.map((entry) => [idFor(entry, "memory", entry.id), entry]));
+    const entities = /* @__PURE__ */ new Map();
+    const relationships = [];
+    let truncated = false;
+    const edges = db.prepare(`SELECT r.*, s.kind AS source_kind, s.key AS source_key, t.kind AS target_kind, t.key AS target_key
+      FROM relationships r JOIN entities s ON s.id=r.source JOIN entities t ON t.id=r.target WHERE r.owner=? ORDER BY r.relation, t.key`);
+    for (const entry of entries) {
+      for (const row of edges.all(entry.id)) {
+        const target = memoryNodes.get(String(row.target));
+        if (row.target_kind === "memory" && (!target || target.revision !== row.target_revision)) continue;
+        if (!allowed.has(String(row.owner)) || row.revision !== entry.revision) continue;
+        if (relationships.length >= limit) {
+          truncated = true;
+          break;
+        }
+        for (const prefix of ["source", "target"]) {
+          const id = String(row[prefix]), kind = row[`${prefix}_kind`], key = String(row[`${prefix}_key`]);
+          entities.set(id, { id, kind, key, label: kind === "memory" ? memoryNodes.get(id).title : key });
+        }
+        relationships.push({
+          from: String(row.source),
+          to: String(row.target),
+          relation: row.relation,
+          evidence: { id: entry.id, revision: entry.revision },
+          ...row.target_revision == null ? {} : { targetRevision: Number(row.target_revision) }
+        });
+      }
+      if (truncated) break;
+    }
+    return { entities: [...entities.values()], relationships, truncated };
+  }
+  writeEntry(db, entry) {
+    db.prepare(`INSERT INTO memories VALUES(?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET
+      repo=excluded.repo, project_id=excluded.project_id, scope=excluded.scope, run_id=excluded.run_id,
+      member_id=excluded.member_id, status=excluded.status, revision=excluded.revision, document=excluded.document`).run(entry.id, entry.repo, entry.projectId ?? null, entry.scope, entry.runId ?? null, entry.memberId ?? null, entry.status, entry.revision, JSON.stringify(entry));
+    db.prepare("DELETE FROM memory_terms WHERE memory_id=?").run(entry.id);
+    db.prepare("DELETE FROM relationships WHERE owner=?").run(entry.id);
+    if (entry.status === "deleted") return;
+    const weights = /* @__PURE__ */ new Map();
+    for (const [value, weight] of [[entry.title, 3], [entry.tags.join(" "), 2], [entry.body, 1]]) {
+      for (const term of new Set(tokenize(value))) weights.set(term, (weights.get(term) ?? 0) + weight);
+    }
+    const termInsert = db.prepare("INSERT INTO memory_terms VALUES(?,?,?)");
+    for (const [term, weight] of weights) termInsert.run(entry.id, term, weight);
+    const entity = (kind, key) => {
+      const id = idFor(entry, kind, key);
+      db.prepare("INSERT OR IGNORE INTO entities VALUES(?,?,?)").run(id, kind, key);
+      return id;
+    };
+    const source = entity("memory", entry.id);
+    const edge = (kind, key, relation, revision) => {
+      db.prepare("INSERT OR REPLACE INTO relationships VALUES(?,?,?,?,?,?)").run(entry.id, entry.revision, source, entity(kind, key), relation, revision ?? null);
+    };
+    for (const path of entry.paths) edge("file", path, "applies_to");
+    if (entry.runId) edge("run", entry.runId, "learned_from");
+    for (const ref of entry.sourceRefs) {
+      if (ref.startsWith("run:") && ref.length > 4) edge("run", ref.slice(4), "learned_from");
+      if (/^commit:[a-f0-9]{40,64}$/i.test(ref)) edge("commit", ref.slice(7), "learned_from");
+    }
+    if (entry.applicability.kind === "branch" && entry.applicability.commit) edge("commit", entry.applicability.commit, "applies_to");
+    if (entry.verification?.commit) edge("commit", entry.verification.commit, "verified_at");
+    const sources = /* @__PURE__ */ new Map();
+    for (const ref of entry.derivedFrom) sources.set(ref.id, Math.max(sources.get(ref.id) ?? 0, ref.revision));
+    for (const [id, revision] of sources) edge("memory", id, "derived_from", revision);
+  }
+  readLegacyIfPresent() {
+    try {
+      const info = lstatSync(this.legacy);
+      if (!info.isFile() || info.isSymbolicLink() || info.size > 32 * 1024 * 1024) throw new Error("Legacy memory must be a regular file under 32 MiB");
+      return readFileSync(this.legacy, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  }
+  cleanLegacyCopies() {
+    rmSync(this.backup, { force: true });
+    for (const name of readdirSync(dirname(this.file))) {
+      for (const path of [this.file, this.legacy]) {
+        const prefix = `${basename(path)}.`;
+        if (name.startsWith(prefix) && /^[0-9a-f-]{36}\.tmp$/.test(name.slice(prefix.length))) rmSync(`${dirname(this.file)}/${name}`);
+      }
+    }
+    this.syncDirectory();
+  }
+  syncDirectory() {
+    if (process.platform === "win32") return;
+    const fd = openSync(dirname(this.file), "r");
+    try {
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+  }
+}
+function tokenize(value) {
+  return value.normalize("NFKC").toLowerCase().match(/[\p{L}\p{N}_]{3,}/gu) ?? [];
+}
+export {
+  MemoryDatabase
+};