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

package/src/model-catalog.js

@@ -0,0 +1,239 @@
+import { AGY_ISOLATION_VERSION, AGY_VERIFIED_CLI_VERSIONS } from "./adapters/agy-isolation.js";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { hostname } from "node:os";
+import { CODEFLOW_HOME } from "./config.js";
+import { getAdapter } from "./adapters/index.js";
+import { researchModels, validateDocumentation } from "./model-research.js";
+const TTL = 10 * 6e4;
+const ID = /^[A-Za-z0-9][\w.:[\]/@-]{0,199}$/;
+const effortValid = (v) => typeof v === "string" && /^[a-z]{2,12}$/.test(v) && v !== "ultracode";
+function modelEnvironment(context = {}, remote) {
+  return createHash("sha256").update(JSON.stringify({ host: hostname(), home: process.env.HOME, codexHome: process.env.CODEX_HOME, claudeHome: process.env.CLAUDE_CONFIG_DIR, path: process.env.PATH, container: context.agentContainer, ...context.isolatedAgy ? { isolation: `agy-${AGY_ISOLATION_VERSION}/${AGY_VERIFIED_CLI_VERSIONS.join(",")}` } : {}, remote })).digest("hex");
+}
+function validateCapabilityCatalog(value) {
+  const c = value;
+  if (!c || typeof c !== "object" || Array.isArray(c) || Object.keys(c).some((k) => !["schemaVersion", "revision", "provider", "environment", "accountKey", "defaultModel", "discoveredAt", "attemptedAt", "state", "issue", "models"].includes(k)))
+    throw new Error("Invalid capability catalog fields");
+  if (!c || c.schemaVersion !== 1 || !Number.isSafeInteger(c.revision) || c.revision < 0 || typeof c.provider !== "string" || !ID.test(c.provider) || !/^[a-f0-9]{64}$/.test(c.environment) || !["current", "stale", "unknown"].includes(c.state) || !Number.isFinite(c.discoveredAt) || !Number.isFinite(c.attemptedAt) || !Array.isArray(c.models) || c.models.length > 800 || c.accountKey !== void 0 && !/^[a-f0-9]{64}$/.test(c.accountKey))
+    throw new Error("Invalid capability catalog");
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of c.models) {
+    if (!m || Object.keys(m).some((k) => !["id", "label", "aliases", "efforts", "defaultEffort", "availability", "compatibility", "source", "verifiedAt", "confidence", "documented", "researchAttemptedAt", "observations"].includes(k)) || typeof m.id !== "string" || !ID.test(m.id) || seen.has(m.id) || typeof m.label !== "string" || m.label.length > 120 || !Array.isArray(m.aliases) || m.aliases.length > 30 || m.aliases.some((a) => typeof a !== "string" || !ID.test(a)) || !(m.efforts === null || Array.isArray(m.efforts) && m.efforts.length <= 20 && m.efforts.every(effortValid)) || m.defaultEffort !== void 0 && !m.efforts?.includes(m.defaultEffort) || !["reported", "unavailable"].includes(m.availability) || !["advertised", "unknown"].includes(m.compatibility) || m.confidence !== "reported" || typeof m.source !== "string" || m.source.length > 120 || !Number.isFinite(m.verifiedAt) || !Array.isArray(m.observations) || m.observations.length > 30)
+      throw new Error("Invalid model capability record");
+    seen.add(m.id);
+    if (m.researchAttemptedAt !== void 0 && (!Number.isFinite(m.researchAttemptedAt) || m.researchAttemptedAt < 0))
+      throw new Error("Invalid research timestamp");
+    if (m.documented)
+      validateDocumentation(m.documented, c.provider, m.id);
+    for (const o of m.observations)
+      if (!o || Object.keys(o).some((k) => !["runId", "at", "ok", "effort", "durationMs", "errorKind"].includes(k)) || typeof o.runId !== "string" || o.runId.length > 200 || !Number.isFinite(o.at) || typeof o.ok !== "boolean" || typeof o.effort !== "string" || o.effort.length > 12 || !Number.isFinite(o.durationMs) || o.durationMs < 0 || o.errorKind !== void 0 && !/^[a-z_]{1,40}$/.test(o.errorKind))
+        throw new Error("Invalid model observation");
+  }
+  const aliases = /* @__PURE__ */ new Map();
+  for (const model of c.models) for (const alias of model.aliases) {
+    if (seen.has(alias) && alias !== model.id || aliases.has(alias) && aliases.get(alias) !== model.id) throw new Error("Ambiguous model alias");
+    aliases.set(alias, model.id);
+  }
+  if (c.defaultModel !== void 0 && !seen.has(c.defaultModel))
+    throw new Error("Unknown default model");
+  return c;
+}
+function assignmentProblem(c, model, effort) {
+  const entry = c.models.find((m) => m.id === (model || c.defaultModel) || m.aliases.includes(model));
+  if (!entry || entry.availability !== "reported" || entry.compatibility !== "advertised")
+    return `Model ${model || "default"} is not reported by ${c.provider} in this execution environment. Refresh its catalog or choose an eligible model.`;
+  if (effort && !entry.efforts?.includes(effort))
+    return `${entry.id} does not report support for effort ${effort}; choose a listed setting or leave effort at its default`;
+}
+function resolveModelAssignment(c, model, effort, rationale) {
+  const problem = assignmentProblem(c, model, effort);
+  if (problem)
+    throw new Error(problem);
+  const m = c.models.find((m2) => m2.id === (model || c.defaultModel) || m2.aliases.includes(model));
+  return { provider: c.provider, model: m.id, effort, rationale: rationale.slice(0, 2e3), catalogRevision: c.revision, environment: c.environment, verifiedAt: m.verifiedAt, source: m.source, stale: c.state !== "current" };
+}
+function workerConstraintProblem(c, assignment, providers, pin) {
+  if (assignment.provider !== c.provider || providers && !providers.includes(assignment.provider))
+    return "Worker provider is outside the allowed pool";
+  if (!pin)
+    return;
+  const choices = pin.variants?.length ? [pin, ...pin.variants] : [pin];
+  const permits = choices.some((choice) => {
+    const pinnedModel = choice.model || (pin.variants?.length ? c.defaultModel : void 0);
+    const exact = pinnedModel && c.models.find((m) => m.id === pinnedModel || m.aliases.includes(pinnedModel))?.id;
+    return (!pinnedModel || exact === assignment.model) && (!choice.effort || choice.effort === assignment.effort);
+  });
+  if (!permits)
+    return "Worker assignment does not preserve the user's model/effort pins";
+}
+class ModelCatalogStore {
+  constructor(home = CODEFLOW_HOME, discover = (id, context) => {
+    const adapter = getAdapter(id);
+    if (!adapter.discoverModels)
+      return Promise.reject(new Error("Unsupported discovery"));
+    return adapter.discoverModels(context);
+  }, now = Date.now) {
+    this.home = home;
+    this.discover = discover;
+    this.now = now;
+  }
+  tail = Promise.resolve();
+  flights = /* @__PURE__ */ new Map();
+  path(provider, environment) {
+    return join(this.home, "model-catalogs", createHash("sha256").update(provider + environment).digest("hex") + ".json");
+  }
+  async read(provider, environment) {
+    try {
+      const text = await readFile(this.path(provider, environment), "utf8");
+      if (text.length > 4e6)
+        throw new Error("Catalog too large");
+      const c = validateCapabilityCatalog(JSON.parse(text));
+      if (c.provider !== provider || c.environment !== environment)
+        throw new Error("Catalog identity mismatch");
+      return c;
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    }
+  }
+  save(c) {
+    const work = async () => {
+      const latest = await this.read(c.provider, c.environment);
+      if (latest?.accountKey === c.accountKey)
+        for (const m of c.models) {
+          const observations = [...latest?.models.find((v) => v.id === m.id)?.observations ?? [], ...m.observations];
+          m.observations = [...new Map(observations.map((o) => [`${o.runId}:${o.at}:${o.effort}`, o])).values()].sort((a, b) => a.at - b.at).slice(-30);
+        }
+      if (latest && latest.revision > c.revision) {
+        for (const m of latest.models)
+          if (latest.accountKey === c.accountKey)
+            m.observations = c.models.find((v) => v.id === m.id)?.observations ?? m.observations;
+        c = latest;
+      }
+      validateCapabilityCatalog(c);
+      const dir = join(this.home, "model-catalogs");
+      await mkdir(dir, { recursive: true });
+      const path = this.path(c.provider, c.environment), temp = path + "." + randomUUID();
+      try {
+        const file = await open(temp, "wx", 384);
+        try {
+          await file.writeFile(JSON.stringify(c));
+          await file.sync();
+        } finally {
+          await file.close();
+        }
+        await rename(temp, path);
+        if (c.revision > 0) {
+          const snapshot = path.replace(/\.json$/, `.v${c.revision}.json`);
+          try {
+            const evidence = await open(snapshot, "wx", 384);
+            try {
+              await evidence.writeFile(JSON.stringify(c));
+              await evidence.sync();
+            } finally {
+              await evidence.close();
+            }
+          } catch (e) {
+            if (e.code !== "EEXIST")
+              throw e;
+          }
+        }
+        const folder = await open(dir, "r");
+        try {
+          await folder.sync();
+        } finally {
+          await folder.close();
+        }
+      } finally {
+        await rm(temp, { force: true });
+      }
+    };
+    const promise = this.tail.then(work);
+    this.tail = promise.catch(() => {
+    });
+    return promise;
+  }
+  async settings(allowResearch) {
+    const path = join(this.home, "model-catalog-settings.json");
+    if (allowResearch !== void 0) {
+      await mkdir(this.home, { recursive: true });
+      const temp = path + "." + randomUUID();
+      await (await import("node:fs/promises")).writeFile(temp, JSON.stringify({ allowResearch }), { mode: 384 });
+      await rename(temp, path);
+    }
+    return readFile(path, "utf8").then((text) => ({ allowResearch: JSON.parse(text).allowResearch === true })).catch(() => ({ allowResearch: false }));
+  }
+  get(provider, options = {}) {
+    const environment = options.environment ?? modelEnvironment(options.context), key = provider + environment;
+    if (options.offline || process.env.CODEFLOW_MODEL_NETWORK === "offline")
+      return this.refresh(provider, environment, { ...options, offline: true });
+    const active = this.flights.get(key);
+    if (active)
+      return active;
+    const work = this.refresh(provider, environment, options);
+    this.flights.set(key, work);
+    void work.finally(() => this.flights.delete(key)).catch(() => {
+    });
+    return work;
+  }
+  async refresh(provider, environment, options) {
+    const prior = await this.read(provider, environment), now = this.now();
+    const offline = options.offline || process.env.CODEFLOW_MODEL_NETWORK === "offline";
+    if (prior && !options.force && now - prior.attemptedAt < TTL && !offline)
+      return { ...prior, state: !prior.discoveredAt ? "unknown" : now - prior.discoveredAt < TTL ? "current" : "stale" };
+    if (offline)
+      return prior ? { ...prior, state: "stale", issue: "offline" } : { schemaVersion: 1, revision: 0, provider, environment, models: [], discoveredAt: 0, attemptedAt: now, state: "unknown", issue: "offline" };
+    let reported;
+    try {
+      reported = options.reported ?? await this.discover(provider, options.context ?? {});
+    } catch {
+      const failed = prior ? { ...prior, attemptedAt: now, state: "stale", issue: "discovery-unavailable" } : { schemaVersion: 1, revision: 0, provider, environment, models: [], discoveredAt: 0, attemptedAt: now, state: "unknown", issue: "discovery-unavailable" };
+      await this.save(failed);
+      return failed;
+    }
+    const sameAccount = prior?.accountKey === reported.accountKey;
+    const entries = reported.models.map((m) => {
+      const old = sameAccount ? prior?.models.find((p) => p.id === m.id) : void 0;
+      return { id: m.id, label: m.label, aliases: m.aliases ?? [], efforts: m.efforts ?? null, ...m.defaultEffort ? { defaultEffort: m.defaultEffort } : {}, availability: "reported", compatibility: reported.discovery ? "advertised" : "unknown", source: reported.discovery?.source ?? "legacy catalog (account access unknown)", verifiedAt: now, confidence: "reported", documented: old?.documented, researchAttemptedAt: old?.researchAttemptedAt, observations: old?.observations ?? [] };
+    });
+    const result = { schemaVersion: 1, revision: (prior?.revision ?? 0) + 1, provider, environment, accountKey: reported.accountKey, defaultModel: reported.defaultModel, models: entries, discoveredAt: now, attemptedAt: now, state: "current" };
+    validateCapabilityCatalog(result);
+    if ((await this.settings()).allowResearch && !options.context?.agentContainer && !options.reported) {
+      const pending = entries.filter((m) => (!m.documented || now - m.documented.verifiedAt > 7 * 864e5) && (!m.researchAttemptedAt || now - m.researchAttemptedAt > 7 * 864e5)).slice(0, provider === "codex" ? 4 : 800);
+      const proposals = await researchModels(provider, pending.map((m) => m.id)).catch(() => []);
+      for (const m of pending)
+        m.researchAttemptedAt = now;
+      for (const proposal of proposals) {
+        const m = entries.find((m2) => m2.id === proposal.model);
+        if (m)
+          m.documented = validateDocumentation(proposal, provider, m.id);
+      }
+    }
+    await this.save(result);
+    return result;
+  }
+  async observe(assignment, observation) {
+    await this.tail;
+    const c = await this.read(assignment.provider, assignment.environment);
+    if (!c)
+      return;
+    const m = c.models.find((m2) => m2.id === assignment.model);
+    if (!m)
+      return;
+    m.observations = [...m.observations, observation].slice(-30);
+    await this.save(c);
+  }
+}
+const modelCatalogStore = new ModelCatalogStore();
+export {
+  ModelCatalogStore,
+  assignmentProblem,
+  modelCatalogStore,
+  modelEnvironment,
+  resolveModelAssignment,
+  validateCapabilityCatalog,
+  workerConstraintProblem
+};

package/src/model-research.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+const origins = /* @__PURE__ */ new Set(["developers.openai.com", "platform.openai.com", "learn.chatgpt.com", "platform.claude.com", "code.claude.com", "docs.cloud.google.com", "ai.google.dev", "antigravity.google", "www.antigravity.google"]);
+function validateDocumentation(value, provider, model) {
+  const d = value;
+  const allowed = provider === "codex" ? ["developers.openai.com", "platform.openai.com", "learn.chatgpt.com"] : provider === "claude" ? ["platform.claude.com", "code.claude.com"] : ["docs.cloud.google.com", "ai.google.dev", "antigravity.google", "www.antigravity.google"];
+  let url;
+  try {
+    url = new URL(d.source);
+  } catch {
+    throw new Error("Invalid documentation source");
+  }
+  if (!d || Object.keys(d).some((k) => !["model", "contextTokens", "maxOutputTokens", "capabilities", "pricing", "source", "digest", "verifiedAt", "confidence"].includes(k)) || d.model !== model || url.protocol !== "https:" || !allowed.includes(url.hostname) || url.username || url.password || url.port || !/^[a-f0-9]{64}$/.test(d.digest) || !Number.isFinite(d.verifiedAt) || d.confidence !== "documented" || d.capabilities !== null && (!Array.isArray(d.capabilities) || d.capabilities.length > 12 || d.capabilities.some((c) => !["text", "image", "audio", "tools", "structured-output"].includes(c))))
+    throw new Error("Invalid documentation proposal");
+  for (const n of [d.contextTokens, d.maxOutputTokens])
+    if (n !== null && (!Number.isSafeInteger(n) || n < 1 || n > 1e8))
+      throw new Error("Invalid documented token limit");
+  if (d.pricing !== null && (!d.pricing || Object.keys(d.pricing).sort().join() !== "currency,inputPerMillion,outputPerMillion" || d.pricing.currency !== "USD" || [d.pricing.inputPerMillion, d.pricing.outputPerMillion].some((n) => !Number.isFinite(n) || n < 0 || n > 1e5)))
+    throw new Error("Invalid documented price");
+  return d;
+}
+function proposeDocumentation(provider, model, source, text, now = Date.now()) {
+  if (!text.includes(model))
+    return;
+  const plain = text.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const number = (pattern) => {
+    const found = plain.match(pattern)?.[1];
+    return found ? Number(found.replaceAll(",", "")) : null;
+  };
+  const exactPage = provider === "codex" && new URL(source).pathname.replace(/\/$/, "").endsWith("/" + model);
+  const contextTokens = exactPage ? number(/([\d,]+)\s+(?:token\s+)?context window/i) : null;
+  const maxOutputTokens = exactPage ? number(/([\d,]+)\s+(?:max(?:imum)?\s+output|output limit)/i) : null;
+  const price = exactPage ? plain.match(/Input\s*\$([\d.]+)[\s\S]{0,160}?Output\s*\$([\d.]+)/i) : null;
+  const d = { model, contextTokens, maxOutputTokens, capabilities: null, pricing: price && /per\s+(?:1M|million)\s+tokens/i.test(plain) ? { currency: "USD", inputPerMillion: Number(price[1]), outputPerMillion: Number(price[2]) } : null, source, digest: createHash("sha256").update(text).digest("hex"), verifiedAt: now, confidence: "documented" };
+  return validateDocumentation(d, provider, model);
+}
+async function officialText(source, fetcher) {
+  let url = new URL(source);
+  for (let i = 0; i < 4; i++) {
+    if (url.protocol !== "https:" || !origins.has(url.hostname) || url.username || url.password || url.port)
+      throw new Error("Research must stay on official documentation origins");
+    const response = await fetcher(url, { redirect: "manual", signal: AbortSignal.timeout(6e3), headers: { Accept: "text/markdown, text/html, text/plain" } });
+    if ([301, 302, 303, 307, 308].includes(response.status)) {
+      const location = response.headers.get("location");
+      if (!location)
+        throw new Error("Invalid redirect");
+      url = new URL(location, url);
+      continue;
+    }
+    if (!response.ok || !response.body)
+      throw new Error("Documentation unavailable");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        bytes += value.length;
+        if (bytes > 2e6)
+          throw new Error("Documentation too large");
+        chunks.push(value);
+      }
+    } finally {
+      await reader.cancel();
+    }
+    return { source: url.href, text: Buffer.concat(chunks).toString("utf8") };
+  }
+  throw new Error("Too many documentation redirects");
+}
+async function researchModels(provider, models, fetcher = fetch) {
+  const result = [];
+  const pages = provider === "codex" ? models.filter((m) => /^[\w.-]+$/.test(m)).slice(0, 4).map((m) => ({ source: `https://developers.openai.com/api/docs/models/${m}`, models: [m] })) : [{ source: provider === "claude" ? "https://platform.claude.com/docs/en/about-claude/models/overview" : "https://antigravity.google/docs/models", models }];
+  await Promise.all(pages.map(async (page) => {
+    try {
+      const { source, text } = await officialText(page.source, fetcher);
+      for (const model of page.models) {
+        const d = proposeDocumentation(provider, model, source, text);
+        if (d)
+          result.push(d);
+      }
+    } catch {
+    }
+  }));
+  return result;
+}
+export {
+  proposeDocumentation,
+  researchModels,
+  validateDocumentation
+};

package/src/notes.js

@@ -0,0 +1,176 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { CODEFLOW_HOME } from "./config.js";
+const FILE = join(CODEFLOW_HOME, "notes.json");
+const MAX_NOTE_CHARS = 2e5;
+const MAX_NOTE_REVISIONS = 50;
+const queues = /* @__PURE__ */ new Map();
+class NotesConflictError extends Error {
+  constructor(current) {
+    super(`Note revision conflict: the current note is at revision ${current.revision}`);
+    this.current = current;
+    this.name = "NotesConflictError";
+  }
+}
+class Notes {
+  file;
+  constructor(file = FILE) {
+    this.file = resolve(file);
+  }
+  async get(key) {
+    await queues.get(this.file);
+    const document = await readDocument(this.file);
+    return copy(document.notes[normalize(key)] ?? empty());
+  }
+  /** Omitting expectedRevision keeps older clients compatible; new clients should send it. */
+  set(key, text, expectedRevision) {
+    if (typeof text !== "string") return Promise.reject(new Error("Send the note's text"));
+    if (text.length > MAX_NOTE_CHARS) return Promise.reject(new Error(`A note can hold ${MAX_NOTE_CHARS.toLocaleString()} characters at most`));
+    if (!validRevision(expectedRevision)) return Promise.reject(new Error("Expected note revision must be a non-negative integer"));
+    return this.change((document) => this.update(document, normalize(key), text, expectedRevision));
+  }
+  /** Retained revisions, newest first. An untouched scratchpad has no history. */
+  async history(key) {
+    await queues.get(this.file);
+    const document = await readDocument(this.file);
+    const normalized = normalize(key);
+    return (document.history[normalized] ?? (document.notes[normalized] ? [document.notes[normalized]] : [])).map(copy);
+  }
+  restore(key, revision, expectedRevision) {
+    if (!Number.isSafeInteger(revision) || revision < 1) return Promise.reject(new Error("Choose a saved note revision to restore"));
+    if (expectedRevision === void 0 || !validRevision(expectedRevision)) return Promise.reject(new Error("Restoring a note needs its current revision"));
+    return this.change((document) => {
+      const normalized = normalize(key);
+      const current = document.notes[normalized] ?? empty();
+      if (current.revision !== expectedRevision) throw new NotesConflictError(copy(current));
+      const historical = document.history[normalized]?.find((note) => note.revision === revision) ?? (current.revision === revision ? current : void 0);
+      if (!historical) throw new Error("That note revision is no longer available");
+      return this.update(document, normalized, historical.text, expectedRevision, revision);
+    });
+  }
+  /** Which non-empty notes exist, newest first. */
+  async keys() {
+    await queues.get(this.file);
+    const document = await readDocument(this.file);
+    return Object.entries(document.notes).filter(([, note]) => !!note.text).map(([key, note]) => ({ key, updatedAt: note.updatedAt, revision: note.revision })).sort((a, b) => b.updatedAt - a.updatedAt || a.key.localeCompare(b.key));
+  }
+  /** Search current saved text only; historical/erased revisions are never returned by search. */
+  async search(query) {
+    if (typeof query !== "string" || query.length > 300) throw new Error("Notes search supports up to 300 characters");
+    await queues.get(this.file);
+    const document = await readDocument(this.file);
+    const needle = query.trim().toLowerCase();
+    const ordered = Object.entries(document.notes).filter(([, note]) => !!note.text).sort((a, b) => b[1].updatedAt - a[1].updatedAt);
+    const hits = [];
+    let inspected = 0;
+    for (const [key, note] of ordered) {
+      if (inspected >= 5e3 || hits.length >= 100) break;
+      inspected++;
+      const position = note.text.toLowerCase().indexOf(needle);
+      if (needle && position < 0 && !key.toLowerCase().includes(needle)) continue;
+      const start = Math.max(0, position - 60);
+      hits.push({ key, revision: note.revision, updatedAt: note.updatedAt, excerpt: note.text.slice(start, start + 300) });
+    }
+    return { hits, inspected, truncated: inspected < ordered.length };
+  }
+  update(document, key, text, expectedRevision, restoredFrom) {
+    const current = document.notes[key] ?? empty();
+    if (expectedRevision !== void 0 && current.revision !== expectedRevision) throw new NotesConflictError(copy(current));
+    if (text === current.text && restoredFrom === void 0) return copy(current);
+    const note = {
+      text,
+      updatedAt: Math.max(Date.now(), current.updatedAt + 1),
+      revision: current.revision + 1,
+      ...restoredFrom === void 0 ? {} : { restoredFrom }
+    };
+    document.notes[key] = note;
+    document.history[key] = [note, ...document.history[key] ?? (current.revision ? [current] : [])].slice(0, MAX_NOTE_REVISIONS);
+    return copy(note);
+  }
+  change(mutate) {
+    const next = (queues.get(this.file) ?? Promise.resolve()).then(async () => {
+      const document = await readDocument(this.file);
+      const before = JSON.stringify(document);
+      const result = mutate(document);
+      if (JSON.stringify(document) !== before) await writeDocument(this.file, document);
+      return result;
+    });
+    const settled = next.catch(() => void 0);
+    queues.set(this.file, settled);
+    void settled.then(() => {
+      if (queues.get(this.file) === settled) queues.delete(this.file);
+    });
+    return next;
+  }
+}
+const empty = () => ({ text: "", updatedAt: 0, revision: 0 });
+const copy = (note) => ({ ...note });
+const validRevision = (revision) => revision === void 0 || Number.isSafeInteger(revision) && Number(revision) >= 0;
+async function readDocument(file) {
+  const document = { version: 2, notes: /* @__PURE__ */ Object.create(null), history: /* @__PURE__ */ Object.create(null) };
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return document;
+    throw new Error(`Notes store cannot be read: ${error.message}`);
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Notes store cannot be read: invalid document");
+  const versioned = raw.version === 2;
+  const notes = versioned ? raw.notes : raw;
+  if (!notes || typeof notes !== "object" || Array.isArray(notes)) throw new Error("Notes store cannot be read: invalid notes");
+  const decode = (value, legacy = false) => {
+    if (!value || typeof value.text !== "string" || value.text.length > MAX_NOTE_CHARS) throw new Error("Notes store cannot be read: invalid note");
+    const revision = legacy ? 1 : value.revision;
+    if (!Number.isSafeInteger(revision) || revision < 1) throw new Error("Notes store cannot be read: invalid revision");
+    return {
+      text: value.text,
+      updatedAt: Number(value.updatedAt) || 0,
+      revision,
+      ...Number.isSafeInteger(value.restoredFrom) && value.restoredFrom >= 1 ? { restoredFrom: value.restoredFrom } : {}
+    };
+  };
+  for (const [key, value] of Object.entries(notes)) {
+    const normalized = normalize(key);
+    const current = decode(value, !versioned);
+    document.notes[normalized] = current;
+    const saved = versioned && raw.history && Array.isArray(raw.history[key]) ? raw.history[key].map((note) => decode(note)) : [];
+    const byRevision = new Map(saved.filter((note) => note.revision < current.revision).map((note) => [note.revision, note]));
+    document.history[normalized] = [current, ...[...byRevision.values()].sort((a, b) => b.revision - a.revision)].slice(0, MAX_NOTE_REVISIONS);
+  }
+  return document;
+}
+async function writeDocument(file, document) {
+  await mkdir(dirname(file), { recursive: true });
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 384);
+    await handle.writeFile(JSON.stringify(document, null, 2));
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await rename(temporary, file);
+    if (process.platform !== "win32") {
+      const directory = await open(dirname(file), "r");
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
+      }
+    }
+  } finally {
+    await handle?.close().catch(() => {
+    });
+    await rm(temporary, { force: true }).catch(() => {
+    });
+  }
+}
+const normalize = (key) => key.startsWith("/") ? key.replace(/\/+$/, "") || "/" : "general";
+export {
+  MAX_NOTE_CHARS,
+  MAX_NOTE_REVISIONS,
+  Notes,
+  NotesConflictError
+};