agentic-drive 0.0.0-stage → 0.1.0

package/dist/chunk-QRGKXPLX.js

@@ -0,0 +1,935 @@
+// src/drive.ts
+var ROOT_ID = "root";
+var NODES = "drive_nodes";
+var NAMES = "drive_names";
+var ACTOR_KINDS = ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
+var DriveError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "DriveError";
+  }
+  code;
+};
+var MAX_PATH_SEGMENTS = 64;
+var DEFAULT_MAX_DEPTH = 256;
+var CHUNK = 25;
+var DEFAULT_URL_SECONDS = 900;
+var MAX_URL_SECONDS = 3600;
+var OPAQUE = "application/octet-stream";
+var MIME_SHAPE = /^[a-z0-9][a-z0-9!#$&^_.+-]{0,63}\/[a-z0-9][a-z0-9!#$&^_.+-]{0,63}$/;
+var ACTIVE_TYPES = /* @__PURE__ */ new Set([
+  "text/html",
+  "application/xhtml+xml",
+  "image/svg+xml",
+  "text/xml",
+  "application/xml",
+  "text/javascript",
+  "application/javascript",
+  "application/x-javascript",
+  "text/ecmascript",
+  "application/ecmascript",
+  "text/css"
+]);
+function safeMime(claimed) {
+  const type = (claimed ?? "").trim().toLowerCase();
+  return MIME_SHAPE.test(type) && !ACTIVE_TYPES.has(type) ? type : OPAQUE;
+}
+async function sha256Hex(data) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", data);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var REF = /^[a-z][a-z0-9_-]*:[^\s/]+$/;
+function parseName(raw) {
+  const name = raw.normalize("NFC");
+  if (name.trim() === "" || /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/.test(name) || name === "." || name === ".." || /[/\u0000-\u001f\u007f]/.test(name) || new TextEncoder().encode(name).length > 255) {
+    throw new DriveError("INVALID_NAME", `invalid name ${JSON.stringify(raw)}`);
+  }
+  return { name, key: name.toLowerCase() };
+}
+function splitPath(path) {
+  if (!path.startsWith("/")) throw new DriveError("INVALID_PATH", `path must start with "/": ${path}`);
+  const rest = path.replace(/\/$/, "").slice(1);
+  if (rest === "") return [];
+  const parts = rest.split("/");
+  if (parts.includes("")) throw new DriveError("INVALID_PATH", `empty segment in path: ${path}`);
+  if (parts.length > MAX_PATH_SEGMENTS) throw new DriveError("TOO_DEEP", `a path has at most ${MAX_PATH_SEGMENTS} segments`);
+  return parts.map(parseName);
+}
+function batch() {
+  const writes = [];
+  const fresh = /* @__PURE__ */ new Set();
+  return {
+    fresh,
+    put: (collection, id, doc) => void writes.push({ collection, id, doc }),
+    remove: (collection, id) => void writes.push({ collection, id, doc: null }),
+    async apply(ops) {
+      for (const w of writes) await (w.doc ? ops.put(w.collection, w.id, w.doc) : ops.delete(w.collection, w.id));
+    }
+  };
+}
+var claimId = (owner, parentId, key) => sha256Hex(new TextEncoder().encode(`${owner}\0${parentId}\0${key}`));
+function createDrive(deps) {
+  const { store, blobs } = deps;
+  const now = deps.now ?? Date.now;
+  const newId = deps.newId ?? (() => globalThis.crypto.randomUUID());
+  const maxDepth = deps.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const onOrphan = deps.onOrphan ?? ((key, error) => console.error(`orphan blob ${key}: ${error instanceof Error ? error.name : "delete failed"}`));
+  const can = deps.can ?? ((ctx, _action, node) => node.owner === ctx.owner);
+  const rootNode = (ctx) => ({
+    id: ROOT_ID,
+    owner: ctx.owner,
+    parentId: "",
+    kind: "folder",
+    name: "",
+    nameKey: "",
+    size: 0,
+    mime: null,
+    hash: null,
+    ref: null,
+    blobKey: null,
+    createdAt: 0,
+    updatedAt: 0,
+    createdBy: ctx.actor,
+    updatedBy: ctx.actor,
+    trashed: false,
+    trashedAt: null,
+    purging: false
+  });
+  const who = (ctx) => ({ id: ctx.actor.id, kind: ctx.actor.kind });
+  async function fetch(ops, ctx, id, purgeAgain = false) {
+    const node = id === ROOT_ID ? rootNode(ctx) : await ops.get(NODES, id);
+    return node && (purgeAgain || node.purging !== true) && await can(ctx, "read", node) ? node : null;
+  }
+  async function need(ctx, action, node) {
+    if (!await can(ctx, action, node)) throw new DriveError("FORBIDDEN", `not allowed to ${action} ${node.id}`);
+  }
+  async function children(ops, owner, parentId, extra = {}) {
+    const out = [];
+    for (let cursor; ; ) {
+      const page = await ops.query(NODES, { where: { owner, parentId, ...extra }, limit: 100, cursor });
+      out.push(...page.items.map((item) => item.data));
+      if (!page.nextCursor) return out;
+      cursor = page.nextCursor;
+    }
+  }
+  async function claimed(ops, owner, parentId, key) {
+    const claim = await ops.get(NAMES, await claimId(owner, parentId, key));
+    const found = claim ? await ops.get(NODES, claim.nodeId) : null;
+    const node = found && !found.trashed && found.purging !== true && found.parentId === parentId && found.nameKey === key ? found : null;
+    return { taken: claim !== null, node };
+  }
+  const liveChild = async (ops, ctx, parentId, key) => (await claimed(ops, ctx.owner, parentId, key)).node;
+  async function isLive(ops, ctx, node) {
+    for (let n = node, depth = 0; n && depth < maxDepth; depth++) {
+      if (n.trashed) return false;
+      if (n.id === ROOT_ID) return true;
+      n = await fetch(ops, ctx, n.parentId);
+    }
+    return false;
+  }
+  async function resolve(ops, ctx, loc) {
+    if (!loc.startsWith("/")) {
+      const node2 = await fetch(ops, ctx, loc);
+      if (!node2) throw new DriveError("NOT_FOUND", `no item ${loc}`);
+      if (!await isLive(ops, ctx, node2)) throw new DriveError("TRASHED", `${loc} is in the trash`);
+      return node2;
+    }
+    let node = rootNode(ctx);
+    for (const seg of splitPath(loc)) {
+      if (node.kind !== "folder") throw new DriveError("NOT_A_FOLDER", `${node.name} is not a folder`);
+      const next = await liveChild(ops, ctx, node.id, seg.key);
+      if (!next) throw new DriveError("NOT_FOUND", `no item ${loc}`);
+      node = next;
+    }
+    if (!await can(ctx, "read", node)) throw new DriveError("NOT_FOUND", `no item ${loc}`);
+    return node;
+  }
+  async function freeName(ops, ctx, parentId, name) {
+    const dot = name.lastIndexOf(".");
+    const [base, ext] = dot > 0 ? [name.slice(0, dot), name.slice(dot)] : [name, ""];
+    for (let n = 2; ; n++) {
+      const candidate = `${base} (${n})${ext}`;
+      if (!(await claimed(ops, ctx.owner, parentId, parseName(candidate).key)).taken) return candidate;
+    }
+  }
+  async function folderAt(ops, w, ctx, segs, create) {
+    let node = rootNode(ctx);
+    for (const seg of segs) {
+      if (node.kind !== "folder") throw new DriveError("NOT_A_FOLDER", `${node.name} is not a folder`);
+      let next = w.fresh.has(node.id) ? null : await liveChild(ops, ctx, node.id, seg.key);
+      if (!next) {
+        if (!create) throw new DriveError("NOT_FOUND", `no folder ${seg.name}`);
+        next = (await insert(ops, w, ctx, node, seg.name, { kind: "folder" }, "fail")).node;
+        w.fresh.add(next.id);
+      }
+      node = next;
+    }
+    if (node.kind !== "folder") throw new DriveError("NOT_A_FOLDER", `${node.name} is not a folder`);
+    return node;
+  }
+  async function insert(ops, w, ctx, parent, rawName, fields, onConflict) {
+    let { name, key } = parseName(rawName);
+    const empty = w.fresh.has(parent.id);
+    if (!empty) await need(ctx, "write", parent);
+    const slot = empty ? null : await claimed(ops, ctx.owner, parent.id, key);
+    if (slot?.taken) {
+      if (onConflict === "replace" && slot.node?.kind === "file" && fields.kind === "file") {
+        const node2 = { ...slot.node, ...fields, updatedAt: now(), updatedBy: who(ctx) };
+        w.put(NODES, node2.id, node2);
+        return { node: node2, replacedBlob: slot.node.blobKey };
+      }
+      if (onConflict !== "rename") throw new DriveError("NAME_TAKEN", `"${name}" already exists`);
+      name = await freeName(ops, ctx, parent.id, name);
+      key = parseName(name).key;
+    }
+    const t = now();
+    const node = {
+      id: newId(),
+      owner: ctx.owner,
+      parentId: parent.id,
+      kind: "file",
+      name,
+      nameKey: key,
+      size: 0,
+      mime: null,
+      hash: null,
+      ref: null,
+      blobKey: null,
+      createdAt: t,
+      updatedAt: t,
+      createdBy: who(ctx),
+      updatedBy: who(ctx),
+      trashed: false,
+      trashedAt: null,
+      purging: false,
+      ...fields
+    };
+    w.put(NODES, node.id, node);
+    w.put(NAMES, await claimId(ctx.owner, parent.id, key), { nodeId: node.id, owner: ctx.owner, parentId: parent.id });
+    return { node, replacedBlob: null };
+  }
+  async function parentAndName(ops, w, ctx, path, parents) {
+    const segs = splitPath(path);
+    const last = segs.pop();
+    if (!last) throw new DriveError("IS_ROOT", "the root already exists");
+    return { parent: await folderAt(ops, w, ctx, segs, parents), name: last.name };
+  }
+  async function relocate(ops, w, ctx, node, destLoc, opts) {
+    if (node.id === ROOT_ID) throw new DriveError("IS_ROOT", "cannot change the root");
+    const dest = await resolve(ops, ctx, destLoc);
+    if (dest.kind !== "folder") throw new DriveError("NOT_A_FOLDER", `${dest.name} is not a folder`);
+    for (let n = dest, depth = 0; n.id !== ROOT_ID; depth++) {
+      if (n.id === node.id) throw new DriveError("MOVE_INTO_SELF", `cannot move ${node.name} into itself`);
+      if (depth >= maxDepth) throw new DriveError("TOO_DEEP", `the destination is deeper than ${maxDepth} folders`);
+      const parent = await fetch(ops, ctx, n.parentId);
+      if (!parent) throw new DriveError("NOT_FOUND", `a parent folder of ${dest.name} is missing`);
+      n = parent;
+    }
+    await need(ctx, "write", node);
+    await need(ctx, "write", dest);
+    let { name, key } = parseName(opts.name ?? node.name);
+    const slot = await claimed(ops, ctx.owner, dest.id, key);
+    if (slot.taken && slot.node?.id !== node.id) {
+      if (opts.onConflict !== "rename") throw new DriveError("NAME_TAKEN", `"${name}" already exists`);
+      name = await freeName(ops, ctx, dest.id, name);
+      key = parseName(name).key;
+    }
+    const moved = { ...node, parentId: dest.id, name, nameKey: key, updatedAt: now(), updatedBy: who(ctx) };
+    w.put(NODES, moved.id, moved);
+    const [from, to] = [await claimId(ctx.owner, node.parentId, node.nameKey), await claimId(ctx.owner, dest.id, key)];
+    if (from !== to) {
+      if ((await ops.get(NAMES, from))?.nodeId === node.id) w.remove(NAMES, from);
+      w.put(NAMES, to, { nodeId: moved.id, owner: ctx.owner, parentId: dest.id });
+    }
+    return moved;
+  }
+  async function isUnreferenced(ctx, blobKey) {
+    try {
+      return (await store.query(NODES, { where: { owner: ctx.owner, blobKey }, limit: 1 })).items.length === 0;
+    } catch (error) {
+      onOrphan(blobKey, error);
+      return false;
+    }
+  }
+  async function dropBlob(key) {
+    try {
+      await blobs.delete(key);
+    } catch (error) {
+      onOrphan(key, error);
+    }
+  }
+  async function ownerNodes(ctx, withMarked = false) {
+    const root = rootNode(ctx);
+    if (!await can(ctx, "read", root)) throw new DriveError("FORBIDDEN", "not allowed to read this drive");
+    const out = [];
+    for (let cursor; ; ) {
+      const page = await store.query(NODES, { where: { owner: ctx.owner }, limit: 100, cursor });
+      out.push(...page.items.map((item) => item.data).filter((node) => withMarked || node.purging !== true));
+      if (!page.nextCursor) return out;
+      cursor = page.nextCursor;
+    }
+  }
+  function pathIn(byId, node, liveOnly) {
+    const names = [];
+    for (let n = node, depth = 0; depth < 1e3; depth++) {
+      if (!n) return liveOnly ? null : `/(orphan)/${names.reverse().join("/")}`;
+      if (liveOnly && n.trashed) return null;
+      names.push(n.name);
+      if (n.parentId === ROOT_ID) return `/${names.reverse().join("/")}`;
+      n = byId.get(n.parentId);
+    }
+    return null;
+  }
+  async function transact(fn) {
+    try {
+      return await store.transaction(fn);
+    } catch (error) {
+      if (error instanceof Error && /transaction kept conflicting/.test(error.message)) throw new DriveError("BUSY", "the drive changed at the same time. Try again.");
+      throw error;
+    }
+  }
+  async function removeNodes(nodes, top) {
+    const unchanged = (now2, seen) => now2 !== null && now2.trashed === seen.trashed && now2.parentId === seen.parentId && now2.updatedAt === seen.updatedAt;
+    const marked = [];
+    const markedIds = /* @__PURE__ */ new Set();
+    for (let i = 0; i < nodes.length; i += CHUNK) {
+      const slice = nodes.slice(i, i + CHUNK);
+      for (const node of slice) {
+        if (node.purging === true) {
+          marked.push(node);
+          markedIds.add(node.id);
+        }
+      }
+      const found = await transact(async (tx) => {
+        const out = [];
+        const ids = new Set(markedIds);
+        for (const node of slice) {
+          if (node.purging === true) continue;
+          if (top && node.id !== top.id && !ids.has(node.parentId)) continue;
+          const current = await tx.get(NODES, node.id);
+          if (unchanged(current, node)) {
+            out.push(current);
+            ids.add(node.id);
+          }
+        }
+        for (const node of out) await tx.put(NODES, node.id, { ...node, purging: true });
+        return out;
+      });
+      for (const node of found) {
+        marked.push(node);
+        markedIds.add(node.id);
+      }
+      if (top && i === 0 && !markedIds.has(top.id)) throw new DriveError("BUSY", `${top.name} changed during the purge. Nothing was deleted.`);
+    }
+    const rows = marked.reverse();
+    for (let i = 0; i < rows.length; i += CHUNK) {
+      const chunk = rows.slice(i, i + CHUNK);
+      for (const node of chunk) if (node.blobKey) await blobs.delete(node.blobKey);
+      await transact(async (tx) => {
+        const held = [];
+        for (const node of chunk) {
+          const claim = node.trashed ? null : await claimId(node.owner, node.parentId, node.nameKey);
+          held.push({ node, claim, owns: claim !== null && (await tx.get(NAMES, claim))?.nodeId === node.id });
+        }
+        for (const { node, claim, owns } of held) {
+          await tx.delete(NODES, node.id);
+          if (claim && owns) await tx.delete(NAMES, claim);
+        }
+      });
+    }
+    return marked.length;
+  }
+  const api = {
+    async stat(ctx, loc) {
+      return resolve(store, ctx, loc);
+    },
+    /** Live children, sorted by name. */
+    async list(ctx, loc = "/") {
+      const folder = await resolve(store, ctx, loc);
+      if (folder.kind !== "folder") throw new DriveError("NOT_A_FOLDER", `${folder.name} is not a folder`);
+      return (await children(store, folder.owner, folder.id)).filter((n) => !n.trashed && n.purging !== true).sort((a, b) => a.nameKey < b.nameKey ? -1 : a.nameKey > b.nameKey ? 1 : a.name < b.name ? -1 : 1);
+    },
+    async mkdir(ctx, path, opts = {}) {
+      return transact(async (tx) => {
+        const w = batch();
+        const { parent, name } = await parentAndName(tx, w, ctx, path, opts.parents ?? false);
+        const existing = w.fresh.has(parent.id) ? null : await liveChild(tx, ctx, parent.id, parseName(name).key);
+        if (opts.parents && existing?.kind === "folder") return existing;
+        const { node } = await insert(tx, w, ctx, parent, name, { kind: "folder" }, "fail");
+        await w.apply(tx);
+        return node;
+      });
+    },
+    /**
+     * Stores one blob and one node. The blob is written first. The new node commits before
+     * any old blob goes. A failed old-blob delete leaves an orphan and never undoes the commit.
+     */
+    async putFile(ctx, path, data, opts = {}) {
+      const mime = opts.mime === void 0 ? null : safeMime(opts.mime);
+      const hash = await sha256Hex(data);
+      const blobKey = `${ctx.owner}/${newId()}`;
+      const stored = await blobs.put(blobKey, data, { ifNoneMatch: "*", ...mime ? { contentType: mime } : {} });
+      if (!stored) throw new DriveError("BLOB_EXISTS", "a blob with this key already exists");
+      let committed;
+      try {
+        committed = await transact(async (tx) => {
+          const w = batch();
+          const { parent, name } = await parentAndName(tx, w, ctx, path, opts.parents ?? false);
+          const result = await insert(tx, w, ctx, parent, name, { kind: "file", size: data.byteLength, mime, hash, blobKey }, opts.onConflict ?? "fail");
+          await w.apply(tx);
+          return result;
+        });
+      } catch (error) {
+        if (await isUnreferenced(ctx, blobKey)) await dropBlob(blobKey);
+        throw error;
+      }
+      if (committed.replacedBlob) await dropBlob(committed.replacedBlob);
+      return committed.node;
+    },
+    /** A reference points at a document in another app, such as `docs:<id>`. */
+    async putRef(ctx, path, ref, opts = {}) {
+      if (!REF.test(ref)) throw new DriveError("INVALID_REF", `a reference looks like "docs:<id>", got ${JSON.stringify(ref)}`);
+      return transact(async (tx) => {
+        const w = batch();
+        const { parent, name } = await parentAndName(tx, w, ctx, path, opts.parents ?? false);
+        const { node } = await insert(tx, w, ctx, parent, name, { kind: "ref", ref }, opts.onConflict === "replace" ? "fail" : opts.onConflict ?? "fail");
+        await w.apply(tx);
+        return node;
+      });
+    },
+    async read(ctx, loc) {
+      const node = await resolve(store, ctx, loc);
+      if (node.kind !== "file" || !node.blobKey) throw new DriveError("NOT_A_FILE", `${node.name} is not a file`);
+      const blob = await blobs.get(node.blobKey);
+      if (!blob) throw new DriveError("BLOB_MISSING", `the bytes of ${node.name} are missing`);
+      return { node, ...blob };
+    },
+    /**
+     * A time-limited URL to fetch the bytes. The URL signs an attachment header and the stored
+     * type, so the link holder cannot change how the bytes are served. Trashing an item does
+     * not revoke a link already issued.
+     */
+    async downloadUrl(ctx, loc, expiresInSeconds = DEFAULT_URL_SECONDS) {
+      if (!Number.isInteger(expiresInSeconds) || expiresInSeconds < 1 || expiresInSeconds > MAX_URL_SECONDS) {
+        throw new DriveError("INVALID_EXPIRY", `a link lasts 1 to ${MAX_URL_SECONDS} seconds`);
+      }
+      const node = await resolve(store, ctx, loc);
+      if (node.kind !== "file" || !node.blobKey) throw new DriveError("NOT_A_FILE", `${node.name} is not a file`);
+      const disposition = `attachment; filename*=UTF-8''${encodeURIComponent(node.name).replace(/['()*]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`)}`;
+      return blobs.signedUrl(node.blobKey, {
+        method: "GET",
+        expiresInSeconds,
+        responseContentDisposition: disposition.length <= 1024 ? disposition : "attachment",
+        responseContentType: node.mime ?? "application/octet-stream"
+      });
+    },
+    async move(ctx, src, destLoc, opts = {}) {
+      return transact(async (tx) => {
+        const w = batch();
+        const moved = await relocate(tx, w, ctx, await resolve(tx, ctx, src), destLoc, opts);
+        await w.apply(tx);
+        return moved;
+      });
+    },
+    async rename(ctx, loc, name) {
+      return transact(async (tx) => {
+        const w = batch();
+        const node = await resolve(tx, ctx, loc);
+        const renamed = await relocate(tx, w, ctx, node, node.parentId, { name });
+        await w.apply(tx);
+        return renamed;
+      });
+    },
+    /** Hides an item and, for a folder, everything under it. Nothing else changes. */
+    async trash(ctx, loc) {
+      return transact(async (tx) => {
+        const node = await resolve(tx, ctx, loc);
+        if (node.id === ROOT_ID) throw new DriveError("IS_ROOT", "cannot trash the root");
+        await need(ctx, "delete", node);
+        const claim = await claimId(node.owner, node.parentId, node.nameKey);
+        const held = await tx.get(NAMES, claim);
+        const t = now();
+        const trashed = { ...node, trashed: true, trashedAt: t, updatedAt: t, updatedBy: who(ctx) };
+        await tx.put(NODES, node.id, trashed);
+        if (held?.nodeId === node.id) await tx.delete(NAMES, claim);
+        return trashed;
+      });
+    },
+    /** Items trashed on their own, newest first. */
+    async listTrash(ctx) {
+      const page = await store.query(NODES, { where: { owner: ctx.owner, trashed: true }, limit: 1e3 });
+      const out = [];
+      for (const { data } of page.items) if (data.purging !== true && await can(ctx, "read", data)) out.push(data);
+      return out.sort((a, b) => (b.trashedAt ?? 0) - (a.trashedAt ?? 0));
+    },
+    /** Puts a trashed item back. It needs a live parent folder. */
+    async restore(ctx, id, opts = {}) {
+      return transact(async (tx) => {
+        const node = await fetch(tx, ctx, id);
+        if (!node || node.id === ROOT_ID) throw new DriveError("NOT_FOUND", `no item ${id}`);
+        if (!node.trashed) throw new DriveError("NOT_TRASHED", `${node.name} is not in the trash`);
+        await need(ctx, "write", node);
+        const parent = await fetch(tx, ctx, opts.parentId ?? node.parentId);
+        if (!parent || parent.kind !== "folder" || !await isLive(tx, ctx, parent)) {
+          throw new DriveError("PARENT_GONE", `the folder of ${node.name} is gone or in the trash`);
+        }
+        let { name, key } = parseName(node.name);
+        if ((await claimed(tx, ctx.owner, parent.id, key)).taken) {
+          if (opts.onConflict !== "rename") throw new DriveError("NAME_TAKEN", `"${name}" already exists`);
+          name = await freeName(tx, ctx, parent.id, name);
+          key = parseName(name).key;
+        }
+        const restored = { ...node, parentId: parent.id, name, nameKey: key, trashed: false, trashedAt: null, updatedAt: now(), updatedBy: who(ctx) };
+        await tx.put(NODES, restored.id, restored);
+        await tx.put(NAMES, await claimId(ctx.owner, parent.id, key), { nodeId: restored.id, owner: ctx.owner, parentId: parent.id });
+        return restored;
+      });
+    },
+    /** Live items that match every field given, sorted by path. */
+    async search(ctx, q = {}) {
+      const limit = q.limit ?? 100;
+      if (!Number.isInteger(limit) || limit < 1) throw new RangeError("limit must be an integer of 1 or more");
+      const all = await ownerNodes(ctx);
+      const byId = new Map(all.map((n) => [n.id, n]));
+      const needle = q.name?.normalize("NFC").toLowerCase();
+      const hits = [];
+      for (const node of all) {
+        const path = pathIn(byId, node, true);
+        if (path === null || node.purging) continue;
+        if (needle !== void 0 && !node.nameKey.includes(needle)) continue;
+        if (q.kind && node.kind !== q.kind) continue;
+        if (q.mime && !(q.mime.endsWith("/*") ? node.mime?.startsWith(q.mime.slice(0, -1)) : node.mime === q.mime)) continue;
+        if (q.minSize !== void 0 && node.size < q.minSize) continue;
+        if (q.maxSize !== void 0 && node.size > q.maxSize) continue;
+        if (q.createdByKind && node.createdBy.kind !== q.createdByKind) continue;
+        hits.push({ node, path });
+      }
+      return hits.sort((a, b) => a.path < b.path ? -1 : 1).slice(0, limit);
+    },
+    /** Every item of the owner, trashed or not, with its original path and bytes. For export. */
+    async exportData(ctx) {
+      const all = await ownerNodes(ctx);
+      const byId = new Map(all.map((n) => [n.id, n]));
+      const out = [];
+      for (const node of all.sort((a, b) => a.id < b.id ? -1 : 1)) {
+        const blob = node.blobKey ? await blobs.get(node.blobKey) : null;
+        out.push({ node, path: pathIn(byId, node, false), data: blob?.data ?? null, missing: node.blobKey !== null && !blob });
+      }
+      return out;
+    },
+    /** Deletes every item and blob of the owner for good. Only the owner may do this, never an agent for them. A failed call can run again. */
+    async deleteAll(ctx) {
+      if (ctx.actor.kind !== "human" || ctx.actor.id !== ctx.owner) throw new DriveError("FORBIDDEN", "only the owner in person can delete the whole drive");
+      await need(ctx, "delete", rootNode(ctx));
+      let removed = 0;
+      for (let pass = 0; pass < 5; pass++) {
+        const all = await ownerNodes(ctx, true);
+        if (all.length === 0) return { removed };
+        removed += await removeNodes(all);
+      }
+      throw new DriveError("BUSY", "the drive kept changing while it was deleted. Run it again.");
+    },
+    /** Deletes a trashed item for good, with everything under it and all their bytes. */
+    async purge(ctx, id) {
+      const top = await fetch(store, ctx, id, true);
+      if (!top || top.id === ROOT_ID) throw new DriveError("NOT_FOUND", `no item ${id}`);
+      if (!top.trashed) throw new DriveError("NOT_TRASHED", `${top.name} is not in the trash`);
+      await need(ctx, "delete", top);
+      const nodes = [];
+      for (const queue = [top]; queue.length; ) {
+        const node = queue.pop();
+        nodes.push(node);
+        if (node.kind === "folder") queue.push(...await children(store, node.owner, node.id));
+      }
+      return { removed: await removeNodes(nodes, top) };
+    }
+  };
+  return api;
+}
+
+// src/zip.ts
+var CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+  return c >>> 0;
+});
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) crc = CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function safeEntryName(name) {
+  if (name === "" || /[\\\u0000]/.test(name) || name.startsWith("/") || /^[a-zA-Z]:/.test(name)) return false;
+  return name.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+function writeZip(entries, at) {
+  for (const { name } of entries) if (!safeEntryName(name)) throw new Error(`zip: unsafe entry name ${JSON.stringify(name)}`);
+  const d = new Date(at);
+  const time = d.getUTCHours() << 11 | d.getUTCMinutes() << 5 | d.getUTCSeconds() >> 1;
+  const date = Math.max(d.getUTCFullYear(), 1980) - 1980 << 9 | d.getUTCMonth() + 1 << 5 | d.getUTCDate();
+  const parts = [];
+  const central = [];
+  let offset = 0;
+  const u16 = (v, o, n) => v.setUint16(o, n, true);
+  const u32 = (v, o, n) => v.setUint32(o, n, true);
+  for (const entry of entries) {
+    const name = new TextEncoder().encode(entry.name);
+    const crc = crc32(entry.data);
+    if (entry.data.byteLength >= 4294967295 || offset >= 4294967295 || entries.length >= 65535) throw new Error("zip: export is too large for a plain zip");
+    const local = new DataView(new ArrayBuffer(30));
+    u32(local, 0, 67324752);
+    u16(local, 4, 20);
+    u16(local, 6, 2048);
+    u16(local, 8, 0);
+    u16(local, 10, time);
+    u16(local, 12, date);
+    u32(local, 14, crc);
+    u32(local, 18, entry.data.byteLength);
+    u32(local, 22, entry.data.byteLength);
+    u16(local, 26, name.length);
+    u16(local, 28, 0);
+    const head = new DataView(new ArrayBuffer(46));
+    u32(head, 0, 33639248);
+    u16(head, 4, 20);
+    u16(head, 6, 20);
+    u16(head, 8, 2048);
+    u16(head, 10, 0);
+    u16(head, 12, time);
+    u16(head, 14, date);
+    u32(head, 16, crc);
+    u32(head, 20, entry.data.byteLength);
+    u32(head, 24, entry.data.byteLength);
+    u16(head, 28, name.length);
+    u32(head, 42, offset);
+    parts.push(new Uint8Array(local.buffer), name, entry.data);
+    central.push(new Uint8Array(head.buffer), name);
+    offset += 30 + name.length + entry.data.byteLength;
+  }
+  const size = central.reduce((n, p) => n + p.byteLength, 0);
+  const end = new DataView(new ArrayBuffer(22));
+  u32(end, 0, 101010256);
+  u16(end, 8, entries.length);
+  u16(end, 10, entries.length);
+  u32(end, 12, size);
+  u32(end, 16, offset);
+  const all = [...parts, ...central, new Uint8Array(end.buffer)];
+  const out = new Uint8Array(all.reduce((n, p) => n + p.byteLength, 0));
+  let at2 = 0;
+  for (const p of all) {
+    out.set(p, at2);
+    at2 += p.byteLength;
+  }
+  return out;
+}
+function readZip(bytes) {
+  const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let end = bytes.byteLength - 22;
+  while (end >= 0 && v.getUint32(end, true) !== 101010256) end--;
+  if (end < 0) throw new Error("zip: no end signature");
+  const count = v.getUint16(end + 10, true);
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0, at = v.getUint32(end + 16, true); i < count; i++) {
+    if (v.getUint32(at, true) !== 33639248) throw new Error("zip: bad central signature");
+    if (v.getUint16(at + 10, true) !== 0) throw new Error("zip: compressed entries are not supported");
+    const crc = v.getUint32(at + 16, true);
+    const size = v.getUint32(at + 24, true);
+    const nameLen = v.getUint16(at + 28, true);
+    const local = v.getUint32(at + 42, true);
+    const name = new TextDecoder().decode(bytes.subarray(at + 46, at + 46 + nameLen));
+    if (v.getUint32(local, true) !== 67324752) throw new Error("zip: bad local signature");
+    const start = local + 30 + v.getUint16(local + 26, true) + v.getUint16(local + 28, true);
+    const data = bytes.slice(start, start + size);
+    if (crc32(data) !== crc) throw new Error(`zip: crc mismatch in ${name}`);
+    out.set(name, data);
+    at += 46 + nameLen + v.getUint16(at + 30, true) + v.getUint16(at + 32, true);
+  }
+  return out;
+}
+
+// src/export.ts
+async function buildExport(drive, ctx, now = Date.now) {
+  const entries = [];
+  const items = (await drive.exportData(ctx)).map(({ node, path, data, missing }) => {
+    const file = data ? `files/${node.id}` : null;
+    if (data && file) entries.push({ name: file, data });
+    return {
+      id: node.id,
+      owner: node.owner,
+      path,
+      parentId: node.parentId,
+      kind: node.kind,
+      name: node.name,
+      size: node.size,
+      mime: node.mime,
+      hash: node.hash,
+      ref: node.ref,
+      createdAt: node.createdAt,
+      updatedAt: node.updatedAt,
+      createdBy: node.createdBy,
+      updatedBy: node.updatedBy,
+      trashed: node.trashed,
+      trashedAt: node.trashedAt,
+      file,
+      ...missing ? { missing: true } : {}
+    };
+  });
+  const manifest = { format: "agentic-drive-export", version: 1, exportedAt: now(), owner: ctx.owner, items };
+  return writeZip([{ name: "manifest.json", data: new TextEncoder().encode(JSON.stringify(manifest, null, 2)) }, ...entries], now());
+}
+
+// src/adapters/fs.ts
+import { createHash } from "crypto";
+import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, truncateSync, writeFileSync, writeSync } from "fs";
+import { join } from "path";
+import { assertBlobPutOptions, assertResponseHeaders, createMemoryStore, parseRegion } from "agentic-identity";
+function createFileStore(dir, options = {}) {
+  mkdirSync(dir, { recursive: true });
+  const file = join(dir, "store.jsonl");
+  const inner = createMemoryStore(options);
+  const ready = (async () => {
+    if (!existsSync(file)) return;
+    const text = readFileSync(file, "utf8");
+    const lines = text.split("\n");
+    const tail = lines.pop();
+    const apply = async (changes2) => {
+      for (const [collection, id, doc] of changes2) await (doc ? inner.put(collection, id, doc) : inner.delete(collection, id));
+    };
+    for (const [i, line] of lines.entries()) {
+      if (line === "") continue;
+      try {
+        await apply(JSON.parse(line));
+      } catch {
+        throw new Error(`the journal ${file} has a bad line ${i + 1}`);
+      }
+    }
+    if (tail === "") return;
+    let changes;
+    try {
+      changes = JSON.parse(tail);
+    } catch {
+      truncateSync(file, Buffer.byteLength(text) - Buffer.byteLength(tail));
+      return;
+    }
+    try {
+      await apply(changes);
+    } catch {
+      throw new Error(`the journal ${file} has a bad last line`);
+    }
+    appendFileSync(file, "\n");
+  })();
+  let failed;
+  const keep = (changes) => {
+    if (changes.length === 0) return;
+    try {
+      const fd = openSync(file, "a");
+      try {
+        const line = Buffer.from(`${JSON.stringify(changes)}
+`);
+        for (let done = 0; done < line.length; ) {
+          const wrote = writeSync(fd, line, done);
+          if (wrote <= 0) throw new Error("the journal write stopped short");
+          done += wrote;
+        }
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+    } catch (error) {
+      failed = error;
+      throw error;
+    }
+  };
+  const open = async () => {
+    await ready;
+    if (failed !== void 0) throw new Error("the journal could not be written, so the store is closed. Open it again.");
+  };
+  const recording = (ops, changes) => ({
+    ...ops,
+    put: async (collection, id, doc) => {
+      await ops.put(collection, id, doc);
+      changes.push([collection, id, doc]);
+    },
+    delete: async (collection, id) => {
+      await ops.delete(collection, id);
+      changes.push([collection, id, null]);
+    }
+  });
+  return {
+    region: inner.region,
+    get: async (c, id) => (await open(), inner.get(c, id)),
+    query: async (c, q) => (await open(), inner.query(c, q)),
+    async put(collection, id, doc) {
+      await open();
+      await inner.put(collection, id, doc);
+      keep([[collection, id, doc]]);
+    },
+    async delete(collection, id) {
+      await open();
+      await inner.delete(collection, id);
+      keep([[collection, id, null]]);
+    },
+    async transaction(fn) {
+      await open();
+      let changes = [];
+      const result = await inner.transaction((tx) => {
+        changes = [];
+        return fn(recording(tx, changes));
+      });
+      keep(changes);
+      return result;
+    }
+  };
+}
+var versionOf = (data) => createHash("sha256").update(data).digest("hex");
+function createFileBlobs(dir, options = {}) {
+  mkdirSync(dir, { recursive: true });
+  const path = (key) => join(dir, createHash("sha256").update(key).digest("hex"));
+  const need = (key) => {
+    if (key === "") throw new Error("blob key must not be empty");
+  };
+  const now = options.now ?? Date.now;
+  return {
+    region: options.region === void 0 ? "unknown" : parseRegion(options.region),
+    async put(key, data, opts) {
+      need(key);
+      assertBlobPutOptions(opts);
+      const current = existsSync(path(key)) ? versionOf(readFileSync(path(key))) : void 0;
+      if (opts?.ifNoneMatch === "*" && current !== void 0 || opts?.ifMatch !== void 0 && current !== opts.ifMatch) return null;
+      const tmp = `${path(key)}.tmp`;
+      writeFileSync(tmp, data);
+      if (opts?.contentType) writeFileSync(`${path(key)}.type`, opts.contentType);
+      else rmSync(`${path(key)}.type`, { force: true });
+      renameSync(tmp, path(key));
+      return { version: versionOf(data) };
+    },
+    async get(key) {
+      need(key);
+      if (!existsSync(path(key))) return null;
+      const type = existsSync(`${path(key)}.type`) ? readFileSync(`${path(key)}.type`, "utf8") : void 0;
+      const data = new Uint8Array(readFileSync(path(key)));
+      return { data, version: versionOf(data), ...type ? { contentType: type } : {} };
+    },
+    async head(key) {
+      need(key);
+      if (!existsSync(path(key))) return null;
+      const type = existsSync(`${path(key)}.type`) ? readFileSync(`${path(key)}.type`, "utf8") : void 0;
+      const data = readFileSync(path(key));
+      return { size: data.length, version: versionOf(data), ...type ? { contentType: type } : {} };
+    },
+    async delete(key) {
+      need(key);
+      rmSync(path(key), { force: true });
+      rmSync(`${path(key)}.type`, { force: true });
+    },
+    /** A local path with its expiry. Nothing serves or checks it: it exists so the port is whole. */
+    async signedUrl(key, opts) {
+      need(key);
+      const { method, expiresInSeconds } = opts;
+      assertResponseHeaders(opts);
+      if (!Number.isInteger(expiresInSeconds) || expiresInSeconds < 1 || expiresInSeconds > 604800) {
+        throw new RangeError("expiresInSeconds must be an integer from 1 to 604800");
+      }
+      const extra = [
+        opts.responseContentDisposition === void 0 ? "" : `&disposition=${encodeURIComponent(opts.responseContentDisposition)}`,
+        opts.responseContentType === void 0 ? "" : `&type=${encodeURIComponent(opts.responseContentType)}`
+      ].join("");
+      return `file://${path(key)}?method=${method}&expires=${now() + expiresInSeconds * 1e3}${extra}`;
+    }
+  };
+}
+
+// src/local.ts
+import { join as join2 } from "path";
+function openLocal(options) {
+  const kind = options.kind ?? "human";
+  if (!ACTOR_KINDS.includes(kind)) throw new Error(`unknown actor kind "${kind}"`);
+  return {
+    drive: createDrive({ store: createFileStore(join2(options.dir, "db")), blobs: createFileBlobs(join2(options.dir, "blobs")) }),
+    ctx: { owner: options.owner, actor: { id: options.actor ?? options.owner, kind } }
+  };
+}
+function publicNode(node, path) {
+  const { nameKey: _nameKey, blobKey: _blobKey, purging: _purging, ...rest } = node;
+  return path === void 0 ? rest : { path, ...rest };
+}
+
+// src/upload.ts
+var DEFAULT_MAX_BYTES = 25 * 1024 * 1024;
+var SIGNATURES = [
+  [[137, 80, 78, 71, 13, 10, 26, 10], "image/png"],
+  [[255, 216, 255], "image/jpeg"],
+  [[71, 73, 70, 56], "image/gif"],
+  [[37, 80, 68, 70, 45], "application/pdf"],
+  [[80, 75, 3, 4], "application/zip"],
+  [[31, 139], "application/gzip"]
+];
+function sniffMime(head) {
+  const hit = SIGNATURES.find(([sig]) => sig.every((byte, i) => head[i] === byte));
+  if (hit) return hit[1];
+  const isWebp = [..."RIFF"].every((c, i) => head[i] === c.charCodeAt(0)) && [..."WEBP"].every((c, i) => head[8 + i] === c.charCodeAt(0));
+  return isWebp ? "image/webp" : null;
+}
+function looksLikeText(head) {
+  if (head.includes(0)) return false;
+  for (let cut = 0; cut < 4 && cut <= head.length; cut++) {
+    try {
+      new TextDecoder("utf-8", { fatal: true }).decode(head.subarray(0, head.length - cut));
+      return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+async function* iterate(source) {
+  if (Symbol.asyncIterator in source) {
+    yield* source;
+    return;
+  }
+  const reader = source.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function upload(drive, ctx, path, source, opts = {}) {
+  const max = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+  const parts = [];
+  let size = 0;
+  for await (const chunk of iterate(source)) {
+    size += chunk.byteLength;
+    if (size > max) throw new DriveError("TOO_LARGE", `upload is over the limit of ${max} bytes`);
+    parts.push(chunk);
+  }
+  const data = new Uint8Array(size);
+  for (let at = 0, i = 0; i < parts.length; at += parts[i].byteLength, i++) data.set(parts[i], at);
+  const head = data.subarray(0, 512);
+  const mime = sniffMime(head) ?? (opts.mime !== void 0 ? safeMime(opts.mime) : looksLikeText(head) ? "text/plain" : "application/octet-stream");
+  return drive.putFile(ctx, path, data, { mime, parents: opts.parents, onConflict: opts.onConflict });
+}
+
+export {
+  ROOT_ID,
+  ACTOR_KINDS,
+  DriveError,
+  DEFAULT_URL_SECONDS,
+  safeMime,
+  parseName,
+  createDrive,
+  writeZip,
+  readZip,
+  buildExport,
+  createFileStore,
+  createFileBlobs,
+  openLocal,
+  publicNode,
+  DEFAULT_MAX_BYTES,
+  sniffMime,
+  upload
+};