agentic-canvas 0.7.0 → 0.9.0

package/dist/chunk-UKST5A57.js

@@ -1,228 +0,0 @@
-import {
-  FileStoreError
-} from "./chunk-NWQED42L.js";
-
-// src/store-file.ts
-import { randomUUID } from "crypto";
-import { mkdirSync } from "fs";
-import { link, open, readFile, rename, unlink } from "fs/promises";
-import { join } from "path";
-import { assertCollection, assertId, createMemoryStore, parseRegion, StoreConflictError } from "agentic-identity";
-var MAX_TRANSACTION_RUNS = 50;
-var clone = (value) => JSON.parse(JSON.stringify(value));
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var codeOf = (error) => error?.code;
-function processIsAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return codeOf(error) === "EPERM";
-  }
-}
-function lockIsStale(text, staleAfterMs) {
-  let held;
-  try {
-    held = JSON.parse(text);
-  } catch {
-    return false;
-  }
-  if (typeof held !== "object" || held === null) return false;
-  const { pid, at } = held;
-  if (typeof pid !== "number" || !Number.isInteger(pid) || pid < 1 || typeof at !== "number" || !Number.isFinite(at)) return false;
-  return !processIsAlive(pid) || Date.now() - at > staleAfterMs;
-}
-function createFileStore(path, options = {}) {
-  const region = parseRegion(options.region ?? "unknown");
-  const lockPath = `${path}.lock`;
-  const timeoutMs = options.lockTimeoutMs ?? 1e4;
-  const staleAfterMs = options.staleAfterMs ?? 3e4;
-  for (const ms of [timeoutMs, staleAfterMs]) if (typeof ms !== "number" || !Number.isFinite(ms) || ms < 0) throw new TypeError("lockTimeoutMs and staleAfterMs must be finite numbers of 0 or more");
-  let queue = Promise.resolve();
-  async function load() {
-    let text;
-    try {
-      text = await readFile(path, "utf8");
-    } catch (error) {
-      if (codeOf(error) === "ENOENT") return /* @__PURE__ */ new Map();
-      throw error;
-    }
-    try {
-      const data = JSON.parse(text);
-      if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error();
-      return new Map(
-        Object.entries(data).map(([name, docs]) => {
-          if (typeof docs !== "object" || docs === null || Array.isArray(docs)) throw new Error();
-          for (const doc of Object.values(docs)) if (typeof doc !== "object" || doc === null || Array.isArray(doc)) throw new Error();
-          return [name, new Map(Object.entries(docs))];
-        })
-      );
-    } catch {
-      throw new FileStoreError("DAMAGED", `the database file is not valid JSON. Repair or remove it`);
-    }
-  }
-  async function save(snapshot) {
-    const text = JSON.stringify(Object.fromEntries([...snapshot].map(([name, docs]) => [name, Object.fromEntries(docs)])));
-    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-      const handle = await open(temp, "w");
-      try {
-        await handle.writeFile(text);
-        await handle.sync();
-      } finally {
-        await handle.close();
-      }
-      await rename(temp, path);
-    } catch (error) {
-      await unlink(temp).catch(() => void 0);
-      throw error;
-    }
-  }
-  async function takeOverIfStale() {
-    let seen;
-    try {
-      seen = await readFile(lockPath, "utf8");
-    } catch {
-      return;
-    }
-    if (!lockIsStale(seen, staleAfterMs)) return;
-    const aside = `${lockPath}.stale.${randomUUID()}`;
-    try {
-      await rename(lockPath, aside);
-    } catch {
-      return;
-    }
-    if (await readFile(aside, "utf8").catch(() => "") !== seen) await link(aside, lockPath).catch(() => void 0);
-    await unlink(aside).catch(() => void 0);
-  }
-  async function acquire() {
-    const token = randomUUID();
-    const deadline = Date.now() + timeoutMs;
-    for (; ; ) {
-      try {
-        const handle = await open(lockPath, "wx");
-        try {
-          await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now(), token }));
-        } finally {
-          await handle.close();
-        }
-        return token;
-      } catch (error) {
-        if (codeOf(error) !== "EEXIST") throw error;
-      }
-      await takeOverIfStale();
-      if (Date.now() > deadline) throw new FileStoreError("LOCKED", `the database file is locked. If no agentic-canvas process runs, remove the .lock file next to it`);
-      await sleep(5 + Math.random() * 15);
-    }
-  }
-  async function release(token) {
-    const text = await readFile(lockPath, "utf8").catch(() => "");
-    if (text.includes(`"token":"${token}"`)) await unlink(lockPath).catch(() => void 0);
-  }
-  async function memoryOf(snapshot, only) {
-    const memory = createMemoryStore({ region });
-    for (const [name, docs] of snapshot) if (only === void 0 || only === name) for (const [id, doc] of docs) await memory.put(name, id, doc);
-    return memory;
-  }
-  const recording = (inner, log) => ({
-    get: (collection, id) => inner.get(collection, id),
-    query: (collection, query) => inner.query(collection, query),
-    put: async (collection, id, doc) => {
-      await inner.put(collection, id, doc);
-      log.push([collection, id, clone(doc)]);
-    },
-    delete: async (collection, id) => {
-      await inner.delete(collection, id);
-      log.push([collection, id, null]);
-    }
-  });
-  const locked = (body) => {
-    const run = queue.then(async () => {
-      const token = await acquire();
-      try {
-        return await body();
-      } finally {
-        await release(token);
-      }
-    });
-    queue = run.catch(() => void 0);
-    return run;
-  };
-  async function commit(snapshot, log) {
-    for (const [name, id, doc] of log) {
-      if (doc === null) snapshot.get(name)?.delete(id);
-      else snapshot.set(name, (snapshot.get(name) ?? /* @__PURE__ */ new Map()).set(id, doc));
-    }
-    if (log.length > 0) await save(snapshot);
-  }
-  const writeOne = (write) => locked(async () => {
-    const log = [];
-    await write(recording(createMemoryStore({ region }), log));
-    await commit(await load(), log);
-  });
-  const watching = (inner, seen) => ({
-    ...inner,
-    async get(collection, id) {
-      const doc = await inner.get(collection, id);
-      if (!seen.has(`${collection}/${id}`)) seen.set(`${collection}/${id}`, JSON.stringify(doc));
-      return doc;
-    },
-    async query(collection, query) {
-      const page = await inner.query(collection, query);
-      for (const item of page.items) if (!seen.has(`${collection}/${item.id}`)) seen.set(`${collection}/${item.id}`, JSON.stringify(item.data));
-      return page;
-    }
-  });
-  const unchanged = (snapshot, seen) => [...seen].every(([key, text]) => {
-    const slash = key.indexOf("/");
-    return JSON.stringify(snapshot.get(key.slice(0, slash))?.get(key.slice(slash + 1)) ?? null) === text;
-  });
-  return {
-    region,
-    async get(collection, id) {
-      assertCollection(collection);
-      assertId(id);
-      const doc = (await load()).get(collection)?.get(id);
-      return doc ? clone(doc) : null;
-    },
-    async query(collection, query) {
-      assertCollection(collection);
-      return (await memoryOf(await load(), collection)).query(collection, query);
-    },
-    put: (collection, id, doc) => writeOne((ops) => ops.put(collection, id, doc)),
-    delete: (collection, id) => writeOne((ops) => ops.delete(collection, id)),
-    // Optimistic, as the port requires: run on a copy of the file with no lock, then take the lock and commit
-    // only if every doc the run read is unchanged. Else run again. The memory adapter keeps the rule that
-    // every read comes before the first write.
-    async transaction(fn) {
-      for (let run = 0; run < MAX_TRANSACTION_RUNS; run++) {
-        const log = [];
-        const seen = /* @__PURE__ */ new Map();
-        const result = await (await memoryOf(await load())).transaction(async (tx) => {
-          log.length = 0;
-          seen.clear();
-          return fn(watching(recording(tx, log), seen));
-        });
-        const done = log.length === 0 ? unchanged(await load(), seen) : await locked(async () => {
-          const current = await load();
-          if (!unchanged(current, seen)) return false;
-          await commit(current, log);
-          return true;
-        });
-        if (done) return result;
-      }
-      throw new StoreConflictError();
-    }
-  };
-}
-function openLocalStore(dir) {
-  mkdirSync(dir, { recursive: true });
-  return createFileStore(join(dir, STORE_FILE));
-}
-var STORE_FILE = "canvas.json";
-
-export {
-  createFileStore,
-  openLocalStore,
-  STORE_FILE
-};