@safekb/mcp 0.5.0 → 0.6.0

package/dist/safekb-mcp.js

@@ -2354,12 +2354,12 @@ var require_index_umd = __commonJS((exports, module) => {
 });
 
 // src/main.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 // package.json
 var package_default = {
   name: "@safekb/mcp",
-  version: "0.5.0",
+  version: "0.6.0",
   description: "SafeKB local MCP client: proxies the hosted SafeKB tools and adds zero-knowledge sealed documents.",
   license: "SEE LICENSE IN LICENSE",
   author: "Mustafa Öztürk",
@@ -2448,13 +2448,25 @@ async function followUp(done, undone, tidy) {
 var JSON_TIMEOUT_MS = 30000;
 var TRANSFER_TIMEOUT_MS = 10 * 60000;
 var MAX_ERROR_TEXT_CHARS = 500;
+function withoutInput(entry) {
+  if (typeof entry !== "object" || entry === null)
+    return entry;
+  const {
+    input: _input,
+    ctx: _ctx,
+    ...rest
+  } = entry;
+  return rest;
+}
 function describeDetail(payload) {
   if (typeof payload !== "object" || payload === null)
     return null;
   const detail = payload.detail;
   if (detail === undefined || detail === null)
     return null;
-  return typeof detail === "string" ? detail : JSON.stringify(detail);
+  if (typeof detail === "string")
+    return detail;
+  return JSON.stringify(Array.isArray(detail) ? detail.map(withoutInput) : detail);
 }
 async function errorDetail(response) {
   const text = (await response.text()).trim();
@@ -2502,6 +2514,31 @@ class HttpClient {
       contentType: "application/json"
     });
   }
+  putJson(path, body, query = {}) {
+    return this.json("PUT", path, {
+      query,
+      body: JSON.stringify(body),
+      contentType: "application/json"
+    });
+  }
+  patchJson(path, body, query = {}) {
+    return this.json("PATCH", path, {
+      query,
+      body: JSON.stringify(body),
+      contentType: "application/json"
+    });
+  }
+  async delete(path) {
+    await this.send("DELETE", path, { timeoutMs: JSON_TIMEOUT_MS });
+  }
+  async postFields(path, fields) {
+    const response = await this.send("POST", path, {
+      body: fields.toString(),
+      contentType: "application/x-www-form-urlencoded",
+      timeoutMs: TRANSFER_TIMEOUT_MS
+    });
+    return await response.json();
+  }
   async postForm(path, form) {
     const response = await this.send("POST", path, {
       body: form,
@@ -2559,11 +2596,319 @@ class HttpClient {
   }
 }
 
+// src/api/kbApi.ts
+var LINK_TYPES = [
+  "relates",
+  "blocks",
+  "blocked_by",
+  "project",
+  "spec",
+  "wiki",
+  "supersedes"
+];
+var TASK_PAGE_SIZE = 500;
+var CREDENTIAL_PAGE_SIZE = 200;
+var TASK_TEXT_LIMIT = 200;
+var ROW_PAGE_SIZE = 200;
+var BLOCK_BATCH_SIZE = 500;
+var ATTACHMENT_ROWS_BATCH_SIZE = 100;
+function taskOf(raw) {
+  return {
+    id: raw.id,
+    title: raw.title,
+    status: raw.status,
+    priority: raw.priority ?? null,
+    due_date: raw.due_date ?? null,
+    due_date_label: raw.due_date_label ?? null,
+    assignee_id: raw.assignee_id ?? null,
+    waiting_on: raw.waiting_on ?? null,
+    project_id: raw.project_id ?? null,
+    parent_task_id: raw.parent_task_id ?? null,
+    exec_order: raw.exec_order ?? null,
+    space_id: raw.space_id ?? null,
+    spec_doc_id: raw.spec_doc_id ?? null,
+    external_refs: raw.external_refs ?? [],
+    position: raw.position,
+    merged_into: raw.merged_into ?? null
+  };
+}
+function projectOf(raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    slug: raw.slug,
+    status: raw.status,
+    description: raw.description ?? null,
+    spec_doc_id: raw.spec_doc_id ?? null,
+    space_id: raw.space_id ?? null,
+    icon: raw.icon ?? null,
+    color: raw.color ?? null
+  };
+}
+function rowOf(raw) {
+  return {
+    id: raw._id,
+    values: { ...raw.indexed_fields, ...raw.unindexed_fields }
+  };
+}
+function fileOf(upload) {
+  const form = new FormData;
+  form.set("file", new Blob([upload.bytes], { type: upload.mime_type }), upload.file_name);
+  return form;
+}
+
+class KbApi {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  spaces() {
+    return this.http.getJson("/spaces");
+  }
+  createSpace(space) {
+    return this.http.postJson("/spaces", space);
+  }
+  async allowClientUploads(spaceId) {
+    await this.http.putJson(`/spaces/${spaceId}`, {
+      allow_client_uploads: true
+    });
+  }
+  async tree(spaceId) {
+    const tree = await this.http.getJson(`/spaces/${spaceId}/tree`, { include_archived: "true" });
+    return tree.documents;
+  }
+  document(id) {
+    return this.http.getJson(`/documents/${id}`);
+  }
+  async body(id) {
+    const stored = await this.http.getJson(`/documents/${id}/body`);
+    return stored.body;
+  }
+  async bodyJson(id) {
+    const stored = await this.http.getJson(`/documents/${id}/body-json`);
+    return stored.body_json;
+  }
+  createFolder(folder) {
+    return this.http.postJson("/documents/folders", folder);
+  }
+  createDocument(document) {
+    const fields = this.placed(document);
+    fields.set("doc_type", document.doc_type);
+    if (document.body !== null)
+      fields.set("body", document.body);
+    if (document.body_json !== null) {
+      fields.set("body_json", JSON.stringify(document.body_json));
+    }
+    if (document.source_id !== null) {
+      fields.set("source_id", document.source_id);
+    }
+    for (const tag of document.tags)
+      fields.append("tags", tag);
+    if (document.external_refs.length > 0) {
+      fields.set("external_refs", JSON.stringify(document.external_refs));
+    }
+    return this.http.postFields("/documents", fields);
+  }
+  createVaultDocument(document) {
+    const fields = this.placed(document);
+    fields.set("encrypted", "true");
+    fields.set("doc_id", document.doc_id);
+    fields.set("enc_body", document.enc_body);
+    if (document.enc_meta !== null)
+      fields.set("enc_meta", document.enc_meta);
+    if (document.enc_key_id !== null) {
+      fields.set("enc_key_id", document.enc_key_id);
+    }
+    if (document.cipher !== null)
+      fields.set("cipher", document.cipher);
+    return this.http.postFields("/documents", fields);
+  }
+  placed(node) {
+    const fields = new URLSearchParams;
+    fields.set("title", node.title);
+    fields.set("space_id", node.space_id);
+    fields.set("position", String(node.position));
+    if (node.parent_id !== null)
+      fields.set("parent_id", node.parent_id);
+    return fields;
+  }
+  async labelDocument(id, labels) {
+    await this.http.putJson(`/documents/${id}`, labels);
+  }
+  async replaceContent(id, content) {
+    await this.http.putJson(`/documents/${id}`, content.body_json === null ? { body: content.body } : { body_json: content.body_json });
+  }
+  async archiveDocument(id) {
+    await this.http.postJson(`/documents/${id}/archive`, {});
+  }
+  async blocks(documentId) {
+    const page = await this.http.getJson(`/documents/${documentId}/blocks`, { limit: 0 });
+    return page.blocks;
+  }
+  async addBlocks(documentId, blocks) {
+    await this.http.patchJson(`/documents/${documentId}/blocks`, {
+      add: blocks,
+      update: [],
+      delete: []
+    });
+  }
+  async attachments(documentId) {
+    const page = await this.http.getJson(`/documents/${documentId}/attachments`, { limit: 0 });
+    return page.attachments;
+  }
+  attachmentFile(documentId, attachmentId) {
+    return this.http.getStream(`/documents/${documentId}/attachments/${attachmentId}/file`);
+  }
+  attach(documentId, upload) {
+    return this.http.postForm(`/documents/${documentId}/attachments`, fileOf(upload));
+  }
+  async showAttachmentOnRows(documentId, attachmentId, rowIds) {
+    await this.http.postJson(`/documents/${documentId}/attachments/${attachmentId}/links`, { row_ids: rowIds });
+  }
+  async database(id) {
+    const raw = await this.http.getJson(`/databases/${id}`);
+    return {
+      id: raw._id,
+      title: raw.title,
+      description: await this.body(id),
+      columns: raw.schema.columns,
+      compound_indexes: raw.schema.compound_indexes ?? [],
+      primary_column_id: raw.schema.primary_column_id ?? null
+    };
+  }
+  async createDatabase(database) {
+    const raw = await this.http.postJson("/databases", database);
+    return { id: raw._id };
+  }
+  async addColumn(databaseId, column) {
+    await this.http.patchJson(`/databases/${databaseId}/schema`, {
+      mutations: [{ op: "add_column", column }]
+    });
+  }
+  async addIndex(databaseId, index) {
+    await this.http.patchJson(`/databases/${databaseId}/schema`, {
+      mutations: [{ op: "add_compound_index", index }]
+    });
+  }
+  views(databaseId) {
+    return this.http.getJson(`/databases/${databaseId}/views`);
+  }
+  async createView(databaseId, view) {
+    await this.http.postJson(`/databases/${databaseId}/views`, view);
+  }
+  async* rows(databaseId) {
+    const page = (number) => this.http.postJson(`/databases/${databaseId}/rows/query`, { page: number, page_size: ROW_PAGE_SIZE });
+    const { total } = await page(1);
+    for (let last = Math.ceil(total / ROW_PAGE_SIZE);last >= 1; last--) {
+      const { rows } = await page(last);
+      if (rows.length > 0)
+        yield rows.map(rowOf);
+    }
+  }
+  async createRows(databaseId, valuesList) {
+    const rows = await this.http.postJson(`/databases/${databaseId}/rows/bulk`, { values_list: valuesList });
+    return rows.map((row) => row._id);
+  }
+  async updateRow(rowId, values) {
+    await this.http.patchJson(`/databases/rows/${rowId}`, { values });
+  }
+  rowBody(rowId) {
+    return this.http.getJson(`/databases/rows/${rowId}/body`);
+  }
+  async replaceRowBody(rowId, blocks) {
+    await this.http.putJson(`/databases/rows/${rowId}/body`, { blocks });
+  }
+  rowAttachments(databaseId, rowIds) {
+    return this.http.postJson(`/databases/${databaseId}/rows/attachments-batch`, {
+      row_ids: rowIds
+    });
+  }
+  rowAttachmentFile(rowId, attachmentId) {
+    return this.http.getStream(`/databases/rows/${rowId}/attachments/${attachmentId}/file`);
+  }
+  attachToRow(rowId, upload) {
+    return this.http.postForm(`/databases/rows/${rowId}/attachments`, fileOf(upload));
+  }
+  async* credentials() {
+    for (const archived of ["false", "true"]) {
+      for (let offset = 0;; offset += CREDENTIAL_PAGE_SIZE) {
+        const page = await this.http.getJson("/credentials", {
+          archived,
+          limit: CREDENTIAL_PAGE_SIZE,
+          offset,
+          sort: "created_at"
+        });
+        yield* page;
+        if (page.length < CREDENTIAL_PAGE_SIZE)
+          break;
+      }
+    }
+  }
+  async reveal(credentialId, field) {
+    const revealed = await this.http.postJson(`/credentials/${credentialId}/reveal`, { field });
+    return revealed.value;
+  }
+  createCredential(credential) {
+    return this.http.postJson("/credentials", credential);
+  }
+  archiveCredential(id) {
+    return this.http.delete(`/credentials/${id}`);
+  }
+  async projects() {
+    const projects = await this.http.getJson("/projects");
+    return projects.map(projectOf);
+  }
+  async createProject(project) {
+    return projectOf(await this.http.postJson("/projects", project));
+  }
+  async* tasks() {
+    for (let skip = 0;; skip += TASK_PAGE_SIZE) {
+      const page = await this.http.getJson("/tasks", {
+        limit: TASK_PAGE_SIZE,
+        skip
+      });
+      yield* page.map(taskOf);
+      if (page.length < TASK_PAGE_SIZE)
+        return;
+    }
+  }
+  createTask(task) {
+    return this.http.postJson("/tasks", task);
+  }
+  decisions(projectId) {
+    return this.http.getJson(`/projects/${projectId}/decisions`, {
+      compact: "false"
+    });
+  }
+  createDecision(decision) {
+    return this.http.postJson("/decisions", decision);
+  }
+  async setDecisionStatus(id, status) {
+    await this.http.patchJson(`/decisions/${id}`, { status });
+  }
+  async outgoingLinks(type, id) {
+    const graph = await this.http.getJson(`/links/${type}/${id}`);
+    return graph.outgoing;
+  }
+  async createLink(link) {
+    const ownType = LINK_TYPES.includes(link.link_type);
+    if (ownType || link.source.type !== "doc" || link.target.type !== "doc") {
+      await this.http.postJson("/links", link);
+      return;
+    }
+    await this.http.postJson(`/documents/${link.source.id}/links`, {
+      target_id: link.target.id,
+      link_type: link.link_type,
+      note: link.note
+    });
+  }
+}
+
 // src/api/sealedApi.ts
 var KEY_MODE_SEALED = "sealed";
 var MAX_PAGE_SIZE = 500;
 var MAX_INDEX_ENTRY_IDS = 100;
-var CREDENTIAL_PAGE_SIZE = 200;
+var CREDENTIAL_PAGE_SIZE2 = 200;
 function toSealedNode(document) {
   const { seal_root_id, seal_seq, enc_meta } = document;
   if (document.key_mode !== KEY_MODE_SEALED || typeof seal_root_id !== "string" || typeof seal_seq !== "number" || typeof enc_meta !== "string") {
@@ -2674,25 +3019,25 @@ class SealedApi {
     return this.http.postForm(`/documents/${id}/sealed/attach`, form);
   }
   createPlainDocument(request) {
-    const form = new FormData;
-    form.set("title", request.title);
-    form.set("body", request.body);
-    form.set("space_id", request.space_id);
+    const fields = new URLSearchParams;
+    fields.set("title", request.title);
+    fields.set("body", request.body);
+    fields.set("space_id", request.space_id);
     if (request.parent_id !== null)
-      form.set("parent_id", request.parent_id);
+      fields.set("parent_id", request.parent_id);
     for (const tag of request.tags)
-      form.append("tags", tag);
-    return this.http.postForm("/documents", form);
+      fields.append("tags", tag);
+    return this.http.postFields("/documents", fields);
   }
   getCredential(id) {
     return this.http.getJson(`/credentials/${id}`);
   }
   async* credentials() {
     for (const archived of ["false", "true"]) {
-      for (let offset = 0;; offset += CREDENTIAL_PAGE_SIZE) {
-        const page = await this.http.getJson("/credentials", { archived, limit: CREDENTIAL_PAGE_SIZE, offset, sort: "created_at" });
+      for (let offset = 0;; offset += CREDENTIAL_PAGE_SIZE2) {
+        const page = await this.http.getJson("/credentials", { archived, limit: CREDENTIAL_PAGE_SIZE2, offset, sort: "created_at" });
         yield* page;
-        if (page.length < CREDENTIAL_PAGE_SIZE)
+        if (page.length < CREDENTIAL_PAGE_SIZE2)
           break;
       }
     }
@@ -6276,9 +6621,9 @@ async function authorize(request) {
   }
 }
 
-// src/claudeCode.ts
-import { spawn as spawn2 } from "node:child_process";
-import { basename as basename2 } from "node:path";
+// src/backup/console.ts
+import { createReadStream, existsSync as existsSync2, rmSync } from "node:fs";
+import { open as open3, stat as stat2 } from "node:fs/promises";
 
 // src/printable.ts
 var UNPRINTABLE2 = /[\p{Cc}\p{Cf}]/gu;
@@ -6291,118 +6636,2435 @@ function printableLines(text) {
 `);
 }
 
-// src/claudeCode.ts
-var SERVER_NAME = "safekb";
-var PACKAGE_NAME = "@safekb/mcp";
-var BIN_NAME = "safekb-mcp";
-var SERVE_FLAG = "--mcp";
-var PACKAGE_COMMAND = ["npx", "-y", PACKAGE_NAME, SERVE_FLAG];
-var SCOPES = ["user", "local", "project"];
-function quotedForCmd(arg) {
-  return /[\s"&|<>^]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg;
+// src/transfer/passphrase.ts
+var RECOMMENDED_EXPORT_PASSPHRASE_LENGTH = 12;
+async function readNewPassphrase(reader, guarded) {
+  for (;; ) {
+    const first = await reader.read(`Passphrase for the export file (not shown; ${RECOMMENDED_EXPORT_PASSPHRASE_LENGTH} or more characters recommended): `, { hidden: true });
+    if (first.length === 0) {
+      reader.write(`Nothing entered.
+`);
+      continue;
+    }
+    if (first.length < RECOMMENDED_EXPORT_PASSPHRASE_LENGTH) {
+      reader.write(`Note: shorter than the recommended ${RECOMMENDED_EXPORT_PASSPHRASE_LENGTH} characters; ${guarded} is only as safe as this passphrase.
+`);
+    }
+    const second = await reader.read("Repeat it: ", { hidden: true });
+    if (first === second)
+      return first;
+    reader.write(`The two entries differ.
+`);
+  }
 }
-var runProgram = (program, args) => new Promise((resolve, reject) => {
-  const windows = process.platform === "win32";
-  const child = spawn2(program, windows ? args.map(quotedForCmd) : args, {
-    stdio: ["ignore", "pipe", "pipe"],
-    shell: windows
-  });
-  let output = "";
-  child.stdout.on("data", (chunk) => {
-    output += chunk;
+function readPassphrase(reader) {
+  return reader.read("Passphrase of the export file (not shown): ", {
+    hidden: true
   });
-  child.stderr.on("data", (chunk) => {
-    output += chunk;
-  });
-  child.on("error", (error) => {
-    if (error.code === "ENOENT")
-      resolve({ code: null, output: "" });
-    else
-      reject(error);
-  });
-  child.on("close", (code) => resolve({ code: code ?? 1, output }));
-});
-function addCommand(serverArgs) {
-  return [
-    "mcp",
-    "add",
-    "--scope",
-    "user",
-    SERVER_NAME,
-    "--",
-    ...PACKAGE_COMMAND,
-    ...serverArgs
-  ];
-}
-var REMOTE_TYPES = ["http", "sse"];
-var ENVIRONMENT = /^([ \t]*)Environment:[ \t]*\n((?:\1[ \t]+\S.*(?:\n|$))*)/m;
-var SERVE_FLAG_SINCE = [0, 5, 0];
-var EXACT_VERSION = /^(\d+)\.(\d+)\.(\d+)$/;
-function field(description, name) {
-  return (new RegExp(`^\\s*${name}:(.*)$`, "m").exec(description)?.[1] ?? "").trim();
 }
-function registrationOf(output) {
-  const description = output.replace(/\r\n?/g, `
-`);
-  if (REMOTE_TYPES.includes(field(description, "Type")))
-    return null;
-  const command = field(description, "Command");
-  if (command.length === 0) {
-    throw new StartupError(`Claude Code has an MCP server "${SERVER_NAME}", but what it starts could not be read from "claude mcp get ${SERVER_NAME}", so it is not known whether it starts this client with ${SERVE_FLAG}. Nothing was changed.`);
+
+// src/backup/archive/container.ts
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip, createGzip } from "node:zlib";
+
+// src/backup/archive/byteReader.ts
+class ByteReader {
+  source;
+  cutShort;
+  chunks = [];
+  offset = 0;
+  available = 0;
+  ended = false;
+  constructor(source, cutShort) {
+    this.source = source[Symbol.asyncIterator]();
+    this.cutShort = cutShort;
+  }
+  async readOrEnd(length) {
+    while (this.available < length && await this.pull())
+      ;
+    if (this.available === 0 && length > 0)
+      return null;
+    if (this.available < length)
+      throw new ClientError(this.cutShort);
+    return this.take(length);
+  }
+  async read(length) {
+    const bytes = await this.readOrEnd(length);
+    if (bytes === null)
+      throw new ClientError(this.cutShort);
+    return bytes;
+  }
+  async readUntil(delimiter, limit) {
+    while (this.available <= limit && await this.pull())
+      ;
+    const head = this.take(Math.min(this.available, limit + 1));
+    const at = head.indexOf(delimiter);
+    if (at < 0)
+      return null;
+    this.putBack(head.subarray(at + 1));
+    return head.subarray(0, at);
+  }
+  async readUpTo(limit) {
+    while (this.available === 0) {
+      if (!await this.pull())
+        throw new ClientError(this.cutShort);
+    }
+    const first = this.chunks[0];
+    return this.take(Math.min(limit, first.length - this.offset));
+  }
+  putBack(bytes) {
+    const first = this.chunks[0];
+    if (first !== undefined && this.offset > 0) {
+      this.chunks[0] = first.subarray(this.offset);
+      this.offset = 0;
+    }
+    this.chunks.unshift(bytes);
+    this.available += bytes.length;
+  }
+  take(length) {
+    const bytes = new Uint8Array(length);
+    let filled = 0;
+    while (filled < length) {
+      const first = this.chunks[0];
+      const piece = first.subarray(this.offset, this.offset + length - filled);
+      bytes.set(piece, filled);
+      filled += piece.length;
+      this.offset += piece.length;
+      if (this.offset === first.length) {
+        this.chunks.shift();
+        this.offset = 0;
+      }
+    }
+    this.available -= length;
+    return bytes;
+  }
+  async pull() {
+    if (this.ended)
+      return false;
+    const next = await this.source.next();
+    if (next.done) {
+      this.ended = true;
+      return false;
+    }
+    if (next.value.length > 0) {
+      this.chunks.push(next.value);
+      this.available += next.value.length;
+    }
+    return true;
   }
-  const scope = field(description, "Scope").split(" ")[0]?.toLowerCase();
-  return {
-    scope: SCOPES.find((name) => name === scope) ?? null,
-    command,
-    args: field(description, "Args"),
-    environment: (ENVIRONMENT.exec(description)?.[2] ?? "").split(`
-`).map((line) => line.trim().split("=")[0] ?? "").filter((name) => name.length > 0),
-    timeout: field(description, "Timeout")
-  };
 }
-function words(registration) {
-  return [registration.command, ...registration.args.split(/\s+/)];
+function uint32(value) {
+  const bytes = new Uint8Array(4);
+  new DataView(bytes.buffer).setUint32(0, value, false);
+  return bytes;
 }
-function startsThisClient(registration) {
-  return words(registration).some((word) => word === PACKAGE_NAME || word.startsWith(`${PACKAGE_NAME}@`) || [BIN_NAME, `${BIN_NAME}.js`].includes(basename2(word)));
+function readUint32(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, 4).getUint32(0, false);
 }
-function pinnedBeforeServeFlag(registration) {
-  for (const word of words(registration)) {
-    if (!word.startsWith(`${PACKAGE_NAME}@`))
+
+// src/backup/archive/container.ts
+var ARCHIVE_KIND = "safekb-export";
+var ARCHIVE_VERSION = 1;
+var COMPRESSIONS = ["none", "gzip"];
+var KEY_INFO = "safekb/export/v1";
+var ARCHIVE_KDF = MIN_KDF_PARAMS;
+var MAX_KDF = { m: 256 * 1024, t: 8, p: 4 };
+var PART_BYTES = 1024 * 1024;
+var TAG_BYTES2 = 16;
+var NONCE_PREFIX_BYTES2 = 8;
+var MAX_PARTS = 2 ** 32;
+var MAX_HEADER_BYTES = 4096;
+var NEWLINE = 10;
+var CUT_SHORT = "The export file is cut short or damaged";
+function malformed(why) {
+  return new ClientError(`Not a SafeKB export: ${why}`);
+}
+async function archiveKey(passphrase, header) {
+  const ikm = await derivePassphraseIkm(passphrase, fromBase64(header.salt), header.kdf);
+  return deriveKey(ikm, KEY_INFO);
+}
+function partNonce(prefix, index) {
+  if (index >= MAX_PARTS)
+    throw new ClientError("The export is too large");
+  return concatBytes(prefix, uint32(index));
+}
+function partAad(headerDigest, part, isLast) {
+  return utf8Encode(`${KEY_INFO}|${headerDigest}|${part}|${isLast ? 1 : 0}`);
+}
+async function* inParts(source, size) {
+  let pieces = [];
+  let held = 0;
+  for await (const piece of source) {
+    pieces.push(piece);
+    held += piece.length;
+    if (held <= size)
       continue;
-    const version = word.slice(PACKAGE_NAME.length + 1);
-    const numbers = EXACT_VERSION.exec(version)?.slice(1).map(Number);
-    if (numbers === undefined)
-      return null;
-    const differing = numbers.findIndex((number, index) => number !== SERVE_FLAG_SINCE[index]);
-    return differing !== -1 && numbers[differing] < SERVE_FLAG_SINCE[differing] ? version : null;
+    let pending = concatBytes(...pieces);
+    while (pending.length > size) {
+      yield { bytes: pending.slice(0, size), isLast: false };
+      pending = pending.slice(size);
+    }
+    pieces = [pending];
+    held = pending.length;
+  }
+  yield { bytes: concatBytes(...pieces), isLast: true };
+}
+function through(source, transform) {
+  pipeline(Readable.from(source, { objectMode: false }), transform).catch(() => {});
+  return transform;
+}
+async function* sealArchive(content, passphrase, compression) {
+  const prefix = randomBytes(NONCE_PREFIX_BYTES2);
+  const header = {
+    kind: ARCHIVE_KIND,
+    v: ARCHIVE_VERSION,
+    kdf: { ...ARCHIVE_KDF },
+    salt: toBase64(randomBytes(SALT_BYTES)),
+    nonce_prefix: toBase64(prefix),
+    compression
+  };
+  const line = utf8Encode(JSON.stringify(header));
+  const digest = await sha256Hex(line);
+  const key = await archiveKey(passphrase, header);
+  yield concatBytes(line, new Uint8Array([NEWLINE]));
+  const plain = compression === "gzip" ? through(content, createGzip()) : content;
+  let index = 0;
+  for await (const part of inParts(plain, PART_BYTES)) {
+    const sealed = await aesGcmEncrypt(key, partNonce(prefix, index), part.bytes, partAad(digest, index, part.isLast));
+    yield concatBytes(uint32(sealed.length), sealed);
+    index++;
   }
-  return null;
 }
-function lacksServeFlag(registration) {
-  return startsThisClient(registration) && !words(registration).includes(SERVE_FLAG);
-}
-function writtenBySetup(registration) {
-  const { scope, command, args, environment, timeout } = registration;
-  if (scope !== "user" || command !== "npx" || environment.length > 0 || timeout.length > 0) {
-    return null;
+function parseHeader(line) {
+  let value;
+  try {
+    value = JSON.parse(utf8Decode(line));
+  } catch {
+    throw malformed("it does not start with a header");
   }
-  const own = `-y ${PACKAGE_NAME}`;
-  if (args === own)
-    return [];
-  const config = `${own} --config `;
-  if (!args.startsWith(config))
-    return null;
-  const path = args.slice(config.length);
-  return /\s-/.test(path) ? null : ["--config", path];
+  const raw = value;
+  if (raw?.kind !== ARCHIVE_KIND) {
+    throw malformed(`its kind is not '${ARCHIVE_KIND}'`);
+  }
+  if (raw.v !== ARCHIVE_VERSION) {
+    throw malformed(`its version is not ${ARCHIVE_VERSION}; use the version of @safekb/mcp that wrote it`);
+  }
+  const { kdf, salt, nonce_prefix, compression } = raw;
+  if (typeof kdf !== "object" || kdf === null || typeof salt !== "string" || typeof nonce_prefix !== "string" || !COMPRESSIONS.includes(compression)) {
+    throw malformed("its header is incomplete");
+  }
+  const params = assertKdfParams(kdf);
+  if (params.m > MAX_KDF.m || params.t > MAX_KDF.t || params.p > MAX_KDF.p) {
+    throw malformed("its KDF parameters are beyond what this client runs");
+  }
+  if (fromBase64(nonce_prefix).length !== NONCE_PREFIX_BYTES2) {
+    throw malformed("its header is incomplete");
+  }
+  return {
+    kind: raw.kind,
+    v: raw.v,
+    kdf: params,
+    salt,
+    nonce_prefix,
+    compression
+  };
 }
-function quotedForSh(word) {
-  return /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replace(/'/g, "'\\''")}'`;
+async function* openParts(reader, key, header, digest) {
+  const prefix = fromBase64(header.nonce_prefix);
+  let length = await reader.readOrEnd(4);
+  for (let index = 0;length !== null; index++) {
+    const size = readUint32(length);
+    if (size < TAG_BYTES2 || size > PART_BYTES + TAG_BYTES2) {
+      throw new ClientError(CUT_SHORT);
+    }
+    const sealed = await reader.read(size);
+    length = await reader.readOrEnd(4);
+    try {
+      yield await aesGcmDecrypt(key, partNonce(prefix, index), sealed, partAad(digest, index, length === null));
+    } catch (error) {
+      if (!(error instanceof DecryptionError))
+        throw error;
+      throw new ClientError(index === 0 ? "Wrong passphrase, or the export file was changed or damaged" : CUT_SHORT);
+    }
+    if (length === null)
+      return;
+  }
+  throw new ClientError(CUT_SHORT);
 }
-function typed(command) {
-  return command.map(process.platform === "win32" ? quotedForCmd : quotedForSh).join(" ");
+async function* openArchive(file, passphrase) {
+  const reader = new ByteReader(file, CUT_SHORT);
+  const line = await reader.readUntil(NEWLINE, MAX_HEADER_BYTES);
+  if (line === null)
+    throw malformed("it does not start with a header");
+  const header = parseHeader(line);
+  const key = await archiveKey(passphrase, header);
+  const parts = openParts(reader, key, header, await sha256Hex(line));
+  yield* header.compression === "gzip" ? through(parts, createGunzip()) : parts;
 }
-function howToAddServeFlag(registration) {
+
+// src/backup/archive/entries.ts
+var MAX_RECORD_BYTES = 512 * 1024 * 1024;
+var CUT_SHORT2 = "The export ends in the middle of a record";
+async function* blobOf(record, blob) {
+  let written = 0;
+  for await (const piece of blob) {
+    written += piece.length;
+    yield piece;
+  }
+  if (written !== record.blob_bytes) {
+    throw new ClientError(`Attachment ${record.id} ('${record.file_name}') is ${written} bytes, not the ${record.blob_bytes} the server reports for it`);
+  }
+}
+async function* encodeEntries(entries) {
+  for await (const entry of entries) {
+    const json = utf8Encode(JSON.stringify(entry.record));
+    yield uint32(json.length);
+    yield json;
+    if ("blob" in entry)
+      yield* blobOf(entry.record, entry.blob);
+  }
+}
+function parseRecord(json) {
+  let value;
+  try {
+    value = JSON.parse(utf8Decode(json));
+  } catch {
+    throw new ClientError("The export holds a record that is not valid JSON");
+  }
+  if (typeof value?.kind !== "string") {
+    throw new ClientError("The export holds a record without a kind");
+  }
+  return value;
+}
+async function* decodeEntries(content) {
+  const reader = new ByteReader(content, CUT_SHORT2);
+  for (;; ) {
+    const length = await reader.readOrEnd(4);
+    if (length === null)
+      return;
+    const size = readUint32(length);
+    if (size > MAX_RECORD_BYTES)
+      throw new ClientError(CUT_SHORT2);
+    const record = parseRecord(await reader.read(size));
+    if (record.kind !== "attachment") {
+      yield { record };
+      continue;
+    }
+    let left = record.blob_bytes;
+    const blob = async function* () {
+      while (left > 0) {
+        const piece = await reader.readUpTo(left);
+        left -= piece.length;
+        yield piece;
+      }
+    }();
+    yield { record, blob };
+    while (left > 0)
+      left -= (await reader.readUpTo(left)).length;
+  }
+}
+
+// src/backup/archive/records.ts
+var RECORD_FORMAT = 1;
+var ENTITY_TYPES = ["doc", "task", "project", "decision"];
+
+// src/backup/import/labels.ts
+async function label(ctx, id, record) {
+  const labels = {};
+  if (record.kind === "folder" || record.kind === "database") {
+    if (record.tags.length > 0)
+      labels.tags = record.tags;
+    if (record.external_refs.length > 0) {
+      labels.external_refs = record.external_refs;
+    }
+  }
+  if (record.workflow_status !== null) {
+    labels.workflow_status = record.workflow_status;
+  }
+  if (record.due_date !== null)
+    labels.due_date = record.due_date;
+  if (record.due_date_label !== null) {
+    labels.due_date_label = record.due_date_label;
+  }
+  if (Object.keys(labels).length > 0)
+    await ctx.kb.labelDocument(id, labels);
+}
+
+// src/backup/import/databases.ts
+var ORPHANED = "database content left out: the database or row it belongs to was not imported";
+var RELATION = "relation";
+var TARGET = "target_database_id";
+var COLUMN_SETTINGS = [
+  "id",
+  "name",
+  "type",
+  "indexed",
+  "searchable",
+  "embedded",
+  "required",
+  "options",
+  "default",
+  "description",
+  TARGET,
+  "cardinality"
+];
+function settingsOf(column) {
+  const settings = {};
+  for (const name of COLUMN_SETTINGS) {
+    if (column[name] !== undefined)
+      settings[name] = column[name];
+  }
+  return settings;
+}
+function indexOf(index) {
+  return { id: index.id, fields: index.fields, unique: index.unique === true };
+}
+function batches(items, size) {
+  const result = [];
+  for (let at = 0;at < items.length; at += size) {
+    result.push(items.slice(at, at + size));
+  }
+  return result;
+}
+
+class DatabaseImporter {
+  ctx;
+  relationColumns = [];
+  relationIndexes = [];
+  relationValues = new Map;
+  leftOut = new Set;
+  relationsDone = false;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async database(record, spaceId) {
+    const { kb, ids, report, archivals } = this.ctx;
+    const later = new Set(record.columns.filter((column) => column.type === RELATION).map((column) => column.id));
+    const onLater = (index) => index.fields.some((field) => later.has(field));
+    const created = await kb.createDatabase({
+      title: record.title,
+      space_id: spaceId,
+      parent_id: ids.get("node", record.parent_id),
+      position: record.position,
+      description: record.description === null ? null : ids.rewrite(record.description),
+      columns: record.columns.filter((column) => !later.has(column.id)).map(settingsOf),
+      compound_indexes: record.compound_indexes.filter((index) => !onLater(index)).map(indexOf),
+      primary_column_id: record.primary_column_id
+    });
+    for (const column of record.columns) {
+      if (later.has(column.id)) {
+        this.relationColumns.push({ databaseId: created.id, column });
+      }
+    }
+    for (const index of record.compound_indexes.filter(onLater)) {
+      this.relationIndexes.push({ databaseId: created.id, index });
+    }
+    await label(this.ctx, created.id, record);
+    ids.set("node", record.id, created.id);
+    report.count("database");
+    if (record.archived)
+      archivals.push(() => kb.archiveDocument(created.id));
+  }
+  async rows(record) {
+    const { kb, ids, report } = this.ctx;
+    const databaseId = ids.get("node", record.database_id);
+    if (databaseId === null)
+      return report.note(ORPHANED);
+    const relations = new Set(this.relationColumns.filter((later) => later.databaseId === databaseId).map((later) => later.column.id));
+    const plain = record.rows.map((row) => ids.rewriteJson(Object.fromEntries(Object.entries(row.values).filter(([column]) => !relations.has(column)))));
+    const created = await kb.createRows(databaseId, plain);
+    record.rows.forEach((row, at) => {
+      const id = created[at];
+      ids.set("row", row.id, id);
+      const related = Object.entries(row.values).filter(([column, value]) => relations.has(column) && value !== null);
+      if (related.length > 0) {
+        this.relationValues.set(id, {
+          databaseId,
+          values: Object.fromEntries(related)
+        });
+      }
+    });
+    report.count("rows", created.length);
+  }
+  async rowBody(record) {
+    const { kb, ids } = this.ctx;
+    const rowId = ids.get("row", record.row_id);
+    if (rowId === null)
+      return this.ctx.report.note(ORPHANED);
+    await kb.replaceRowBody(rowId, ids.rewriteJson(record.blocks));
+    this.ctx.report.count("row-body");
+  }
+  async attachmentRows(record) {
+    const { kb, ids } = this.ctx;
+    const documentId = ids.get("node", record.document_id);
+    const attachmentId = ids.get("attachment", record.attachment_id);
+    const rowIds = record.row_ids.map((id) => ids.get("row", id)).filter((id) => id !== null);
+    if (documentId === null || attachmentId === null) {
+      return this.ctx.report.note(ORPHANED);
+    }
+    for (const batch of batches(rowIds, ATTACHMENT_ROWS_BATCH_SIZE)) {
+      await kb.showAttachmentOnRows(documentId, attachmentId, batch);
+    }
+    this.ctx.report.count("attachment-rows");
+  }
+  async view(record) {
+    const { kb, ids, report } = this.ctx;
+    await this.relations();
+    const databaseId = ids.get("node", record.database_id);
+    if (databaseId === null)
+      return report.note(ORPHANED);
+    await kb.createView(databaseId, {
+      name: record.name,
+      type: record.type,
+      config: ids.rewriteJson(record.config),
+      is_default: record.is_default
+    });
+    report.count("view");
+  }
+  async blocks(record) {
+    const { kb, ids, report } = this.ctx;
+    const documentId = ids.get("node", record.document_id);
+    if (documentId === null) {
+      return report.note("canvas content left out: its document was not imported");
+    }
+    for (const batch of batches(record.blocks, BLOCK_BATCH_SIZE)) {
+      await kb.addBlocks(documentId, ids.rewriteJson(batch));
+    }
+    report.count("blocks");
+  }
+  async relations() {
+    if (this.relationsDone)
+      return;
+    this.relationsDone = true;
+    const { kb, ids, report } = this.ctx;
+    for (const { databaseId, column } of this.relationColumns) {
+      const target = ids.get("node", column[TARGET]);
+      if (target === null) {
+        this.leftOut.add(`${databaseId}|${column.id}`);
+        report.note("relation column(s) left out: the database they point at was not imported");
+        continue;
+      }
+      await kb.addColumn(databaseId, {
+        ...settingsOf(column),
+        [TARGET]: target
+      });
+    }
+    for (const [rowId, row] of this.relationValues) {
+      const related = this.related(row);
+      if (Object.keys(related).length > 0)
+        await kb.updateRow(rowId, related);
+    }
+    for (const { databaseId, index } of this.relationIndexes) {
+      const usable = index.fields.every((field) => !this.leftOut.has(`${databaseId}|${field}`));
+      if (usable)
+        await kb.addIndex(databaseId, indexOf(index));
+    }
+  }
+  related(row) {
+    const { ids } = this.ctx;
+    const related = {};
+    for (const [column, value] of Object.entries(row.values)) {
+      if (this.leftOut.has(`${row.databaseId}|${column}`))
+        continue;
+      if (Array.isArray(value)) {
+        related[column] = value.map((id) => ids.get("row", id)).filter((id) => id !== null);
+      } else {
+        const row2 = ids.get("row", value);
+        if (row2 !== null)
+          related[column] = row2;
+      }
+    }
+    return related;
+  }
+}
+
+// src/backup/import/idMap.ts
+var OBJECT_ID = /\b[0-9a-f]{24}\b/g;
+var TASK_LINK = "taskId";
+
+class IdMap {
+  byKind = new Map;
+  all = new Map;
+  set(kind, exported, created) {
+    this.of(kind).set(exported, created);
+    if (kind !== "seal-root")
+      this.all.set(exported, created);
+  }
+  get(kind, exported) {
+    return exported === null ? null : this.of(kind).get(exported) ?? null;
+  }
+  rewrite(text) {
+    return text.replace(OBJECT_ID, (id) => this.all.get(id) ?? id);
+  }
+  mentionsUnknown(text) {
+    return (text.match(OBJECT_ID) ?? []).some((id) => !this.all.has(id));
+  }
+  static mentionsId(text) {
+    return text.search(OBJECT_ID) >= 0;
+  }
+  rewriteJson(value) {
+    if (typeof value === "string")
+      return this.rewrite(value);
+    if (Array.isArray(value)) {
+      return value.map((item) => this.rewriteJson(item));
+    }
+    if (typeof value !== "object" || value === null)
+      return value;
+    const rewritten = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (key === TASK_LINK && typeof item === "string" && !this.all.has(item)) {
+        continue;
+      }
+      rewritten[key] = this.rewriteJson(item);
+    }
+    return rewritten;
+  }
+  of(kind) {
+    let ids = this.byKind.get(kind);
+    if (ids === undefined) {
+      ids = new Map;
+      this.byKind.set(kind, ids);
+    }
+    return ids;
+  }
+}
+
+// src/backup/import/context.ts
+async function collect2(source) {
+  const pieces = [];
+  let length = 0;
+  for await (const piece of source) {
+    pieces.push(piece);
+    length += piece.length;
+  }
+  const bytes = new Uint8Array(length);
+  let at = 0;
+  for (const piece of pieces) {
+    bytes.set(piece, at);
+    at += piece.length;
+  }
+  return bytes;
+}
+
+// src/backup/import/nodes.ts
+var NOT_FOUND = 404;
+
+class NodeImporter {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async space(record) {
+    const { kb, request, ids, report } = this.ctx;
+    if (request.intoSpaceId !== null) {
+      ids.set("space", record.id, request.intoSpaceId);
+      return;
+    }
+    const created = await kb.createSpace({
+      name: record.name,
+      icon: record.icon,
+      color: record.color,
+      description: record.description,
+      access_mode: record.access_mode,
+      workflow_states: record.workflow_states,
+      encryption_policy: record.encryption_policy
+    });
+    if (record.allow_client_uploads)
+      await kb.allowClientUploads(created.id);
+    ids.set("space", record.id, created.id);
+    report.count("space");
+  }
+  async folder(record) {
+    const created = await this.ctx.kb.createFolder(this.placed(record));
+    await label(this.ctx, created.id, record);
+    this.created(record, created.id);
+  }
+  async document(record) {
+    const { kb, rewrites } = this.ctx;
+    const written = this.contentOf(record);
+    const created = await kb.createDocument({
+      ...this.placed(record),
+      doc_type: "document",
+      ...written,
+      source_id: record.source_id,
+      tags: record.tags,
+      external_refs: record.external_refs
+    });
+    await label(this.ctx, created.id, record);
+    this.created(record, created.id);
+    if (!IdMap.mentionsId(JSON.stringify([record.body, record.body_json]))) {
+      return;
+    }
+    rewrites.push(async () => {
+      const complete = this.contentOf(record);
+      if (JSON.stringify(complete) !== JSON.stringify(written)) {
+        await kb.replaceContent(created.id, complete);
+      }
+    });
+  }
+  contentOf(record) {
+    const { ids } = this.ctx;
+    return {
+      body: record.body === null ? null : ids.rewrite(record.body),
+      body_json: record.body_json === null ? null : ids.rewriteJson(record.body_json)
+    };
+  }
+  async canvas(record) {
+    const created = await this.ctx.kb.createDocument({
+      ...this.placed(record),
+      doc_type: "canvas",
+      body: null,
+      body_json: null,
+      source_id: record.source_id,
+      tags: record.tags,
+      external_refs: record.external_refs
+    });
+    await label(this.ctx, created.id, record);
+    this.created(record, created.id);
+  }
+  async vaultDocument(record) {
+    const { kb, request, report } = this.ctx;
+    if (record.tenant_id !== request.tenantId) {
+      report.note("vault document(s) left out: they open only in the account they were encrypted for");
+      return;
+    }
+    if (await this.exists(record.id)) {
+      report.note("vault document(s) left out: they still exist in this account");
+      return;
+    }
+    await kb.createVaultDocument({
+      ...this.placed(record),
+      doc_id: record.id,
+      enc_body: record.enc_body,
+      enc_meta: record.enc_meta,
+      enc_key_id: record.enc_key_id,
+      cipher: record.cipher
+    });
+    this.created(record, record.id);
+  }
+  async attachment(entry) {
+    const { kb, ids, report } = this.ctx;
+    const { record } = entry;
+    const owner = ids.get(record.owner === "row" ? "row" : "node", record.owner_id);
+    if (owner === null) {
+      report.note("attachment(s) left out: what they belong to was not imported");
+      return;
+    }
+    const upload = {
+      file_name: record.file_name,
+      mime_type: record.mime_type,
+      bytes: await collect2(entry.blob)
+    };
+    const created = record.owner === "row" ? await kb.attachToRow(owner, upload) : await kb.attach(owner, upload);
+    ids.set("attachment", record.id, created.id);
+    report.count("attachment");
+  }
+  placed(record) {
+    const { ids } = this.ctx;
+    return {
+      title: record.title,
+      space_id: this.spaceOf(record.space_id),
+      parent_id: ids.get("node", record.parent_id),
+      position: record.position
+    };
+  }
+  spaceOf(exported) {
+    const space = this.ctx.ids.get("space", exported);
+    if (space === null) {
+      throw new ClientError(`The export holds something of space ${exported} but not that space`);
+    }
+    return space;
+  }
+  created(record, id) {
+    const { kb, ids, report, archivals } = this.ctx;
+    ids.set("node", record.id, id);
+    report.count(record.kind);
+    if (record.archived)
+      archivals.push(() => kb.archiveDocument(id));
+  }
+  async exists(documentId) {
+    try {
+      await this.ctx.kb.document(documentId);
+      return true;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === NOT_FOUND)
+        return false;
+      throw error;
+    }
+  }
+}
+
+// src/backup/import/report.ts
+class ImportReport {
+  created = {};
+  notes = new Map;
+  sealRoots = [];
+  count(kind, by = 1) {
+    this.created[kind] = (this.created[kind] ?? 0) + by;
+  }
+  note(reason, times = 1) {
+    this.notes.set(reason, (this.notes.get(reason) ?? 0) + times);
+  }
+}
+
+// src/stores/secretStore.ts
+var KEY_STORE_NAMES = ["system", "file"];
+var KEY_STORE_LABELS = {
+  system: "the system keyring",
+  file: "the key file directory"
+};
+var STORE_NAMES = [...KEY_STORE_NAMES, "sidecar"];
+function passphraseNote(seal2) {
+  return `seal root ${seal2.rootId} is opened by a passphrase, which only the sidecar can hold`;
+}
+
+// src/backup/import/sealed.ts
+var POSITION_DECIMALS = 6;
+var IMPORTED = "imported";
+var OBJECT_ID2 = /^[0-9a-f]{24}$/;
+
+class SealedImporter {
+  ctx;
+  sealed;
+  services;
+  rootOf = new Map;
+  seqOf = new Map;
+  constructor(ctx, sealed, services) {
+    this.ctx = ctx;
+    this.sealed = sealed;
+    this.services = services;
+  }
+  async folder(record, spaceId) {
+    const place = await this.placeOf(record, spaceId);
+    this.created(record, place.title, await this.services.creator.createFolder({
+      name: place.title,
+      ...place.args
+    }));
+  }
+  async document(record, spaceId) {
+    const place = await this.placeOf(record, spaceId);
+    if (this.ctx.ids.mentionsUnknown(record.body)) {
+      this.ctx.report.note("sealed document(s) name something by an id the import did not know yet; that id stays as exported");
+    }
+    this.created(record, place.title, await this.services.creator.insertDocument({
+      title: place.title,
+      body: this.ctx.ids.rewrite(record.body),
+      summary: record.summary,
+      summary_short: record.summary_short,
+      keywords: record.keywords,
+      tags: record.tags,
+      ...place.args
+    }));
+  }
+  async attachment(entry) {
+    const { ids, report } = this.ctx;
+    const { record } = entry;
+    const documentId = ids.get("node", record.owner_id);
+    if (documentId === null) {
+      report.note("attachment(s) left out: what they belong to was not imported");
+      return;
+    }
+    const bytes = await collect2(entry.blob);
+    const attached = await this.services.attachments.attach({
+      document_id: documentId,
+      expected_seq: this.seqOf.get(documentId),
+      size: bytes.length,
+      file: {
+        filename: record.file_name,
+        mime: record.mime_type,
+        bytes: [bytes]
+      }
+    });
+    this.seqOf.set(documentId, attached.seal_seq);
+    ids.set("attachment", record.id, attached.attachment_id);
+    report.count("attachment");
+  }
+  async credential(record, spaceId) {
+    const { kb, ids, report } = this.ctx;
+    const rootId = ids.get("seal-root", record.seal_root_id);
+    if (rootId === null) {
+      report.note("sealed credential(s) left out: their seal root was not imported");
+      return;
+    }
+    const created = await this.services.credentials.insert({
+      root_id: rootId,
+      space_id: spaceId,
+      folder_id: ids.get("node", record.folder_id) ?? undefined,
+      title: record.title,
+      username: record.username ?? undefined,
+      url: record.url ?? undefined,
+      tags: record.tags,
+      notes: record.notes === null ? undefined : ids.rewrite(record.notes),
+      password: record.password ?? undefined,
+      totp: record.totp ?? undefined,
+      sealed_notes: record.sealed_notes === null ? undefined : ids.rewrite(record.sealed_notes),
+      custom: record.custom.map((field) => ({
+        key: field.key,
+        value: field.value,
+        sealed: field.secret
+      })),
+      display: {
+        icon: record.icon,
+        color: record.color,
+        favorite: record.favorite,
+        expires_at: record.expires_at,
+        external_refs: record.external_refs.map(({ system, key }) => ({
+          system,
+          key
+        }))
+      }
+    });
+    if (record.archived)
+      await kb.archiveCredential(created.id);
+    ids.set("credential", record.id, created.id);
+    report.count("credential");
+  }
+  async placeOf(record, spaceId) {
+    const parentId = this.ctx.ids.get("node", record.parent_id);
+    const inside = parentId !== null && this.rootOf.has(parentId);
+    const ownRoot = record.id === record.seal_root_id || !inside;
+    return {
+      title: ownRoot ? await this.rootName(record.title) : record.title,
+      args: {
+        space_id: spaceId,
+        parent_id: parentId ?? undefined,
+        position: record.position.toFixed(POSITION_DECIMALS),
+        ...ownRoot ? { store: this.ctx.request.store } : {}
+      }
+    };
+  }
+  async rootName(title) {
+    const taken = new Set((await this.sealed.names.all()).values());
+    const usable = (name) => !OBJECT_ID2.test(name) && !taken.has(name);
+    if (usable(title))
+      return title;
+    for (let copy = 1;; copy++) {
+      const name = `${title} (${IMPORTED}${copy === 1 ? "" : ` ${copy}`})`;
+      if (!usable(name))
+        continue;
+      this.ctx.report.note("seal root(s) renamed, because their name cannot be given to another seal root on this machine");
+      return name;
+    }
+  }
+  created(record, title, node) {
+    const { ids, report, archivals } = this.ctx;
+    ids.set("node", record.id, node.id);
+    this.rootOf.set(node.id, node.seal_root_id);
+    this.seqOf.set(node.id, node.seal_seq);
+    report.count(record.kind);
+    if (record.id === record.seal_root_id) {
+      ids.set("seal-root", record.id, node.id);
+    }
+    if (node.new_seal_root) {
+      report.sealRoots.push({
+        id: node.id,
+        name: title,
+        kept: node.secret_store === "system" || node.secret_store === "file" ? KEY_STORE_LABELS[node.secret_store] : "this machine"
+      });
+    }
+    if (record.archived) {
+      archivals.push(async () => {
+        await this.services.tree.archive(node.id, this.seqOf.get(node.id));
+      });
+    }
+  }
+}
+
+// src/backup/import/work.ts
+var CONFLICT = 409;
+var ACTIVE = "active";
+var LINKED = {
+  doc: "node",
+  task: "task",
+  project: "project",
+  decision: "decision"
+};
+
+class WorkImporter {
+  ctx;
+  takenSlugs = null;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async credential(record, spaceId) {
+    const { kb, ids, report } = this.ctx;
+    const created = await kb.createCredential({
+      space_id: spaceId,
+      folder_id: ids.get("node", record.folder_id),
+      title: record.title,
+      username: record.username,
+      url: record.url,
+      tags: record.tags,
+      password: record.password,
+      totp: record.totp,
+      notes: record.notes === null ? null : ids.rewrite(record.notes),
+      custom: record.custom.map((field) => ({
+        key: field.key,
+        value: field.value,
+        is_secret: field.secret
+      })),
+      icon: record.icon,
+      color: record.color,
+      favorite: record.favorite,
+      expires_at: record.expires_at,
+      external_refs: record.external_refs.map(({ system, key }) => ({
+        system,
+        key
+      }))
+    });
+    if (record.archived)
+      await kb.archiveCredential(created.id);
+    ids.set("credential", record.id, created.id);
+    report.count("credential");
+  }
+  async project(record) {
+    const { kb, ids, report } = this.ctx;
+    this.takenSlugs ??= new Set((await kb.projects()).map((project) => project.slug));
+    const slug = this.freeSlug(record.slug);
+    if (slug !== record.slug) {
+      report.note("project(s) given a new slug, because theirs is taken here");
+    }
+    const created = await kb.createProject({
+      name: record.name,
+      slug,
+      description: record.description === null ? null : ids.rewrite(record.description),
+      status: record.status,
+      spec_doc_id: ids.get("node", record.spec_doc_id),
+      space_id: ids.get("space", record.space_id),
+      icon: record.icon,
+      color: record.color
+    });
+    this.takenSlugs.add(created.slug);
+    ids.set("project", record.id, created.id);
+    report.count("project");
+  }
+  freeSlug(slug) {
+    const taken = this.takenSlugs;
+    if (!taken.has(slug))
+      return slug;
+    for (let copy = 2;; copy++) {
+      if (!taken.has(`${slug}-${copy}`))
+        return `${slug}-${copy}`;
+    }
+  }
+  async task(record) {
+    const { kb, ids, report, request, sourceTenantId } = this.ctx;
+    const sameTenant = sourceTenantId === request.tenantId;
+    if (record.assignee_id !== null && !sameTenant) {
+      report.note("task(s) left without their assignee: a person of the other account");
+    }
+    const created = await kb.createTask({
+      title: this.fitting(record.title),
+      status: record.status,
+      priority: record.priority,
+      due_date: record.due_date,
+      due_date_label: record.due_date_label,
+      assignee_id: sameTenant ? record.assignee_id : null,
+      waiting_on: record.waiting_on === null ? null : this.fitting(record.waiting_on),
+      project_id: ids.get("project", record.project_id),
+      parent_task_id: ids.get("task", record.parent_task_id),
+      exec_order: record.exec_order,
+      space_id: ids.get("space", record.space_id),
+      spec_doc_id: ids.get("node", record.spec_doc_id),
+      external_refs: record.external_refs
+    });
+    ids.set("task", record.id, created.id);
+    report.count("task");
+  }
+  fitting(text) {
+    const characters = [...text];
+    if (characters.length <= TASK_TEXT_LIMIT)
+      return text;
+    this.ctx.report.note(`task text(s) cut to the ${TASK_TEXT_LIMIT} characters the server takes for a title or 'waiting on'`);
+    return `${characters.slice(0, TASK_TEXT_LIMIT - 1).join("")}…`;
+  }
+  async decision(record) {
+    const { kb, ids, report } = this.ctx;
+    const projectId = ids.get("project", record.project_id);
+    if (projectId === null) {
+      return report.note("decision(s) left out: their project was not imported");
+    }
+    const created = await kb.createDecision({
+      project_id: projectId,
+      title: record.title,
+      rationale: ids.rewrite(record.rationale)
+    });
+    if (record.status !== ACTIVE) {
+      await kb.setDecisionStatus(created.id, record.status);
+    }
+    ids.set("decision", record.id, created.id);
+    report.count("decision");
+  }
+  async link(record) {
+    const { kb, ids, report } = this.ctx;
+    const source = ids.get(LINKED[record.source.type], record.source.id);
+    const target = ids.get(LINKED[record.target.type], record.target.id);
+    if (source === null || target === null) {
+      report.note("link(s) left out: one of their ends was not imported");
+      return;
+    }
+    try {
+      await kb.createLink({
+        source: { type: record.source.type, id: source },
+        target: { type: record.target.type, id: target },
+        link_type: record.link_type,
+        note: record.note
+      });
+    } catch (error) {
+      if (error instanceof ApiError && error.status === CONFLICT)
+        return;
+      throw error;
+    }
+    report.count("link");
+  }
+}
+
+// src/backup/import/importer.ts
+class ImportStopped extends ClientError {
+  report;
+  constructor(message, report) {
+    super(message);
+    this.report = report;
+  }
+}
+var WHAT_STAYS = "What was imported before it stays in the account; nothing was removed.";
+function describe(record) {
+  const named = record;
+  const name = named.title ?? named.name ?? named.file_name;
+  return name === undefined ? `a ${record.kind}` : `${record.kind} '${name}'`;
+}
+
+class Importer {
+  ctx;
+  nodes;
+  sealed;
+  databases;
+  work;
+  progress;
+  end = null;
+  section = null;
+  constructor(targets, request, progress) {
+    this.ctx = {
+      kb: targets.kb,
+      request,
+      ids: new IdMap,
+      report: new ImportReport,
+      sourceTenantId: null,
+      rewrites: [],
+      archivals: []
+    };
+    this.nodes = new NodeImporter(this.ctx);
+    this.sealed = new SealedImporter(this.ctx, targets.sealed, targets.services);
+    this.databases = new DatabaseImporter(this.ctx);
+    this.work = new WorkImporter(this.ctx);
+    this.progress = progress;
+  }
+  async run(entries) {
+    await this.assertTargetSpace();
+    let first = true;
+    try {
+      for await (const entry of entries) {
+        if (first && entry.record.kind !== "manifest") {
+          throw new ClientError("The export does not start with its manifest");
+        }
+        first = false;
+        await this.guarded(entry.record, () => this.take(entry));
+      }
+    } catch (error) {
+      if (first || !(error instanceof ClientError))
+        throw error;
+      if (error instanceof ImportStopped)
+        throw error;
+      throw new ImportStopped(`The import stopped: ${error.message}
+${WHAT_STAYS}`, this.ctx.report);
+    }
+    if (this.end === null) {
+      throw new ImportStopped("The export ends without its closing record, so it is incomplete. What was imported from it stays in the account.", this.ctx.report);
+    }
+    return this.ctx.report;
+  }
+  get leftOutByExport() {
+    return this.end?.left_out ?? [];
+  }
+  async assertTargetSpace() {
+    const { intoSpaceId } = this.ctx.request;
+    if (intoSpaceId === null)
+      return;
+    const spaces = await this.ctx.kb.spaces();
+    if (!spaces.some((space) => space.id === intoSpaceId)) {
+      throw new ClientError(`Space ${intoSpaceId} does not exist or is not one this token may use`);
+    }
+  }
+  async guarded(record, step) {
+    try {
+      await step();
+    } catch (error) {
+      if (!(error instanceof ClientError) || error instanceof ImportStopped) {
+        throw error;
+      }
+      throw new ImportStopped(`The import stopped at ${describe(record)}: ${error.message}
+${WHAT_STAYS}`, this.ctx.report);
+    }
+  }
+  announce(section) {
+    if (this.section === section)
+      return;
+    this.section = section;
+    this.progress(section);
+  }
+  async take(entry) {
+    const { record } = entry;
+    switch (record.kind) {
+      case "manifest":
+        if (record.format !== RECORD_FORMAT) {
+          throw new ClientError(`The export has record format ${record.format}, this client reads ${RECORD_FORMAT}; use the version of @safekb/mcp that wrote it`);
+        }
+        this.ctx.sourceTenantId = record.source.tenant_id;
+        return;
+      case "space":
+        this.announce("Spaces");
+        return this.nodes.space(record);
+      case "folder":
+        this.announce("Documents and folders");
+        return this.nodes.folder(record);
+      case "document":
+        this.announce("Documents and folders");
+        return this.nodes.document(record);
+      case "canvas":
+        this.announce("Documents and folders");
+        return this.nodes.canvas(record);
+      case "vault-document":
+        return this.nodes.vaultDocument(record);
+      case "sealed-folder":
+        this.announce("Documents and folders");
+        return this.sealed.folder(record, this.nodes.spaceOf(record.space_id));
+      case "sealed-document":
+        this.announce("Documents and folders");
+        return this.sealed.document(record, this.nodes.spaceOf(record.space_id));
+      case "database":
+        this.announce("Documents and folders");
+        return this.databases.database(record, this.nodes.spaceOf(record.space_id));
+      case "attachment": {
+        const file = entry;
+        return record.owner === "sealed-document" ? this.sealed.attachment(file) : this.nodes.attachment(file);
+      }
+      case "credential": {
+        this.announce("Credentials");
+        const spaceId = this.nodes.spaceOf(record.space_id);
+        return record.seal_root_id === null ? this.work.credential(record, spaceId) : this.sealed.credential(record, spaceId);
+      }
+      case "project":
+        this.announce("Projects, tasks and decisions");
+        return this.work.project(record);
+      case "task":
+        this.announce("Projects, tasks and decisions");
+        return this.work.task(record);
+      case "decision":
+        return this.work.decision(record);
+      case "blocks":
+        this.announce("Canvas blocks and database rows");
+        return this.databases.blocks(record);
+      case "rows":
+        this.announce("Canvas blocks and database rows");
+        return this.databases.rows(record);
+      case "row-body":
+        return this.databases.rowBody(record);
+      case "attachment-rows":
+        return this.databases.attachmentRows(record);
+      case "view":
+        return this.databases.view(record);
+      case "link":
+        await this.databases.relations();
+        this.announce("Links");
+        return this.work.link(record);
+      case "end":
+        this.end = record;
+        return this.finish();
+      default:
+        throw new ClientError(`The export holds a record of a kind this client does not know: ${record.kind}`);
+    }
+  }
+  async finish() {
+    await this.databases.relations();
+    for (const rewrite of this.ctx.rewrites)
+      await rewrite();
+    for (const archive of this.ctx.archivals.reverse())
+      await archive();
+  }
+}
+
+// src/backup/console.ts
+var EXPORT_FILE_MODE = 384;
+var NOT_IN_AN_EXPORT = "Not in an export: version history, who created what and when, shares, public links, space members, and the account's settings.";
+var LABELS = [
+  ["space", "space(s)"],
+  ["folder", "folder(s)"],
+  ["document", "document(s)"],
+  ["canvas", "canvas document(s)"],
+  [
+    "vault-document",
+    "vault document(s), still encrypted to their owner's vault"
+  ],
+  ["sealed-folder", "sealed folder(s)"],
+  ["sealed-document", "sealed document(s)"],
+  ["database", "database(s)"],
+  ["rows", "database row(s)"],
+  ["view", "database view(s)"],
+  ["attachment", "attachment(s)"],
+  ["credential", "credential(s)"],
+  ["project", "project(s)"],
+  ["task", "task(s)"],
+  ["decision", "decision(s)"],
+  ["link", "link(s)"]
+];
+function countLines(counts) {
+  const lines = LABELS.filter(([kind]) => (counts[kind] ?? 0) > 0).map(([kind, label2]) => `  ${counts[kind]} ${label2}
+`);
+  return lines.length === 0 ? `  nothing
+` : lines.join("");
+}
+function alreadyThere(path) {
+  return new ClientError(`${path} already exists; choose a new path`);
+}
+async function* bytesOf(path) {
+  try {
+    for await (const chunk of createReadStream(path))
+      yield chunk;
+  } catch (error) {
+    throw fileError(error);
+  }
+}
+
+class BackupConsole {
+  reader;
+  constructor(reader) {
+    this.reader = reader;
+  }
+  progress = (line) => {
+    this.reader.write(`${printable2(line)}…
+`);
+  };
+  async export(exporter, path, compression) {
+    if (existsSync2(path))
+      throw alreadyThere(path);
+    const prepared = await exporter.prepare();
+    const passphrase = await readNewPassphrase(this.reader, "everything in the file");
+    const file = await open3(path, "wx", EXPORT_FILE_MODE).catch((error) => {
+      throw error.code === "EEXIST" ? alreadyThere(path) : fileError(error);
+    });
+    let complete = false;
+    const discard = () => {
+      if (!complete)
+        rmSync(path, { force: true });
+    };
+    process.once("exit", discard);
+    try {
+      const content = encodeEntries(exporter.entries(prepared));
+      for await (const part of sealArchive(content, passphrase, compression)) {
+        await file.write(part);
+      }
+      await file.sync();
+      complete = true;
+    } finally {
+      await file.close();
+      discard();
+      process.removeListener("exit", discard);
+    }
+    const { counts, leftOut } = exporter.written;
+    this.reader.write(`Exported to ${path}:
+${countLines(counts)}`);
+    this.writeNotes("Left out", leftOut);
+    this.reader.write(`${NOT_IN_AN_EXPORT}
+The file opens only with the passphrase you typed: keep both, and keep them apart.
+`);
+  }
+  async import(importer, path) {
+    await stat2(path).catch((error) => {
+      throw fileError(error);
+    });
+    const passphrase = await readPassphrase(this.reader);
+    const entries = decodeEntries(openArchive(bytesOf(path), passphrase));
+    let report;
+    try {
+      report = await importer.run(entries);
+    } catch (error) {
+      if (error instanceof ImportStopped) {
+        this.writeReport("Imported before the import stopped", error.report);
+      }
+      throw error;
+    }
+    this.writeReport(`Imported from ${path}`, report);
+    this.writeNotes("The export was made without", importer.leftOutByExport);
+  }
+  writeReport(heading, report) {
+    this.reader.write(`${heading}:
+${countLines(report.created)}`);
+    this.writeNotes("Notes", [...report.notes].map(([reason, times]) => `${times} ${reason}`));
+    if (report.sealRoots.length === 0)
+      return;
+    this.reader.write(`New seal roots, each with a newly generated key. Back the keys up (safekb-mcp --export-keys): a lost key cannot be recovered.
+`);
+    for (const root of report.sealRoots) {
+      this.reader.write(`  "${printable2(root.name)}" (${root.id}), key in ${root.kept}
+`);
+    }
+  }
+  writeNotes(heading, notes) {
+    if (notes.length === 0)
+      return;
+    this.reader.write(`${heading}:
+`);
+    for (const note of notes)
+      this.reader.write(`  ${printable2(note)}
+`);
+  }
+}
+
+// src/sealed/credentialAccess.ts
+function visibleOf(credential2) {
+  return {
+    title: credential2.title,
+    username: credential2.username,
+    url: credential2.url,
+    tags: credential2.tags,
+    notes: credential2.notes,
+    custom: credential2.custom.flatMap(({ key, value }) => value === undefined ? [] : [{ key, value }])
+  };
+}
+function assertDistinctCustomKeys(visible, values) {
+  const keys = [...visible.custom, ...values.custom].map(({ key }) => key);
+  if (keys.some((key) => key.length === 0)) {
+    throw new ClientError("A custom field needs a key");
+  }
+  if (new Set(keys).size !== keys.length) {
+    throw new ClientError("Custom field keys must be unique");
+  }
+}
+
+class CredentialAccess {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  context(credentialId) {
+    return { tenant: this.ctx.tenant, credential: credentialId };
+  }
+  async newDek(rootId, credentialId) {
+    const { keys } = this.ctx.session.require(rootId);
+    const dek = generateDek();
+    return {
+      dek,
+      encDek: serializeEnvelope(await wrapDek(keys, credentialId, dek))
+    };
+  }
+  async rewrapDek(dek, rootId, credentialId) {
+    const { keys } = this.ctx.session.require(rootId);
+    return serializeEnvelope(await wrapDek(keys, credentialId, dek));
+  }
+  async open(credentialId) {
+    const credential2 = await this.ctx.api.fetchSealedCredential(credentialId);
+    const { keys } = this.ctx.session.require(credential2.seal_root_id);
+    const dek = await unwrapDek(keys, credentialId, parseEnvelope(credential2.enc_dek));
+    const values = await unsealCredentialFields(dek, this.context(credentialId), credential2.enc_fields);
+    return { credential: credential2, dek, values };
+  }
+  async seal(credentialId, dek, visible, values) {
+    assertDistinctCustomKeys(visible, values);
+    return {
+      visible,
+      encFields: await sealCredentialFields(dek, this.context(credentialId), values),
+      visibleDigest: await visibleFieldsDigest(visible)
+    };
+  }
+  async sign(message, signerRootIds) {
+    const signers = signerRootIds.map((rootId) => this.ctx.session.require(rootId).keys);
+    return signMessage(await buildCredentialMessage(message), signers);
+  }
+}
+
+// src/sealed/nodeAccess.ts
+function assertSeq(node, expectedSeq) {
+  if (node.seal_seq !== expectedSeq) {
+    throw new ClientError(`${node.id} changed: its seal_seq is ${node.seal_seq}, not ${expectedSeq}. Read it again before writing.`);
+  }
+}
+function assertAccepted(node) {
+  if (node.deposited) {
+    throw new ClientError(`${node.id} is a pending deposit; accept_sealed_deposit or reject_sealed_deposit it first`);
+  }
+}
+function writeResult(node) {
+  return {
+    id: node.id,
+    seal_root_id: node.seal_root_id,
+    seal_seq: node.seal_seq
+  };
+}
+
+class NodeAccess {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  nodeContext(nodeId) {
+    return { tenant: this.ctx.tenant, node: nodeId };
+  }
+  async dekOf(node) {
+    const { keys } = this.ctx.session.require(node.seal_root_id);
+    if (node.enc_dek !== null) {
+      return unwrapDek(keys, node.id, parseEnvelope(node.enc_dek));
+    }
+    if (node.box_dek !== null) {
+      return openBoxDek(keys, node.id, parseBoxDek(node.box_dek));
+    }
+    throw new ClientError(`Sealed node ${node.id} has no wrapped key`);
+  }
+  async open(nodeId) {
+    return this.openNode(await this.ctx.api.getNode(nodeId));
+  }
+  async openNode(node) {
+    const root = this.ctx.session.require(node.seal_root_id);
+    const dek = await this.dekOf(node);
+    const meta = await decryptMeta(dek, this.nodeContext(node.id), parseEnvelope(node.enc_meta));
+    return { node, root, dek, meta };
+  }
+  async sign(message, signerRootIds) {
+    const signers = signerRootIds.map((rootId) => this.ctx.session.require(rootId).keys);
+    return signMessage(await buildMessage(message), signers);
+  }
+  async signPlain(op, node) {
+    const sigs = await this.sign({
+      op,
+      tenant: this.ctx.tenant,
+      node: node.id,
+      root: node.seal_root_id,
+      baseSeq: node.seal_seq
+    }, [node.seal_root_id]);
+    return { base_seq: node.seal_seq, sigs };
+  }
+}
+
+// src/backup/export/credentials.ts
+var CUSTOM_FIELD = "custom:";
+
+class CredentialExporter {
+  kb;
+  sealed;
+  roots;
+  exported;
+  constructor(kb, sealed, roots, exported) {
+    this.kb = kb;
+    this.sealed = sealed;
+    this.roots = roots;
+    this.exported = exported;
+  }
+  async* entries(credentials, sealRoots) {
+    for (const credential2 of credentials) {
+      const sealRootId = sealRoots.get(credential2.id) ?? null;
+      if (sealRootId !== null && this.roots.isLocked(sealRootId))
+        continue;
+      const secrets = sealRootId === null ? await this.revealed(credential2) : await this.unsealed(credential2.id);
+      this.exported.count("credential");
+      yield { record: this.record(credential2, sealRootId, secrets) };
+    }
+  }
+  record(credential2, sealRootId, secrets) {
+    return {
+      kind: "credential",
+      id: credential2.id,
+      space_id: credential2.space_id,
+      folder_id: credential2.folder_id,
+      seal_root_id: sealRootId,
+      title: credential2.title,
+      username: credential2.username,
+      url: credential2.url,
+      tags: credential2.tags,
+      icon: credential2.icon,
+      color: credential2.color,
+      favorite: credential2.favorite,
+      expires_at: credential2.expires_at,
+      external_refs: credential2.external_refs,
+      archived: credential2.archived,
+      ...secrets
+    };
+  }
+  async revealed(credential2) {
+    const reveal = (has, field) => has ? this.kb.reveal(credential2.id, field) : null;
+    const custom = [];
+    for (const field of credential2.custom) {
+      custom.push(field.is_secret === true ? {
+        key: field.key,
+        value: await this.kb.reveal(credential2.id, `${CUSTOM_FIELD}${field.key}`),
+        secret: true
+      } : { key: field.key, value: field.value ?? "", secret: false });
+    }
+    return {
+      password: await reveal(credential2.has_password, "password"),
+      totp: await reveal(credential2.has_totp, "totp"),
+      notes: await reveal(credential2.has_notes, "notes"),
+      sealed_notes: null,
+      custom
+    };
+  }
+  async unsealed(credentialId) {
+    const { credential: credential2, values } = await this.sealed.open(credentialId);
+    const visible = credential2.custom.filter((field) => field.sealed !== true && field.is_secret !== true);
+    return {
+      password: values.password,
+      totp: values.totp,
+      notes: credential2.notes,
+      sealed_notes: values.sealed_notes,
+      custom: [
+        ...visible.map((field) => ({
+          key: field.key,
+          value: field.value ?? "",
+          secret: false
+        })),
+        ...values.custom.map((field) => ({ ...field, secret: true }))
+      ]
+    };
+  }
+}
+
+// src/backup/export/databases.ts
+var OWNED = "owned";
+
+class ContentExporter {
+  kb;
+  exported;
+  constructor(kb, exported) {
+    this.kb = kb;
+    this.exported = exported;
+  }
+  async* blocks() {
+    for (const documentId of this.exported.canvases) {
+      const blocks = await this.kb.blocks(documentId);
+      if (blocks.length === 0)
+        continue;
+      this.exported.count("blocks");
+      yield {
+        record: {
+          kind: "blocks",
+          document_id: documentId,
+          blocks: blocks.map(blockOf)
+        }
+      };
+    }
+  }
+  async* views() {
+    for (const databaseId of this.exported.databases) {
+      for (const view of await this.kb.views(databaseId)) {
+        this.exported.count("view");
+        yield {
+          record: {
+            kind: "view",
+            database_id: databaseId,
+            name: view.name,
+            type: view.type,
+            config: view.config,
+            is_default: view.is_default
+          }
+        };
+      }
+    }
+  }
+  async* rows() {
+    for (const databaseId of this.exported.databases) {
+      for await (const rows of this.kb.rows(databaseId)) {
+        for (const row of rows)
+          this.exported.rows.add(row.id);
+        this.exported.count("rows", rows.length);
+        yield { record: { kind: "rows", database_id: databaseId, rows } };
+        yield* this.bodies(rows);
+        yield* this.files(databaseId, rows);
+      }
+    }
+  }
+  async* bodies(rows) {
+    for (const row of rows) {
+      const blocks = await this.kb.rowBody(row.id);
+      if (blocks.length === 0)
+        continue;
+      this.exported.count("row-body");
+      yield {
+        record: {
+          kind: "row-body",
+          row_id: row.id,
+          blocks: blocks.map(blockOf)
+        }
+      };
+    }
+  }
+  async* files(databaseId, rows) {
+    const byRow = await this.kb.rowAttachments(databaseId, rows.map((row) => row.id));
+    for (const [rowId, attachments] of Object.entries(byRow)) {
+      for (const attachment of attachments) {
+        if (attachment.restricted) {
+          this.exported.leftOut.push(`an attachment shown on row ${rowId} that this token may not read`);
+          continue;
+        }
+        if (attachment.link !== OWNED)
+          continue;
+        this.exported.count("attachment");
+        yield {
+          record: {
+            kind: "attachment",
+            id: attachment.id,
+            owner: "row",
+            owner_id: rowId,
+            file_name: attachment.file_name,
+            mime_type: attachment.mime_type,
+            blob_bytes: attachment.size_bytes
+          },
+          blob: await this.kb.rowAttachmentFile(rowId, attachment.id)
+        };
+      }
+    }
+  }
+  async* attachmentRows() {
+    for (const shown of this.exported.attachmentRows) {
+      const rowIds = shown.rowIds.filter((id) => this.exported.rows.has(id));
+      if (rowIds.length === 0)
+        continue;
+      this.exported.count("attachment-rows");
+      yield {
+        record: {
+          kind: "attachment-rows",
+          document_id: shown.documentId,
+          attachment_id: shown.attachmentId,
+          row_ids: rowIds
+        }
+      };
+    }
+  }
+}
+function blockOf(block) {
+  return {
+    block_id: block.block_id,
+    type: block.type,
+    content: block.content ?? null,
+    attrs: block.attrs ?? {},
+    position: block.position,
+    parent_block_id: block.parent_block_id ?? null
+  };
+}
+
+// src/backup/export/exported.ts
+class Exported {
+  entities = {
+    doc: new Set,
+    task: new Set,
+    project: new Set,
+    decision: new Set
+  };
+  rows = new Set;
+  canvases = [];
+  databases = [];
+  attachmentRows = [];
+  counts = {};
+  leftOut = [];
+  count(kind, by = 1) {
+    this.counts[kind] = (this.counts[kind] ?? 0) + by;
+  }
+}
+
+// src/backup/export/links.ts
+class LinkExporter {
+  kb;
+  exported;
+  constructor(kb, exported) {
+    this.kb = kb;
+    this.exported = exported;
+  }
+  async* entries() {
+    let leadingOut = 0;
+    for (const type of ENTITY_TYPES) {
+      for (const id of this.exported.entities[type]) {
+        for (const link of await this.kb.outgoingLinks(type, id)) {
+          const inside = link.target_tenant_id === null && this.exported.entities[link.target_type]?.has(link.target_id);
+          if (!inside) {
+            leadingOut++;
+            continue;
+          }
+          this.exported.count("link");
+          yield {
+            record: {
+              kind: "link",
+              source: { type: link.source_type, id: link.source_id },
+              target: { type: link.target_type, id: link.target_id },
+              link_type: link.link_type,
+              note: link.note
+            }
+          };
+        }
+      }
+    }
+    if (leadingOut > 0) {
+      this.exported.leftOut.push(`${leadingOut} link(s) to something that is not in the export`);
+    }
+  }
+}
+
+// src/backup/export/nodes.ts
+var DATABASE = "database";
+var CANVAS = "canvas";
+var JSON_BODY = "json";
+
+class NodeExporter {
+  from;
+  exported;
+  constructor(from, exported) {
+    this.from = from;
+    this.exported = exported;
+  }
+  async* entries(planned) {
+    if (planned.sealRootId !== null) {
+      if (!this.from.roots.isLocked(planned.sealRootId)) {
+        yield* this.sealed(planned);
+      }
+      return;
+    }
+    const document = await this.from.kb.document(planned.id);
+    const record = await this.record(planned, document);
+    this.exported.count(record.kind);
+    if (record.kind !== "vault-document") {
+      this.exported.entities.doc.add(planned.id);
+    }
+    yield { record };
+    if (record.kind === "document" || record.kind === "canvas") {
+      yield* this.attachments(planned.id);
+    }
+  }
+  async record(planned, document) {
+    const node = {
+      id: document.id,
+      space_id: document.space_id,
+      parent_id: planned.parentId,
+      title: document.title,
+      position: document.position,
+      archived: document.archived
+    };
+    if (document.encrypted) {
+      return {
+        kind: "vault-document",
+        ...node,
+        tenant_id: this.from.sealed.tenant,
+        enc_body: await this.vaultBody(document.id),
+        enc_meta: document.enc_meta,
+        enc_key_id: document.enc_key_id,
+        cipher: document.cipher
+      };
+    }
+    const labelled = {
+      ...node,
+      tags: document.tags,
+      external_refs: document.external_refs,
+      workflow_status: document.workflow_status,
+      due_date: document.due_date,
+      due_date_label: document.due_date_label
+    };
+    if (document.doc_type === DATABASE) {
+      const database = await this.from.kb.database(document.id);
+      this.exported.databases.push(document.id);
+      return {
+        kind: "database",
+        ...labelled,
+        description: database.description,
+        columns: database.columns,
+        compound_indexes: database.compound_indexes,
+        primary_column_id: database.primary_column_id
+      };
+    }
+    if (document.is_folder)
+      return { kind: "folder", ...labelled };
+    if (document.doc_type === CANVAS) {
+      this.exported.canvases.push(document.id);
+      return { kind: "canvas", ...labelled, source_id: document.source_id };
+    }
+    const asJson = document.body_format === JSON_BODY;
+    return {
+      kind: "document",
+      ...labelled,
+      source_id: document.source_id,
+      body: asJson ? null : await this.from.kb.body(document.id),
+      body_json: asJson ? await this.from.kb.bodyJson(document.id) : null
+    };
+  }
+  async vaultBody(documentId) {
+    const body = await this.from.kb.body(documentId);
+    if (body === null) {
+      throw new ClientError(`Vault document ${documentId} has no stored body`);
+    }
+    return body;
+  }
+  async* attachments(documentId) {
+    for (const attachment of await this.from.kb.attachments(documentId)) {
+      this.exported.count("attachment");
+      if (attachment.linked_rows.length > 0) {
+        this.exported.attachmentRows.push({
+          documentId,
+          attachmentId: attachment.id,
+          rowIds: attachment.linked_rows
+        });
+      }
+      yield {
+        record: {
+          kind: "attachment",
+          id: attachment.id,
+          owner: "document",
+          owner_id: documentId,
+          file_name: attachment.file_name,
+          mime_type: attachment.mime_type,
+          blob_bytes: attachment.size_bytes
+        },
+        blob: await this.from.kb.attachmentFile(documentId, attachment.id)
+      };
+    }
+  }
+  async* sealed(planned) {
+    const open4 = await this.from.access.openNode(toSealedNode(await this.from.sealed.api.getDocument(planned.id)));
+    const { node, meta } = open4;
+    const placed = {
+      id: node.id,
+      space_id: node.space_id,
+      parent_id: planned.parentId,
+      title: meta.title,
+      position: node.position,
+      archived: node.archived,
+      seal_root_id: node.seal_root_id
+    };
+    if (node.is_folder) {
+      this.exported.count("sealed-folder");
+      yield { record: { kind: "sealed-folder", ...placed } };
+      return;
+    }
+    const indexed = this.from.sealed.session.require(node.seal_root_id).index.get(node.id)?.entry;
+    const record = {
+      kind: "sealed-document",
+      ...placed,
+      tags: meta.tags,
+      body: (await this.from.services.documents.storedBody(open4)).body,
+      summary: indexed?.summary ?? "",
+      summary_short: meta.summary_short,
+      keywords: indexed?.keywords ?? []
+    };
+    this.exported.count("sealed-document");
+    yield { record };
+    yield* this.sealedAttachments(node.id);
+  }
+  async* sealedAttachments(documentId) {
+    const owner = "sealed-document";
+    for (const file of await this.from.services.attachments.files(documentId)) {
+      this.exported.count("attachment");
+      yield {
+        record: {
+          kind: "attachment",
+          id: file.id,
+          owner,
+          owner_id: documentId,
+          file_name: file.meta.filename,
+          mime_type: file.meta.mime,
+          blob_bytes: file.meta.size
+        },
+        blob: file.bytes()
+      };
+    }
+  }
+}
+
+// src/backup/export/plan.ts
+var DELETING = "deleting";
+function* walk(nodes, parentId) {
+  for (const node of nodes) {
+    if (node.status === DELETING)
+      continue;
+    yield {
+      id: node.id,
+      parentId,
+      sealRootId: node.key_mode === KEY_MODE_SEALED ? node.seal_root_id : null
+    };
+    yield* walk(node.children, node.id);
+  }
+}
+function find(nodes, id) {
+  for (const node of nodes) {
+    if (node.id === id)
+      return node;
+    const below = find(node.children, id);
+    if (below !== null)
+      return below;
+  }
+  return null;
+}
+
+class ExportPlanner {
+  kb;
+  constructor(kb) {
+    this.kb = kb;
+  }
+  async plan(selection) {
+    const reachable = await this.kb.spaces();
+    const whole = selection.spaces === null && selection.documents.length === 0 ? reachable : (selection.spaces ?? []).map((id) => this.spaceOf(reachable, id));
+    const wholeSpaceIds = new Set(whole.map((space) => space.id));
+    const nodes = new Map;
+    for (const space of whole) {
+      for (const node of walk(await this.kb.tree(space.id), null)) {
+        nodes.set(node.id, node);
+      }
+    }
+    const spaces = new Map(whole.map((space) => [space.id, space]));
+    for (const documentId of selection.documents) {
+      if (nodes.has(documentId))
+        continue;
+      const document = await this.kb.document(documentId);
+      const space = this.spaceOf(reachable, document.space_id);
+      spaces.set(space.id, space);
+      const top = find(await this.kb.tree(space.id), documentId);
+      if (top === null) {
+        throw new ClientError(`Document ${documentId} is not in the tree of its space ${space.id}`);
+      }
+      for (const node of walk([top], null))
+        nodes.set(node.id, node);
+    }
+    return {
+      spaces: [...spaces.values()],
+      wholeSpaceIds,
+      nodes: this.parentsFirst(nodes),
+      everything: selection.spaces === null && selection.documents.length === 0
+    };
+  }
+  spaceOf(reachable, id) {
+    const space = reachable.find((candidate) => candidate.id === id);
+    if (space === undefined) {
+      throw new ClientError(`Space ${id} does not exist or is not one this token may use`);
+    }
+    return space;
+  }
+  parentsFirst(nodes) {
+    const ordered = [];
+    const placed = new Set;
+    const place = (node) => {
+      if (placed.has(node.id))
+        return;
+      const parent = node.parentId === null ? undefined : nodes.get(node.parentId);
+      if (parent !== undefined)
+        place(parent);
+      placed.add(node.id);
+      ordered.push(node);
+    };
+    for (const node of nodes.values())
+      place(node);
+    return ordered;
+  }
+}
+
+// src/backup/export/sealedRoots.ts
+function unanswered(error) {
+  return error instanceof NetworkError || error instanceof ApiError;
+}
+
+class SealedRoots {
+  ctx;
+  services;
+  locked = new Set;
+  constructor(ctx, services) {
+    this.ctx = ctx;
+    this.services = services;
+  }
+  async unlock(rootIds, skipLocked) {
+    const refused = [];
+    for (const rootId of rootIds) {
+      try {
+        await this.services.roots.unlock({ root_id: rootId });
+      } catch (error) {
+        if (!(error instanceof ClientError) || unanswered(error))
+          throw error;
+        this.locked.add(rootId);
+        refused.push(`  ${printable2(await this.ctx.names.describe(rootId))}: ${error.message}`);
+      }
+    }
+    if (refused.length > 0 && !skipLocked) {
+      throw new ClientError(`${refused.length} seal root(s) cannot be opened, so the export would be incomplete:
+${refused.join(`
+`)}
+Put their secrets where this machine finds them (a passphrase: safekb-mcp --sidecar, then 'add <name or id>'), or pass --skip-locked to export without them.`);
+    }
+  }
+  isLocked(rootId) {
+    return this.locked.has(rootId);
+  }
+  lockedIds() {
+    return [...this.locked];
+  }
+}
+
+// src/backup/export/work.ts
+class WorkExporter {
+  kb;
+  exported;
+  constructor(kb, exported) {
+    this.kb = kb;
+    this.exported = exported;
+  }
+  async* entries(plan) {
+    const { doc, project, task, decision } = this.exported.entities;
+    const inSpace = (spaceId) => spaceId === null ? plan.everything : plan.wholeSpaceIds.has(spaceId);
+    const exportedDoc = (id) => id !== null && doc.has(id) ? id : null;
+    const projects = (await this.kb.projects()).filter((candidate) => inSpace(candidate.space_id));
+    for (const found of projects) {
+      project.add(found.id);
+      this.exported.count("project");
+      yield { record: this.project(found, exportedDoc(found.spec_doc_id)) };
+    }
+    const tasks = [];
+    let merged = 0;
+    const seen = new Set;
+    for await (const found of this.kb.tasks()) {
+      if (seen.has(found.id))
+        continue;
+      seen.add(found.id);
+      if (found.project_id === null ? !inSpace(found.space_id) : !project.has(found.project_id)) {
+        continue;
+      }
+      if (found.merged_into !== null)
+        merged++;
+      else
+        tasks.push(found);
+    }
+    if (merged > 0) {
+      this.exported.leftOut.push(`${merged} task(s) that were merged into another task`);
+    }
+    for (const found of parentsFirst(tasks)) {
+      task.add(found.id);
+      this.exported.count("task");
+      yield {
+        record: {
+          kind: "task",
+          id: found.id,
+          title: found.title,
+          status: found.status,
+          priority: found.priority,
+          due_date: found.due_date,
+          due_date_label: found.due_date_label,
+          assignee_id: found.assignee_id,
+          waiting_on: found.waiting_on,
+          project_id: found.project_id,
+          parent_task_id: found.parent_task_id !== null && task.has(found.parent_task_id) ? found.parent_task_id : null,
+          exec_order: found.exec_order,
+          space_id: found.space_id,
+          spec_doc_id: exportedDoc(found.spec_doc_id),
+          external_refs: found.external_refs
+        }
+      };
+    }
+    for (const owner of projects) {
+      const decisions = await this.kb.decisions(owner.id);
+      for (const found of decisions.sort((a, b) => a.created_at - b.created_at)) {
+        decision.add(found.id);
+        this.exported.count("decision");
+        yield {
+          record: {
+            kind: "decision",
+            id: found.id,
+            project_id: found.project_id,
+            title: found.title,
+            rationale: found.rationale,
+            status: found.status
+          }
+        };
+      }
+    }
+  }
+  project(found, specDocId) {
+    return {
+      kind: "project",
+      id: found.id,
+      name: found.name,
+      slug: found.slug,
+      description: found.description,
+      status: found.status,
+      spec_doc_id: specDocId,
+      space_id: found.space_id,
+      icon: found.icon,
+      color: found.color
+    };
+  }
+}
+function parentsFirst(tasks) {
+  const byId = new Map(tasks.map((task) => [task.id, task]));
+  const ordered = [];
+  const placed = new Set;
+  const place = (task) => {
+    if (placed.has(task.id))
+      return;
+    placed.add(task.id);
+    const parent = task.parent_task_id === null ? undefined : byId.get(task.parent_task_id);
+    if (parent !== undefined)
+      place(parent);
+    ordered.push(task);
+  };
+  for (const task of tasks)
+    place(task);
+  return ordered;
+}
+
+// src/backup/export/exporter.ts
+class Exporter {
+  from;
+  request;
+  progress;
+  exported = new Exported;
+  roots;
+  constructor(from, request, progress) {
+    this.from = from;
+    this.request = request;
+    this.progress = progress;
+    this.roots = new SealedRoots(from.sealed, from.services);
+  }
+  async prepare() {
+    const { kb } = this.from;
+    const plan = await new ExportPlanner(kb).plan(this.request.selection);
+    const credentials = await this.credentialsOf(plan);
+    await this.includeSpaces(plan, credentials.map((credential2) => credential2.space_id));
+    const sealRoots = new Map;
+    for (const credential2 of credentials) {
+      if (!credential2.sealed)
+        continue;
+      const sealed = await this.from.sealed.api.fetchSealedCredential(credential2.id);
+      sealRoots.set(credential2.id, sealed.seal_root_id);
+    }
+    await this.includeRoots(plan, new Set(sealRoots.values()));
+    const needed = new Set(sealRoots.values());
+    for (const node of plan.nodes) {
+      if (node.sealRootId !== null)
+        needed.add(node.sealRootId);
+    }
+    await this.roots.unlock(needed, this.request.skipLocked);
+    return { plan, credentials, sealRoots };
+  }
+  async* entries(prepared) {
+    const { kb, sealed, services } = this.from;
+    const { plan } = prepared;
+    yield { record: this.manifest() };
+    for (const space of plan.spaces) {
+      this.exported.count("space");
+      yield { record: spaceRecord(space) };
+    }
+    this.progress(`Documents and folders: ${plan.nodes.length}`);
+    const nodes = new NodeExporter({
+      kb,
+      sealed,
+      services,
+      access: new NodeAccess(sealed),
+      roots: this.roots
+    }, this.exported);
+    for (const node of plan.nodes)
+      yield* nodes.entries(node);
+    this.progress(`Credentials: ${prepared.credentials.length}`);
+    yield* new CredentialExporter(kb, new CredentialAccess(sealed), this.roots, this.exported).entries(prepared.credentials, prepared.sealRoots);
+    this.progress("Projects, tasks and decisions");
+    yield* new WorkExporter(kb, this.exported).entries(plan);
+    this.progress("Canvas blocks and database rows");
+    const content = new ContentExporter(kb, this.exported);
+    yield* content.blocks();
+    yield* content.rows();
+    yield* content.attachmentRows();
+    yield* content.views();
+    this.progress("Links");
+    yield* new LinkExporter(kb, this.exported).entries();
+    yield { record: await this.end() };
+  }
+  get written() {
+    return this.exported;
+  }
+  manifest() {
+    return {
+      kind: "manifest",
+      format: RECORD_FORMAT,
+      created_at: new Date().toISOString(),
+      client_version: this.request.clientVersion,
+      source: this.request.source,
+      selection: this.request.selection
+    };
+  }
+  async end() {
+    const locked = [];
+    for (const rootId of this.roots.lockedIds()) {
+      locked.push(await this.from.sealed.names.describe(rootId));
+    }
+    if (locked.length > 0) {
+      this.exported.leftOut.push(`everything of ${locked.length} seal root(s) that could not be opened: ${locked.join(", ")}`);
+    }
+    return {
+      kind: "end",
+      counts: { ...this.exported.counts },
+      left_out: [...this.exported.leftOut]
+    };
+  }
+  async credentialsOf(plan) {
+    const folders = new Set(plan.nodes.map((node) => node.id));
+    const chosen = [];
+    for await (const credential2 of this.from.kb.credentials()) {
+      const filed = credential2.folder_id !== null && folders.has(credential2.folder_id);
+      if (plan.wholeSpaceIds.has(credential2.space_id) || filed) {
+        chosen.push(credential2);
+      }
+    }
+    return chosen;
+  }
+  async includeRoots(plan, rootIds) {
+    const planned = new Set(plan.nodes.map((node) => node.id));
+    const extra = [];
+    const spaceIds = [];
+    for (const rootId of rootIds) {
+      if (planned.has(rootId))
+        continue;
+      extra.push({ id: rootId, parentId: null, sealRootId: rootId });
+      spaceIds.push((await this.from.kb.document(rootId)).space_id);
+    }
+    plan.nodes.unshift(...extra);
+    await this.includeSpaces(plan, spaceIds);
+  }
+  async includeSpaces(plan, spaceIds) {
+    const missing = spaceIds.filter((id) => !plan.spaces.some((space) => space.id === id));
+    if (missing.length === 0)
+      return;
+    for (const space of await this.from.kb.spaces()) {
+      if (missing.includes(space.id))
+        plan.spaces.push(space);
+    }
+  }
+}
+function spaceRecord(space) {
+  return {
+    kind: "space",
+    id: space.id,
+    name: space.name,
+    icon: space.icon,
+    color: space.color,
+    description: space.description,
+    access_mode: space.access_mode,
+    workflow_states: space.workflow_states,
+    allow_client_uploads: space.allow_client_uploads,
+    encryption_policy: space.encryption_policy
+  };
+}
+
+// src/claudeCode.ts
+import { spawn as spawn2 } from "node:child_process";
+import { basename as basename2 } from "node:path";
+var SERVER_NAME = "safekb";
+var PACKAGE_NAME = "@safekb/mcp";
+var BIN_NAME = "safekb-mcp";
+var SERVE_FLAG = "--mcp";
+var PACKAGE_COMMAND = ["npx", "-y", PACKAGE_NAME, SERVE_FLAG];
+var SCOPES = ["user", "local", "project"];
+function quotedForCmd(arg) {
+  return /[\s"&|<>^]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg;
+}
+var runProgram = (program, args) => new Promise((resolve, reject) => {
+  const windows = process.platform === "win32";
+  const child = spawn2(program, windows ? args.map(quotedForCmd) : args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: windows
+  });
+  let output = "";
+  child.stdout.on("data", (chunk) => {
+    output += chunk;
+  });
+  child.stderr.on("data", (chunk) => {
+    output += chunk;
+  });
+  child.on("error", (error) => {
+    if (error.code === "ENOENT")
+      resolve({ code: null, output: "" });
+    else
+      reject(error);
+  });
+  child.on("close", (code) => resolve({ code: code ?? 1, output }));
+});
+function addCommand(serverArgs) {
+  return [
+    "mcp",
+    "add",
+    "--scope",
+    "user",
+    SERVER_NAME,
+    "--",
+    ...PACKAGE_COMMAND,
+    ...serverArgs
+  ];
+}
+var REMOTE_TYPES = ["http", "sse"];
+var ENVIRONMENT = /^([ \t]*)Environment:[ \t]*\n((?:\1[ \t]+\S.*(?:\n|$))*)/m;
+var SERVE_FLAG_SINCE = [0, 5, 0];
+var EXACT_VERSION = /^(\d+)\.(\d+)\.(\d+)$/;
+function field(description, name) {
+  return (new RegExp(`^\\s*${name}:(.*)$`, "m").exec(description)?.[1] ?? "").trim();
+}
+function registrationOf(output) {
+  const description = output.replace(/\r\n?/g, `
+`);
+  if (REMOTE_TYPES.includes(field(description, "Type")))
+    return null;
+  const command = field(description, "Command");
+  if (command.length === 0) {
+    throw new StartupError(`Claude Code has an MCP server "${SERVER_NAME}", but what it starts could not be read from "claude mcp get ${SERVER_NAME}", so it is not known whether it starts this client with ${SERVE_FLAG}. Nothing was changed.`);
+  }
+  const scope = field(description, "Scope").split(" ")[0]?.toLowerCase();
+  return {
+    scope: SCOPES.find((name) => name === scope) ?? null,
+    command,
+    args: field(description, "Args"),
+    environment: (ENVIRONMENT.exec(description)?.[2] ?? "").split(`
+`).map((line) => line.trim().split("=")[0] ?? "").filter((name) => name.length > 0),
+    timeout: field(description, "Timeout")
+  };
+}
+function words(registration) {
+  return [registration.command, ...registration.args.split(/\s+/)];
+}
+function startsThisClient(registration) {
+  return words(registration).some((word) => word === PACKAGE_NAME || word.startsWith(`${PACKAGE_NAME}@`) || [BIN_NAME, `${BIN_NAME}.js`].includes(basename2(word)));
+}
+function pinnedBeforeServeFlag(registration) {
+  for (const word of words(registration)) {
+    if (!word.startsWith(`${PACKAGE_NAME}@`))
+      continue;
+    const version = word.slice(PACKAGE_NAME.length + 1);
+    const numbers = EXACT_VERSION.exec(version)?.slice(1).map(Number);
+    if (numbers === undefined)
+      return null;
+    const differing = numbers.findIndex((number, index) => number !== SERVE_FLAG_SINCE[index]);
+    return differing !== -1 && numbers[differing] < SERVE_FLAG_SINCE[differing] ? version : null;
+  }
+  return null;
+}
+function lacksServeFlag(registration) {
+  return startsThisClient(registration) && !words(registration).includes(SERVE_FLAG);
+}
+function writtenBySetup(registration) {
+  const { scope, command, args, environment, timeout } = registration;
+  if (scope !== "user" || command !== "npx" || environment.length > 0 || timeout.length > 0) {
+    return null;
+  }
+  const own = `-y ${PACKAGE_NAME}`;
+  if (args === own)
+    return [];
+  const config = `${own} --config `;
+  if (!args.startsWith(config))
+    return null;
+  const path = args.slice(config.length);
+  return /\s-/.test(path) ? null : ["--config", path];
+}
+function quotedForSh(word) {
+  return /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replace(/'/g, "'\\''")}'`;
+}
+function typed(command) {
+  return command.map(process.platform === "win32" ? quotedForCmd : quotedForSh).join(" ");
+}
+function howToAddServeFlag(registration) {
   const { scope, command, args, environment, timeout } = registration;
   if (scope === null) {
     throw new StartupError(`Claude Code has the MCP server "${SERVER_NAME}" without ${SERVE_FLAG}, which this version needs to start, and did not say where it is registered. Run "claude mcp get ${SERVER_NAME}" and add ${SERVE_FLAG} to its arguments.`);
@@ -6485,7 +9147,7 @@ __export(exports_external, {
   undefined: () => _undefined3,
   ulid: () => ulid2,
   uint64: () => uint64,
-  uint32: () => uint32,
+  uint32: () => uint322,
   tuple: () => tuple,
   trim: () => _trim,
   treeifyError: () => treeifyError,
@@ -6600,7 +9262,7 @@ __export(exports_external, {
   email: () => email2,
   e164: () => e1642,
   discriminatedUnion: () => discriminatedUnion,
-  describe: () => describe2,
+  describe: () => describe3,
   decodeAsync: () => decodeAsync2,
   decode: () => decode2,
   date: () => date3,
@@ -6742,7 +9404,7 @@ __export(exports_core2, {
   extractDefs: () => extractDefs,
   encodeAsync: () => encodeAsync,
   encode: () => encode,
-  describe: () => describe,
+  describe: () => describe2,
   decodeAsync: () => decodeAsync,
   decode: () => decode,
   createToJSONSchemaMethod: () => createToJSONSchemaMethod,
@@ -17079,7 +19741,7 @@ function _check(fn, params) {
   ch._zod.check = fn;
   return ch;
 }
-function describe(description) {
+function describe2(description) {
   const ch = new $ZodCheck({ check: "describe" });
   ch._zod.onattach = [
     (inst) => {
@@ -18134,7 +20796,7 @@ __export(exports_schemas2, {
   undefined: () => _undefined3,
   ulid: () => ulid2,
   uint64: () => uint64,
-  uint32: () => uint32,
+  uint32: () => uint322,
   tuple: () => tuple,
   transform: () => transform,
   templateLiteral: () => templateLiteral,
@@ -18198,7 +20860,7 @@ __export(exports_schemas2, {
   email: () => email2,
   e164: () => e1642,
   discriminatedUnion: () => discriminatedUnion,
-  describe: () => describe2,
+  describe: () => describe3,
   date: () => date3,
   custom: () => custom,
   cuid2: () => cuid22,
@@ -18779,7 +21441,7 @@ function float64(params) {
 function int32(params) {
   return _int32(ZodNumberFormat, params);
 }
-function uint32(params) {
+function uint322(params) {
   return _uint32(ZodNumberFormat, params);
 }
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
@@ -19449,7 +22111,7 @@ function refine(fn, _params = {}) {
 function superRefine(fn) {
   return _superRefine(fn);
 }
-var describe2 = describe;
+var describe3 = describe2;
 var meta2 = meta;
 function _instanceof(cls, params = {}) {
   const inst = new ZodCustom({
@@ -20277,7 +22939,7 @@ class HostedProxy {
 }
 
 // src/keyring.ts
-import { readdir, stat as stat2 } from "node:fs/promises";
+import { readdir, stat as stat3 } from "node:fs/promises";
 import { join as join4 } from "node:path";
 var KEY_FILE_SUFFIX = ".json";
 async function readEntry(path) {
@@ -20306,7 +22968,7 @@ class Keyring {
     this.dir = dir;
   }
   async load() {
-    const info = await stat2(this.dir).catch(() => null);
+    const info = await stat3(this.dir).catch(() => null);
     if (info === null || !info.isDirectory()) {
       throw new ClientError(`Keyring ${this.dir} is not a directory`);
     }
@@ -20350,17 +23012,6 @@ class Keyring {
   }
 }
 
-// src/stores/secretStore.ts
-var KEY_STORE_NAMES = ["system", "file"];
-var KEY_STORE_LABELS = {
-  system: "the system keyring",
-  file: "the key file directory"
-};
-var STORE_NAMES = [...KEY_STORE_NAMES, "sidecar"];
-function passphraseNote(seal2) {
-  return `seal root ${seal2.rootId} is opened by a passphrase, which only the sidecar can hold`;
-}
-
 // src/stores/secretStores.ts
 var HOW_TO_ENABLE = {
   system: "The system keyring is not set up for this client; run: safekb-mcp --configure",
@@ -20760,6 +23411,9 @@ Usage:
   safekb-mcp --rotate-key <name or id> [--store system|file]
   safekb-mcp --move-key <name or id> --store system|file
   safekb-mcp --delete-key <name or id>
+  safekb-mcp --export <file> [--space <space id>]... [--doc <document id>]... [--compress]
+                     [--skip-locked]
+  safekb-mcp --import <file> [--into-space <space id>] [--store system|file]
 
 Without arguments this text is printed.
 
@@ -20806,9 +23460,29 @@ Options:
                      its name. The root on the server is not touched. Shows the keys first, warns
                      unless the server says they are superseded, and asks you to type the root's
                      name or id. Needs a terminal.
-  --space <space id>  With --create-key: the space of the new seal root.
+  --export <file>    Write what this token reaches to a new file, encrypted under a passphrase you
+                     type: spaces, folders, documents, attachments, databases, credentials,
+                     projects, tasks, decisions and links. Sealed content and credential secrets
+                     are decrypted on this machine and are in the file, so every seal root in
+                     the selection must be openable with a secret this machine keeps or its
+                     sidecar holds. Without --space and --doc everything is exported. Needs a
+                     terminal.
+  --import <file>    Create what such a file holds, as new things with new ids, in the account
+                     of this token: nothing that exists is changed. Each exported space becomes
+                     a new space, each seal root a new seal root with a newly generated key.
+                     Needs a terminal.
+  --space <space id>  With --create-key: the space of the new seal root. With --export: export
+                     this space with everything in it; may be repeated.
+  --doc <document id>  With --export: export this document, or this folder with everything in
+                     it; may be repeated, and combined with --space.
+  --compress         With --export: compress (gzip) before encrypting.
+  --skip-locked      With --export: leave out what belongs to a seal root that cannot be opened,
+                     instead of stopping.
+  --into-space <space id>  With --import: put everything into this one existing space instead of
+                     creating the exported spaces again.
   --name <new name>  With --rename-key: the new name.
-  --store system|file  With --create-key, --rotate-key and --move-key: the key store.
+  --store system|file  With --create-key, --rotate-key and --move-key: the key store. With
+                     --import: where the keys of the new seal roots are kept.
   --sidecar-socket <path>  The sidecar's socket. Also: SAFEKB_SIDECAR_SOCKET. Default: sidecar.sock
                      next to the token file.
   --version, --help
@@ -20829,6 +23503,11 @@ Environment:
 function nonEmpty(value) {
   return value === undefined || value.length === 0 ? null : value;
 }
+function several(value) {
+  if (value === undefined || typeof value === "boolean")
+    return [];
+  return typeof value === "string" ? [value] : value;
+}
 function trimTrailingSlashes(url2) {
   return url2.replace(/\/+$/, "");
 }
@@ -20854,7 +23533,9 @@ var EXCLUSIVE_MODES = [
   "rename-key",
   "rotate-key",
   "move-key",
-  "delete-key"
+  "delete-key",
+  "export",
+  "import"
 ];
 var TAKEN_BY_EVERY_MODE = ["config"];
 var KEY_MODE_MODIFIERS = ["url", "keyring"];
@@ -20871,7 +23552,16 @@ var MODIFIERS = {
   "rename-key": [...KEY_MODE_MODIFIERS, "name"],
   "rotate-key": [...KEY_MODE_MODIFIERS, "store"],
   "move-key": [...KEY_MODE_MODIFIERS, "store"],
-  "delete-key": KEY_MODE_MODIFIERS
+  "delete-key": KEY_MODE_MODIFIERS,
+  export: [
+    ...KEY_MODE_MODIFIERS,
+    "sidecar-socket",
+    "space",
+    "doc",
+    "compress",
+    "skip-locked"
+  ],
+  import: [...KEY_MODE_MODIFIERS, "into-space", "store"]
 };
 var A_SEAL_ROOT = "the name or the id of a seal root";
 var MODE_VALUES = {
@@ -20881,7 +23571,9 @@ var MODE_VALUES = {
   "rename-key": A_SEAL_ROOT,
   "rotate-key": A_SEAL_ROOT,
   "move-key": A_SEAL_ROOT,
-  "delete-key": A_SEAL_ROOT
+  "delete-key": A_SEAL_ROOT,
+  export: "the path of the export file",
+  import: "the path of the export file"
 };
 var REQUIRED_MODIFIERS = {
   "create-key": { flag: "space", usage: "--space <space id>" },
@@ -20898,10 +23590,13 @@ function assertFitting(chosen, flags) {
     throw new StartupError(`--${chosen} needs ${value}`);
   }
   const required2 = REQUIRED_MODIFIERS[chosen];
-  if (required2 !== undefined && nonEmpty(flags[required2.flag]) === null) {
+  if (required2 !== undefined && several(flags[required2.flag]).every((value2) => value2 === "")) {
     throw new StartupError(`--${chosen} needs ${required2.usage}`);
   }
-  const empty = Object.entries(flags).filter(([, given]) => given === "").map(([name]) => name);
+  if (chosen === "create-key" && several(flags.space).length > 1) {
+    throw new StartupError("--create-key takes one --space");
+  }
+  const empty = Object.entries(flags).filter(([, given]) => several(given).includes("")).map(([name]) => name);
   if (empty.length > 0) {
     throw new StartupError(`${flagList(empty)} was passed without a value`);
   }
@@ -20965,7 +23660,13 @@ ${USAGE}`);
     transferFile: nonEmpty(values["export-keys"]) ?? nonEmpty(values["import-keys"]),
     rootRef: ROOT_REF_MODES.map((name) => nonEmpty(values[name])).find((value) => value !== null) ?? null,
     newName: nonEmpty(values["create-key"]) ?? nonEmpty(values.name),
-    spaceId: nonEmpty(values.space),
+    spaceId: several(values.space)[0] ?? null,
+    backupFile: nonEmpty(values.export) ?? nonEmpty(values.import),
+    exportSpaceIds: several(values.space),
+    exportDocumentIds: several(values.doc),
+    compress: values.compress === true,
+    skipLocked: values["skip-locked"] === true,
+    intoSpaceId: nonEmpty(values["into-space"]),
     store: keyStoreOf(values.store),
     confirm: values.confirm === true,
     sealedOnly: values["sealed-only"] === true,
@@ -20999,7 +23700,13 @@ function parse5(argv) {
       "rotate-key": { type: "string" },
       "move-key": { type: "string" },
       "delete-key": { type: "string" },
-      space: { type: "string" },
+      space: { type: "string", multiple: true },
+      doc: { type: "string", multiple: true },
+      export: { type: "string" },
+      import: { type: "string" },
+      compress: { type: "boolean" },
+      "skip-locked": { type: "boolean" },
+      "into-space": { type: "string" },
       name: { type: "string" },
       store: { type: "string" },
       help: { type: "boolean" },
@@ -21009,18 +23716,18 @@ function parse5(argv) {
 }
 
 // src/rootNames.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { dirname as dirname3, join as join5 } from "node:path";
 var ROOT_NAMES_FILE = "roots.json";
 var ROOT_NAMES_VERSION = 1;
-var OBJECT_ID = /^[0-9a-f]{24}$/;
+var OBJECT_ID3 = /^[0-9a-f]{24}$/;
 function rootNamesPath(tokenConfigPath) {
   return join5(dirname3(tokenConfigPath), ROOT_NAMES_FILE);
 }
 function assertNames(value, path) {
   const raw = value;
   const names = raw?.names;
-  if (raw?.v !== ROOT_NAMES_VERSION || typeof names !== "object" || names === null || Array.isArray(names) || !Object.entries(names).every(([id, name]) => OBJECT_ID.test(id) && typeof name === "string" && name.length > 0)) {
+  if (raw?.v !== ROOT_NAMES_VERSION || typeof names !== "object" || names === null || Array.isArray(names) || !Object.entries(names).every(([id, name]) => OBJECT_ID3.test(id) && typeof name === "string" && name.length > 0)) {
     throw new ClientError(`Seal root names ${path} are malformed`);
   }
   return new Map(Object.entries(names));
@@ -21033,7 +23740,7 @@ class RootNames {
     this.path = path;
   }
   async all() {
-    if (!existsSync2(this.path))
+    if (!existsSync3(this.path))
       return new Map;
     const text = await readPrivateFile(this.path, "Seal root names");
     let parsed;
@@ -21052,7 +23759,7 @@ class RootNames {
     return name === null ? rootId : `"${name}" (${rootId})`;
   }
   remember(rootId, name) {
-    if (name.length === 0 || OBJECT_ID.test(name))
+    if (name.length === 0 || OBJECT_ID3.test(name))
       return this.forget(rootId);
     return this.change(async () => {
       const names = await this.all();
@@ -21078,108 +23785,64 @@ class RootNames {
     return followUp(done, "its name could not be updated on this machine", change);
   }
   async assertUsable(name, rootId) {
-    if (OBJECT_ID.test(name)) {
+    if (OBJECT_ID3.test(name)) {
       throw new ClientError(`"${name}" has the shape of an id, so it cannot be the name of a seal root`);
     }
     for (const [id, taken] of await this.all()) {
       if (taken === name && id !== rootId) {
         throw new ClientError(`Seal root ${id} is already named "${name}" on this machine; choose another name`);
       }
-    }
-  }
-  async isName(reference) {
-    return [...(await this.all()).values()].includes(reference);
-  }
-  async resolve(reference) {
-    if (OBJECT_ID.test(reference))
-      return reference;
-    const ids = [...await this.all()].filter(([, name]) => name === reference).map(([id]) => id);
-    const [first, ...others] = ids;
-    if (first === undefined) {
-      throw new ClientError(`No seal root is known as "${reference}"; use its id`);
-    }
-    if (others.length > 0) {
-      throw new ClientError(`${ids.length} seal roots are named "${reference}" (${ids.join(", ")}); use the id`);
-    }
-    return first;
-  }
-  save(names) {
-    const sorted = Object.fromEntries([...names].sort(([a], [b]) => a.localeCompare(b)));
-    return writePrivateFile(this.path, `${JSON.stringify({ v: ROOT_NAMES_VERSION, names: sorted }, null, 2)}
-`);
-  }
-}
-
-// src/sealed/attachmentService.ts
-import { createReadStream } from "node:fs";
-import { open as open3, stat as stat3, unlink } from "node:fs/promises";
-import { basename as basename3 } from "node:path";
-
-// src/sealed/nodeAccess.ts
-function assertSeq(node, expectedSeq2) {
-  if (node.seal_seq !== expectedSeq2) {
-    throw new ClientError(`${node.id} changed: its seal_seq is ${node.seal_seq}, not ${expectedSeq2}. Read it again before writing.`);
-  }
-}
-function assertAccepted(node) {
-  if (node.deposited) {
-    throw new ClientError(`${node.id} is a pending deposit; accept_sealed_deposit or reject_sealed_deposit it first`);
-  }
-}
-function writeResult(node) {
-  return {
-    id: node.id,
-    seal_root_id: node.seal_root_id,
-    seal_seq: node.seal_seq
-  };
-}
-
-class NodeAccess {
-  ctx;
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  nodeContext(nodeId) {
-    return { tenant: this.ctx.tenant, node: nodeId };
-  }
-  async dekOf(node) {
-    const { keys } = this.ctx.session.require(node.seal_root_id);
-    if (node.enc_dek !== null) {
-      return unwrapDek(keys, node.id, parseEnvelope(node.enc_dek));
-    }
-    if (node.box_dek !== null) {
-      return openBoxDek(keys, node.id, parseBoxDek(node.box_dek));
-    }
-    throw new ClientError(`Sealed node ${node.id} has no wrapped key`);
-  }
-  async open(nodeId) {
-    return this.openNode(await this.ctx.api.getNode(nodeId));
+    }
   }
-  async openNode(node) {
-    const root = this.ctx.session.require(node.seal_root_id);
-    const dek = await this.dekOf(node);
-    const meta3 = await decryptMeta(dek, this.nodeContext(node.id), parseEnvelope(node.enc_meta));
-    return { node, root, dek, meta: meta3 };
+  async isName(reference) {
+    return [...(await this.all()).values()].includes(reference);
   }
-  async sign(message, signerRootIds) {
-    const signers = signerRootIds.map((rootId) => this.ctx.session.require(rootId).keys);
-    return signMessage(await buildMessage(message), signers);
+  async resolve(reference) {
+    if (OBJECT_ID3.test(reference))
+      return reference;
+    const ids = [...await this.all()].filter(([, name]) => name === reference).map(([id]) => id);
+    const [first, ...others] = ids;
+    if (first === undefined) {
+      throw new ClientError(`No seal root is known as "${reference}"; use its id`);
+    }
+    if (others.length > 0) {
+      throw new ClientError(`${ids.length} seal roots are named "${reference}" (${ids.join(", ")}); use the id`);
+    }
+    return first;
   }
-  async signPlain(op, node) {
-    const sigs = await this.sign({
-      op,
-      tenant: this.ctx.tenant,
-      node: node.id,
-      root: node.seal_root_id,
-      baseSeq: node.seal_seq
-    }, [node.seal_root_id]);
-    return { base_seq: node.seal_seq, sigs };
+  save(names) {
+    const sorted = Object.fromEntries([...names].sort(([a], [b]) => a.localeCompare(b)));
+    return writePrivateFile(this.path, `${JSON.stringify({ v: ROOT_NAMES_VERSION, names: sorted }, null, 2)}
+`);
   }
 }
 
 // src/sealed/attachmentService.ts
+import { createReadStream as createReadStream2 } from "node:fs";
+import { open as open4, stat as stat4, unlink } from "node:fs/promises";
+import { basename as basename3 } from "node:path";
 var DOWNLOAD_FILE_MODE = 384;
 var DEFAULT_MIME_TYPE = "application/octet-stream";
+async function* fileBytes(path) {
+  try {
+    for await (const chunk of createReadStream2(path))
+      yield chunk;
+  } catch (error48) {
+    throw fileError(error48);
+  }
+}
+async function* verified(plaintext, meta3) {
+  const hash2 = await createStreamingSha256();
+  let size = 0;
+  for await (const chunk of plaintext) {
+    hash2.update(chunk);
+    size += chunk.length;
+    yield chunk;
+  }
+  if (size !== meta3.size || hash2.digestHex() !== meta3.sha256_plain) {
+    throw new ClientError("Downloaded attachment does not match its sealed size and hash");
+  }
+}
 
 class AttachmentService {
   ctx;
@@ -21208,11 +23871,32 @@ class AttachmentService {
   }
   async upload(args) {
     const opened = await this.access.open(args.document_id);
+    assertSeq(opened.node, args.expected_seq);
+    assertAccepted(opened.node);
+    const info = await stat4(args.file_path).catch((error48) => {
+      throw fileError(error48);
+    });
+    if (!info.isFile()) {
+      throw new ClientError(`${args.file_path} is not a regular file; only regular files can be attached`);
+    }
+    await this.assertWithinLimit(args.file_path, info.size);
+    return this.attachTo(opened, {
+      filename: basename3(args.file_path),
+      mime: args.mime_type,
+      bytes: fileBytes(args.file_path)
+    });
+  }
+  async attach(args) {
+    const opened = await this.access.open(args.document_id);
+    assertSeq(opened.node, args.expected_seq);
+    assertAccepted(opened.node);
+    await this.assertWithinLimit(`'${args.file.filename}'`, args.size);
+    return this.attachTo(opened, args.file);
+  }
+  async attachTo(opened, plain) {
     const { node, dek } = opened;
-    assertSeq(node, args.expected_seq);
-    assertAccepted(node);
     const ctx = this.attachmentContext(node.id, newObjectId());
-    const file2 = await this.encryptFile(dek, ctx, args.file_path, args.mime_type);
+    const file2 = await this.encrypt(dek, ctx, plain);
     const attEncMeta = serializeEnvelope(await encryptAttachmentMeta(dek, ctx, file2.meta));
     const sigs = await this.access.sign({
       op: "attach",
@@ -21239,6 +23923,23 @@ class AttachmentService {
       size: file2.meta.size
     };
   }
+  async files(documentId) {
+    const opened = await this.access.open(documentId);
+    const files = [];
+    for (const record2 of await this.ctx.api.listAttachments(documentId)) {
+      const meta3 = await this.metaOf(opened, record2);
+      files.push({
+        id: record2.id,
+        meta: meta3,
+        bytes: () => this.plaintextOf(opened, record2.id, meta3)
+      });
+    }
+    return files;
+  }
+  async* plaintextOf(opened, attachmentId, meta3) {
+    const ciphertext = await this.ctx.api.downloadAttachment(opened.node.id, attachmentId);
+    yield* verified(decryptAttachment(opened.dek, this.attachmentContext(opened.node.id, attachmentId), ciphertext), meta3);
+  }
   async download(args) {
     const opened = await this.access.open(args.document_id);
     const record2 = (await this.ctx.api.listAttachments(args.document_id)).find((candidate) => candidate.id === args.attachment_id);
@@ -21246,9 +23947,7 @@ class AttachmentService {
       throw new ClientError(`${args.document_id} has no attachment ${args.attachment_id}`);
     }
     const meta3 = await this.metaOf(opened, record2);
-    const ciphertext = await this.ctx.api.downloadAttachment(args.document_id, args.attachment_id);
-    const plaintext = decryptAttachment(opened.dek, this.attachmentContext(args.document_id, args.attachment_id), ciphertext);
-    await this.writeVerified(args.out_path, plaintext, meta3);
+    await this.write(args.out_path, this.plaintextOf(opened, args.attachment_id, meta3));
     return {
       attachment_id: args.attachment_id,
       out_path: args.out_path,
@@ -21283,27 +23982,15 @@ class AttachmentService {
     }
     return decryptAttachmentMeta(opened.dek, this.attachmentContext(opened.node.id, record2.id), parseEnvelope(record2.att_enc_meta));
   }
-  async encryptFile(dek, ctx, path, mime) {
-    const info = await stat3(path).catch((error48) => {
-      throw fileError(error48);
-    });
-    if (!info.isFile()) {
-      throw new ClientError(`${path} is not a regular file; only regular files can be attached`);
-    }
-    await this.assertWithinLimit(path, info.size);
+  async encrypt(dek, ctx, file2) {
     const plainHash = await createStreamingSha256();
     const cipherHash = await createStreamingSha256();
     let size = 0;
     async function* plaintext() {
-      try {
-        for await (const chunk of createReadStream(path)) {
-          const bytes = chunk;
-          plainHash.update(bytes);
-          size += bytes.length;
-          yield bytes;
-        }
-      } catch (error48) {
-        throw fileError(error48);
+      for await (const bytes of file2.bytes) {
+        plainHash.update(bytes);
+        size += bytes.length;
+        yield bytes;
       }
     }
     const parts = [];
@@ -21315,49 +24002,41 @@ class AttachmentService {
       ciphertext: new Blob(parts),
       blobSha256: cipherHash.digestHex(),
       meta: {
-        filename: basename3(path),
-        mime,
+        filename: file2.filename,
+        mime: file2.mime,
         size,
         sha256_plain: plainHash.digestHex()
       }
     };
   }
-  async assertWithinLimit(path, size) {
+  async assertWithinLimit(what, size) {
     const { max_file_size_bytes: limit } = await this.ctx.api.limits();
     if (!Number.isSafeInteger(limit) || limit <= 0) {
       throw new ClientError("The server did not report a usable upload limit (max_file_size_bytes)");
     }
     const sealedSize = attachmentCiphertextSize(size);
     if (sealedSize > limit) {
-      throw new ClientError(`${path} is too large to attach: it is ${size} bytes, ${sealedSize} bytes once sealed, and the server accepts at most ${limit} bytes`);
+      throw new ClientError(`${what} is too large to attach: it is ${size} bytes, ${sealedSize} bytes once sealed, and the server accepts at most ${limit} bytes`);
     }
   }
-  async writeVerified(path, plaintext, meta3) {
+  async write(path, plaintext) {
     let handle;
     try {
-      handle = await open3(path, "wx", DOWNLOAD_FILE_MODE);
+      handle = await open4(path, "wx", DOWNLOAD_FILE_MODE);
     } catch (error48) {
       if (error48.code === "EEXIST") {
         throw new ClientError(`${path} already exists; choose a new out_path`);
       }
       throw fileError(error48);
     }
-    let verified = false;
+    let complete = false;
     try {
-      const hash2 = await createStreamingSha256();
-      let size = 0;
-      for await (const chunk of plaintext) {
-        hash2.update(chunk);
-        size += chunk.length;
+      for await (const chunk of plaintext)
         await handle.write(chunk);
-      }
-      if (size !== meta3.size || hash2.digestHex() !== meta3.sha256_plain) {
-        throw new ClientError("Downloaded attachment does not match its sealed size and hash");
-      }
-      verified = true;
+      complete = true;
     } finally {
       await handle.close();
-      if (!verified)
+      if (!complete)
         await unlink(path);
     }
   }
@@ -21469,7 +24148,7 @@ class NewSecrets {
   asks(args) {
     return [args.passphrase, args.key_out_path, args.store].some((value) => value !== undefined);
   }
-  async prepare(ctx, args, passphraseArg, label) {
+  async prepare(ctx, args, passphraseArg, label2) {
     const { passphrase, key_out_path: keyOutPath, store } = args;
     const given = [passphrase, keyOutPath, store].filter((value) => value !== undefined);
     if (given.length === 0)
@@ -21480,7 +24159,7 @@ class NewSecrets {
     if (passphrase !== undefined)
       return typedPassphrase(passphrase);
     if (store === "sidecar") {
-      return promptedPassphrase(await this.stores.sidecar().create(ctx.root, label));
+      return promptedPassphrase(await this.stores.sidecar().create(ctx.root, label2));
     }
     const file2 = await buildKeyFile(ctx, generateSecretKey());
     if (keyOutPath !== undefined)
@@ -21559,6 +24238,7 @@ class CreateService {
     return this.create({
       id,
       placement: await this.placement(args.space_id, args.parent_id),
+      position: args.position ?? NEW_NODE_POSITION,
       isFolder: false,
       title: args.title,
       dek,
@@ -21580,6 +24260,7 @@ class CreateService {
     return this.create({
       id,
       placement: await this.placement(args.space_id, args.parent_id),
+      position: args.position ?? NEW_NODE_POSITION,
       isFolder: true,
       title: args.name,
       dek,
@@ -21593,8 +24274,8 @@ class CreateService {
       await this.ctx.names.assertUsable(name, null);
     }
   }
-  newSecret(id, args, label) {
-    return this.newSecrets.prepare({ tenant: this.ctx.tenant, root: id }, args, "passphrase", label);
+  newSecret(id, args, label2) {
+    return this.newSecrets.prepare({ tenant: this.ctx.tenant, root: id }, args, "passphrase", label2);
   }
   async placement(spaceId, parentId) {
     if (parentId === undefined) {
@@ -21679,7 +24360,7 @@ class CreateService {
       space: spaceId,
       parent: parentId,
       isFolder: node.isFolder,
-      position: NEW_NODE_POSITION,
+      position: node.position,
       seal: seal2
     }, signerRootIds);
     return {
@@ -21687,7 +24368,7 @@ class CreateService {
       space_id: spaceId,
       parent_id: parentId,
       is_folder: node.isFolder,
-      position: NEW_NODE_POSITION,
+      position: node.position,
       seal_root_id: sealRootId,
       seal: seal2,
       enc_dek: encDek,
@@ -21699,68 +24380,6 @@ class CreateService {
   }
 }
 
-// src/sealed/credentialAccess.ts
-function visibleOf(credential2) {
-  return {
-    title: credential2.title,
-    username: credential2.username,
-    url: credential2.url,
-    tags: credential2.tags,
-    notes: credential2.notes,
-    custom: credential2.custom.flatMap(({ key, value }) => value === undefined ? [] : [{ key, value }])
-  };
-}
-function assertDistinctCustomKeys(visible, values) {
-  const keys = [...visible.custom, ...values.custom].map(({ key }) => key);
-  if (keys.some((key) => key.length === 0)) {
-    throw new ClientError("A custom field needs a key");
-  }
-  if (new Set(keys).size !== keys.length) {
-    throw new ClientError("Custom field keys must be unique");
-  }
-}
-
-class CredentialAccess {
-  ctx;
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  context(credentialId) {
-    return { tenant: this.ctx.tenant, credential: credentialId };
-  }
-  async newDek(rootId, credentialId) {
-    const { keys } = this.ctx.session.require(rootId);
-    const dek = generateDek();
-    return {
-      dek,
-      encDek: serializeEnvelope(await wrapDek(keys, credentialId, dek))
-    };
-  }
-  async rewrapDek(dek, rootId, credentialId) {
-    const { keys } = this.ctx.session.require(rootId);
-    return serializeEnvelope(await wrapDek(keys, credentialId, dek));
-  }
-  async open(credentialId) {
-    const credential2 = await this.ctx.api.fetchSealedCredential(credentialId);
-    const { keys } = this.ctx.session.require(credential2.seal_root_id);
-    const dek = await unwrapDek(keys, credentialId, parseEnvelope(credential2.enc_dek));
-    const values = await unsealCredentialFields(dek, this.context(credentialId), credential2.enc_fields);
-    return { credential: credential2, dek, values };
-  }
-  async seal(credentialId, dek, visible, values) {
-    assertDistinctCustomKeys(visible, values);
-    return {
-      visible,
-      encFields: await sealCredentialFields(dek, this.context(credentialId), values),
-      visibleDigest: await visibleFieldsDigest(visible)
-    };
-  }
-  async sign(message, signerRootIds) {
-    const signers = signerRootIds.map((rootId) => this.ctx.session.require(rootId).keys);
-    return signMessage(await buildCredentialMessage(message), signers);
-  }
-}
-
 // src/sealed/secretScan.ts
 var PEM_BLOCK = /-----BEGIN [A-Z0-9 ]+-----/;
 var SECRET_WORD = "pass(?:word|wd|phrase|code|wort)?|kennwort|geheim(?:nis)?|pwd|pin|puk|tan|secret|token|api[ _-]?key|access[ _-]?key|private[ _-]?key|client[ _-]?secret|bearer|recovery[ _-]?codes?|backup[ _-]?codes?|seed|cvv|cvc";
@@ -21840,7 +24459,7 @@ function scanForSecrets(text) {
 var NOTES = "notes";
 var NAMED_SECRETS = ["password", "totp", NOTES];
 var SCAN_DISCLAIMER = "notes_look_secret is an advisory pattern scan. It misses secrets (ordinary-word passphrases, other languages, anything it has no pattern for), so do not treat an unflagged note as safe.";
-var CONFLICT = 409;
+var CONFLICT2 = 409;
 async function hashOf(value) {
   return sha256Hex(utf8Encode(value));
 }
@@ -22063,8 +24682,8 @@ class CredentialMigration {
     }
   }
   async verify(rootId, credentialId, entry) {
-    const open4 = await this.withoutLeftoverHistory(rootId, await this.access.open(credentialId));
-    const { credential: credential2, values } = open4;
+    const open5 = await this.withoutLeftoverHistory(rootId, await this.access.open(credentialId));
+    const { credential: credential2, values } = open5;
     const visible = visibleOf(credential2);
     if (await visibleFieldsDigest(visible) !== credential2.visible_sig) {
       throw new ClientError("its visible fields no longer match the signed digest");
@@ -22081,10 +24700,10 @@ class CredentialMigration {
       throw new ClientError("its sealed values do not match the dry run");
     }
   }
-  async withoutLeftoverHistory(rootId, open4) {
-    const { credential: credential2 } = open4;
+  async withoutLeftoverHistory(rootId, open5) {
+    const { credential: credential2 } = open5;
     if (credential2.server_encrypted_history === 0)
-      return open4;
+      return open5;
     try {
       await this.ctx.api.sealCredential(credential2.id, {
         base_seq: credential2.version,
@@ -22095,7 +24714,7 @@ class CredentialMigration {
         sigs: {}
       });
     } catch (error48) {
-      if (!(error48 instanceof ApiError && error48.status === CONFLICT)) {
+      if (!(error48 instanceof ApiError && error48.status === CONFLICT2)) {
         throw error48;
       }
     }
@@ -22127,7 +24746,7 @@ class CredentialMigration {
 }
 
 // src/sealed/credentialService.ts
-var NOT_FOUND = 404;
+var NOT_FOUND2 = 404;
 var CUSTOM_PREFIX2 = customFieldName("");
 var VISIBLE_NAMES = [
   "title",
@@ -22176,28 +24795,28 @@ class CredentialService {
     this.access = access;
   }
   async reveal(credentialId, field2) {
-    const open4 = await this.access.open(credentialId);
-    const value = this.valueOf(open4, field2);
+    const open5 = await this.access.open(credentialId);
+    const value = this.valueOf(open5, field2);
     return {
       id: credentialId,
-      version: open4.credential.version,
+      version: open5.credential.version,
       field: field2,
       value,
-      ...await this.attestation(open4.credential)
+      ...await this.attestation(open5.credential)
     };
   }
   async totp(credentialId, nowMs = Date.now()) {
-    const open4 = await this.access.open(credentialId);
-    const code = await totp(parseTotp(this.valueOf(open4, "totp")), nowMs);
+    const open5 = await this.access.open(credentialId);
+    const code = await totp(parseTotp(this.valueOf(open5, "totp")), nowMs);
     return {
       id: credentialId,
       code: code.code,
       seconds_remaining: code.secondsRemaining,
-      ...await this.attestation(open4.credential)
+      ...await this.attestation(open5.credential)
     };
   }
-  valueOf(open4, field2) {
-    const { values, credential: credential2 } = open4;
+  valueOf(open5, field2) {
+    const { values, credential: credential2 } = open5;
     const value = field2.startsWith(CUSTOM_PREFIX2) ? values.custom.find((item) => item.key === field2.slice(CUSTOM_PREFIX2.length))?.value : SEALED_CREDENTIAL_FIELDS.includes(field2) ? values[field2] : undefined;
     if (value === undefined || value === null) {
       throw new ClientError(`Credential ${credential2.id} has no sealed field '${field2}'. Sealed fields: password, totp, sealed_notes, custom:{key}.`);
@@ -22221,7 +24840,7 @@ class CredentialService {
     try {
       attested = await this.ctx.api.lastAttestedVisibleFields(credential2.id);
     } catch (error48) {
-      if (error48 instanceof ApiError && error48.status === NOT_FOUND)
+      if (error48 instanceof ApiError && error48.status === NOT_FOUND2)
         return null;
       throw error48;
     }
@@ -22269,12 +24888,13 @@ class CredentialService {
       visible: save.visible,
       enc_fields: save.encFields,
       enc_dek: encDek,
-      sigs
+      sigs,
+      ...args.display
     }));
   }
   async update(args) {
-    const open4 = await this.access.open(args.credential_id);
-    const { credential: credential2, values, dek } = open4;
+    const open5 = await this.access.open(args.credential_id);
+    const { credential: credential2, values, dek } = open5;
     assertVersion(credential2, args.expected_version);
     const current = visibleOf(credential2);
     const attestation = await this.attestation(credential2);
@@ -22366,8 +24986,8 @@ var UNREADABLE = {
   keywords: [],
   summary_readable: false
 };
-async function readDepositedSummary(ctx, access, open4) {
-  const { node, dek, meta: meta3 } = open4;
+async function readDepositedSummary(ctx, access, open5) {
+  const { node, dek, meta: meta3 } = open5;
   const [stored] = await ctx.api.indexEntries(node.seal_root_id, [node.id]);
   if (stored === undefined)
     return UNREADABLE;
@@ -22445,14 +25065,14 @@ class DepositService {
     }
   }
   async accept(documentId) {
-    const open4 = await this.access.open(documentId);
-    const { node, meta: meta3 } = open4;
+    const open5 = await this.access.open(documentId);
+    const { node, meta: meta3 } = open5;
     if (!node.deposited || node.box_dek === null) {
       throw new ClientError(`${documentId} is not a pending deposit`);
     }
-    const { keys } = open4.root;
-    const { body } = await this.documents.storedBody(open4);
-    const deposited = await readDepositedSummary(this.ctx, this.access, open4);
+    const { keys } = open5.root;
+    const { body } = await this.documents.storedBody(open5);
+    const deposited = await readDepositedSummary(this.ctx, this.access, open5);
     const dek = generateDek();
     const fields2 = await sealDocument(dek, this.access.nodeContext(node.id), {
       title: meta3.title,
@@ -22529,12 +25149,12 @@ class DocumentService {
     this.access = access;
   }
   async read(documentId) {
-    const open4 = await this.access.open(documentId);
-    const { node, meta: meta3 } = open4;
+    const open5 = await this.access.open(documentId);
+    const { node, meta: meta3 } = open5;
     const deposit = node.deposited ? {
       pending: true,
       untrusted: UNTRUSTED_DEPOSIT_NOTICE,
-      ...await readDepositedSummary(this.ctx, this.access, open4)
+      ...await readDepositedSummary(this.ctx, this.access, open5)
     } : { pending: false };
     return {
       id: node.id,
@@ -22547,31 +25167,31 @@ class DocumentService {
       archived: node.archived,
       attachment_count: node.attachment_count,
       ...deposit,
-      body: await this.bodyOf(open4)
+      body: await this.bodyOf(open5)
     };
   }
   async toc(documentId) {
-    const open4 = await this.access.open(documentId);
+    const open5 = await this.access.open(documentId);
     return {
       id: documentId,
-      seal_seq: open4.node.seal_seq,
-      title: open4.meta.title,
-      ...open4.node.deposited ? { untrusted: UNTRUSTED_DEPOSIT_NOTICE } : {},
-      headings: parseMarkdown(await this.bodyOf(open4)).headings
+      seal_seq: open5.node.seal_seq,
+      title: open5.meta.title,
+      ...open5.node.deposited ? { untrusted: UNTRUSTED_DEPOSIT_NOTICE } : {},
+      headings: parseMarkdown(await this.bodyOf(open5)).headings
     };
   }
   async section(documentId, anchor) {
-    const open4 = await this.access.open(documentId);
+    const open5 = await this.access.open(documentId);
     return {
       id: documentId,
-      seal_seq: open4.node.seal_seq,
+      seal_seq: open5.node.seal_seq,
       anchor,
-      ...open4.node.deposited ? { untrusted: UNTRUSTED_DEPOSIT_NOTICE } : {},
-      content: extractSection(await this.bodyOf(open4), anchor)
+      ...open5.node.deposited ? { untrusted: UNTRUSTED_DEPOSIT_NOTICE } : {},
+      content: extractSection(await this.bodyOf(open5), anchor)
     };
   }
-  async storedBody(open4) {
-    const { node, dek } = open4;
+  async storedBody(open5) {
+    const { node, dek } = open5;
     if (node.is_folder) {
       throw new ClientError(`${node.id} is a sealed folder; it has no body`);
     }
@@ -22584,13 +25204,13 @@ class DocumentService {
       body: await decryptBody(dek, this.access.nodeContext(node.id), parseEnvelope(stored.body))
     };
   }
-  async bodyOf(open4) {
-    return (await this.storedBody(open4)).body;
+  async bodyOf(open5) {
+    return (await this.storedBody(open5)).body;
   }
   async update(args) {
-    const open4 = await this.access.open(args.document_id);
-    assertSeq(open4.node, args.expected_seq);
-    assertAccepted(open4.node);
+    const open5 = await this.access.open(args.document_id);
+    assertSeq(open5.node, args.expected_seq);
+    assertAccepted(open5.node);
     const { document_id: _id, expected_seq: _seq, ...changes } = args;
     if (Object.values(changes).every((value) => value === undefined)) {
       throw new ClientError("Nothing to update: pass at least one field");
@@ -22598,51 +25218,51 @@ class DocumentService {
     if (args.summary === undefined !== (args.summary_short === undefined)) {
       throw new ClientError("Pass summary and summary_short together");
     }
-    const { id } = open4.node;
+    const { id } = open5.node;
     const { title } = args;
-    const renamesRoot = title !== undefined && id === open4.node.seal_root_id;
-    if (renamesRoot && title !== open4.meta.title) {
+    const renamesRoot = title !== undefined && id === open5.node.seal_root_id;
+    if (renamesRoot && title !== open5.meta.title) {
       await this.ctx.names.assertUsable(title, id);
     }
-    const result = await (open4.node.is_folder ? this.updateFolder(open4, args) : this.updateDocument(open4, args));
+    const result = await (open5.node.is_folder ? this.updateFolder(open5, args) : this.updateDocument(open5, args));
     if (renamesRoot) {
       await this.ctx.names.follow(`Seal root ${id} was renamed`, () => this.ctx.names.remember(id, title));
     }
     return result;
   }
   async replace(args) {
-    const open4 = await this.access.open(args.document_id);
-    assertSeq(open4.node, args.expected_seq);
-    assertAccepted(open4.node);
-    const body = await this.bodyOf(open4);
+    const open5 = await this.access.open(args.document_id);
+    assertSeq(open5.node, args.expected_seq);
+    assertAccepted(open5.node);
+    const body = await this.bodyOf(open5);
     const occurrences = countOccurrences(body, args.old_text);
     if (occurrences !== 1) {
       throw new ClientError(`old_text must occur exactly once in the document; it occurs ${occurrences} times`);
     }
-    return this.updateDocument(open4, {
+    return this.updateDocument(open5, {
       body: body.replace(args.old_text, () => args.new_text)
     });
   }
-  async updateFolder(open4, changes) {
+  async updateFolder(open5, changes) {
     const { body, summary, keywords } = changes;
     if (body !== undefined || summary !== undefined || keywords !== undefined) {
       throw new ClientError("A sealed folder has only a title and tags");
     }
     const meta3 = {
-      ...open4.meta,
-      title: changes.title ?? open4.meta.title,
-      tags: changes.tags ?? open4.meta.tags
+      ...open5.meta,
+      title: changes.title ?? open5.meta.title,
+      tags: changes.tags ?? open5.meta.tags
     };
-    return this.sendUpdate(open4, {
+    return this.sendUpdate(open5, {
       encBody: null,
-      encMeta: await sealMeta(open4.dek, this.access.nodeContext(open4.node.id), meta3),
+      encMeta: await sealMeta(open5.dek, this.access.nodeContext(open5.node.id), meta3),
       encIndex: null
     });
   }
-  async updateDocument(open4, changes) {
-    const { node, dek, meta: meta3 } = open4;
+  async updateDocument(open5, changes) {
+    const { node, dek, meta: meta3 } = open5;
     const ctx = this.access.nodeContext(node.id);
-    const current = await this.indexEntryOf(open4);
+    const current = await this.indexEntryOf(open5);
     const content = {
       title: changes.title ?? meta3.title,
       tags: changes.tags ?? meta3.tags,
@@ -22659,7 +25279,7 @@ class DocumentService {
       summary_stale: content.summaryStale,
       keywords: content.keywords
     } : indexEntryOf({ ...content, body: changes.body });
-    return this.sendUpdate(open4, {
+    return this.sendUpdate(open5, {
       encBody: changes.body === undefined ? null : await sealBody(dek, ctx, changes.body),
       encMeta: await sealMeta(dek, ctx, {
         title: content.title,
@@ -22670,8 +25290,8 @@ class DocumentService {
       encIndex: await sealIndexEntry(dek, ctx, entry)
     });
   }
-  async indexEntryOf(open4) {
-    const { node, dek } = open4;
+  async indexEntryOf(open5) {
+    const { node, dek } = open5;
     const [stored] = await this.ctx.api.indexEntries(node.seal_root_id, [
       node.id
     ]);
@@ -22680,8 +25300,8 @@ class DocumentService {
     }
     return decryptIndexEntry(dek, this.access.nodeContext(node.id), parseEnvelope(stored.enc_index));
   }
-  async sendUpdate(open4, fields2) {
-    const { node } = open4;
+  async sendUpdate(open5, fields2) {
+    const { node } = open5;
     const sigs = await this.access.sign({
       op: "update",
       tenant: this.ctx.tenant,
@@ -23139,13 +25759,13 @@ class TreeService {
     }
   }
   async export(args) {
-    const open4 = await this.access.open(args.document_id);
-    const { node, meta: meta3 } = open4;
+    const open5 = await this.access.open(args.document_id);
+    const { node, meta: meta3 } = open5;
     assertAccepted(node);
     if (node.attachment_count > 0) {
       throw new ClientError(`${node.id} has ${node.attachment_count} sealed attachment(s), which an export would destroy. Download them and delete them from the document first.`);
     }
-    const { body } = await this.documents.storedBody(open4);
+    const { body } = await this.documents.storedBody(open5);
     const copy = await this.ctx.api.createPlainDocument({
       title: meta3.title,
       body,
@@ -23586,11 +26206,11 @@ class SidecarConsole {
   async run() {
     while (!await this.inTurn(() => this.commandTurn())) {}
   }
-  newSecret(rootId, label, signal) {
+  newSecret(rootId, label2, signal) {
     return this.inTurn(async () => {
       signal.throwIfAborted();
       this.reader.write(`
-The MCP client asks for a new passphrase for seal root ${rootId} ("${printable2(label)}").
+The MCP client asks for a new passphrase for seal root ${rootId} ("${printable2(label2)}").
 `);
       const secret2 = await this.readNewPassphrase(signal);
       if (secret2 === null)
@@ -23837,7 +26457,7 @@ class SecretHolder {
 import { chmod, lstat, rm as rm3 } from "node:fs/promises";
 import { connect as connect2, createServer } from "node:net";
 var SOCKET_MODE = 384;
-var OBJECT_ID2 = /^[0-9a-f]{24}$/;
+var OBJECT_ID4 = /^[0-9a-f]{24}$/;
 var MAX_REQUEST_BYTES = 4096;
 var CLIENT_GONE = "The client that asked is gone";
 var MAX_SOCKET_PATH_BYTES = 103;
@@ -23868,7 +26488,7 @@ async function clearSocketPath(socketPath) {
   await rm3(socketPath);
 }
 function requireRootId2(value) {
-  if (typeof value !== "string" || !OBJECT_ID2.test(value)) {
+  if (typeof value !== "string" || !OBJECT_ID4.test(value)) {
     throw new ClientError("root_id must be a 24-character id");
   }
   return value;
@@ -24004,8 +26624,8 @@ class SidecarServer {
     }
     return this.holder.secretsOf(rootId);
   }
-  async create(rootId, label, clientGone) {
-    const chosen = await this.prompter.newSecret(rootId, label, clientGone);
+  async create(rootId, label2, clientGone) {
+    const chosen = await this.prompter.newSecret(rootId, label2, clientGone);
     clientGone.throwIfAborted();
     if (chosen === null) {
       throw new ClientError(`The sidecar's user entered no new passphrase for seal root ${rootId}`);
@@ -24071,7 +26691,7 @@ async function runSidecar(settings, names) {
 import { mkdir as mkdir3 } from "node:fs/promises";
 
 // src/stores/storeConfig.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { dirname as dirname5, join as join7 } from "node:path";
 var STORE_CONFIG_NAME = "stores.json";
 var DEFAULT_KEY_DIR_NAME = "keys";
@@ -24097,7 +26717,7 @@ function assertStoreConfig(value, path) {
 }
 async function loadStoreConfig(tokenConfigPath) {
   const path = storeConfigPath(tokenConfigPath);
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return null;
   let text;
   try {
@@ -24126,7 +26746,7 @@ function keyFilesNotice(keyDir) {
 function defaultKeyFilesDir(config2) {
   return config2.default_store === "file" ? config2.key_dir : null;
 }
-function describe3(config2) {
+function describe4(config2) {
   return config2.default_store === "system" ? "system keyring" : `key file directory ${config2.key_dir}`;
 }
 async function choose(request, before) {
@@ -24149,7 +26769,7 @@ async function save(request, chosen) {
     await mkdir3(keyDir, { recursive: true, mode: PRIVATE_DIR_MODE3 });
   }
   await saveStoreConfig(request.configPath, chosen);
-  request.log(keyDir === null ? `New sealed keys will be kept in the ${describe3(chosen)}.` : keyFilesNotice(keyDir));
+  request.log(keyDir === null ? `New sealed keys will be kept in the ${describe4(chosen)}.` : keyFilesNotice(keyDir));
   request.log(`Store settings saved to ${storeConfigPath(request.configPath)}`);
   return chosen;
 }
@@ -24407,11 +27027,11 @@ class SidecarStore {
       note: `the sidecar holds no secret for seal root ${seal2.rootId} (enter it there with: add ${seal2.rootId})`
     };
   }
-  async create(rootId, label) {
+  async create(rootId, label2) {
     const { secret: secret2, entry_id } = await this.client.request({
       op: "new",
       root_id: rootId,
-      label
+      label: label2
     });
     return {
       value: secret2,
@@ -24757,28 +27377,72 @@ function createSealedTools(ctx) {
   ];
 }
 
+// src/transfer/console.ts
+class TransferConsole {
+  reader;
+  transfer;
+  names;
+  constructor(reader, transfer, names) {
+    this.reader = reader;
+    this.transfer = transfer;
+    this.names = names;
+  }
+  async export(path) {
+    await this.transfer.exportable();
+    const keys = await this.transfer.export(path, await readNewPassphrase(this.reader, "every key in the file"));
+    this.reader.write(`Exported ${keys.length} key(s) to ${path}:
+`);
+    await this.writeRoots(keys);
+    this.reader.write(`The file opens only with the passphrase you typed: keep both, and keep them apart.
+` + `A seal root that is opened by a passphrase has no key on this machine and is not in the file.
+`);
+  }
+  async import(path) {
+    const passphrase = await readPassphrase(this.reader);
+    const { imported, store, present } = await this.transfer.import(path, passphrase);
+    if (store !== null) {
+      this.reader.write(`Imported ${imported.length} key(s) into ${KEY_STORE_LABELS[store]}:
+`);
+      await this.writeRoots(imported);
+    }
+    if (present.length > 0) {
+      this.reader.write(`${present.length} key(s) were already on this machine and were left as they are:
+`);
+      await this.writeRoots(present);
+    }
+  }
+  async writeRoots(keys) {
+    for (const { root_id } of keys) {
+      this.reader.write(`  ${printable2(await this.names.describe(root_id))}
+`);
+    }
+  }
+}
+
+// src/transfer/keyTransfer.ts
+import { readFile } from "node:fs/promises";
+
 // src/transfer/keyBundle.ts
 var KEY_BUNDLE_KIND = "safekb-key-export";
 var KEY_BUNDLE_VERSION = 1;
-var RECOMMENDED_EXPORT_PASSPHRASE_LENGTH = 12;
-var KEY_INFO = "safekb/key-export/v1";
+var KEY_INFO2 = "safekb/key-export/v1";
 var EXPORT_KDF = MIN_KDF_PARAMS;
-var MAX_KDF = { m: 256 * 1024, t: 8, p: 4 };
-var OBJECT_ID3 = /^[0-9a-f]{24}$/;
-function malformed(why) {
+var MAX_KDF2 = { m: 256 * 1024, t: 8, p: 4 };
+var OBJECT_ID5 = /^[0-9a-f]{24}$/;
+function malformed2(why) {
   return new ClientError(`Not a SafeKB key export: ${why}`);
 }
 function aadOf(salt, kdf) {
-  return `${KEY_INFO}|${salt}|${kdf.m}|${kdf.t}|${kdf.p}`;
+  return `${KEY_INFO2}|${salt}|${kdf.m}|${kdf.t}|${kdf.p}`;
 }
 async function bundleKey(passphrase, salt, kdf) {
-  return deriveKey(await derivePassphraseIkm(passphrase, salt, kdf), KEY_INFO);
+  return deriveKey(await derivePassphraseIkm(passphrase, salt, kdf), KEY_INFO2);
 }
 function assertContent(value) {
   const raw = value;
   const names = raw?.names;
-  if (!Array.isArray(raw?.keys) || typeof names !== "object" || names === null || Array.isArray(names) || !Object.entries(names).every(([rootId, name]) => OBJECT_ID3.test(rootId) && typeof name === "string" && name.length > 0)) {
-    throw malformed("its content is not keys and the names of their roots");
+  if (!Array.isArray(raw?.keys) || typeof names !== "object" || names === null || Array.isArray(names) || !Object.entries(names).every(([rootId, name]) => OBJECT_ID5.test(rootId) && typeof name === "string" && name.length > 0)) {
+    throw malformed2("its content is not keys and the names of their roots");
   }
   return { keys: raw.keys.map(assertKeyFile), names: { ...names } };
 }
@@ -24787,22 +27451,22 @@ function parseBundle(text) {
   try {
     value = JSON.parse(text);
   } catch {
-    throw malformed("it is not valid JSON");
+    throw malformed2("it is not valid JSON");
   }
   const raw = value;
   if (raw?.kind !== KEY_BUNDLE_KIND) {
-    throw malformed(`its kind is not '${KEY_BUNDLE_KIND}'`);
+    throw malformed2(`its kind is not '${KEY_BUNDLE_KIND}'`);
   }
   if (raw.v !== KEY_BUNDLE_VERSION) {
-    throw malformed(`its version is not ${KEY_BUNDLE_VERSION}; use the version of @safekb/mcp that wrote it`);
+    throw malformed2(`its version is not ${KEY_BUNDLE_VERSION}; use the version of @safekb/mcp that wrote it`);
   }
   const { kdf, salt } = raw;
   if (typeof kdf !== "object" || kdf === null || typeof salt !== "string") {
-    throw malformed("it has no KDF parameters and salt");
+    throw malformed2("it has no KDF parameters and salt");
   }
   const params = assertKdfParams(kdf);
-  if (params.m > MAX_KDF.m || params.t > MAX_KDF.t || params.p > MAX_KDF.p) {
-    throw malformed("its KDF parameters are beyond what this client runs");
+  if (params.m > MAX_KDF2.m || params.t > MAX_KDF2.t || params.p > MAX_KDF2.p) {
+    throw malformed2("its KDF parameters are beyond what this client runs");
   }
   return {
     v: raw.v,
@@ -24839,69 +27503,7 @@ async function openKeyBundle(text, passphrase) {
   return assertContent(JSON.parse(utf8Decode(plaintext)));
 }
 
-// src/transfer/console.ts
-class TransferConsole {
-  reader;
-  transfer;
-  names;
-  constructor(reader, transfer, names) {
-    this.reader = reader;
-    this.transfer = transfer;
-    this.names = names;
-  }
-  async export(path) {
-    await this.transfer.exportable();
-    const keys = await this.transfer.export(path, await this.readNewPassphrase());
-    this.reader.write(`Exported ${keys.length} key(s) to ${path}:
-`);
-    await this.writeRoots(keys);
-    this.reader.write(`The file opens only with the passphrase you typed: keep both, and keep them apart.
-` + `A seal root that is opened by a passphrase has no key on this machine and is not in the file.
-`);
-  }
-  async import(path) {
-    const passphrase = await this.reader.read("Passphrase of the export file (not shown): ", { hidden: true });
-    const { imported, store, present } = await this.transfer.import(path, passphrase);
-    if (store !== null) {
-      this.reader.write(`Imported ${imported.length} key(s) into ${KEY_STORE_LABELS[store]}:
-`);
-      await this.writeRoots(imported);
-    }
-    if (present.length > 0) {
-      this.reader.write(`${present.length} key(s) were already on this machine and were left as they are:
-`);
-      await this.writeRoots(present);
-    }
-  }
-  async writeRoots(keys) {
-    for (const { root_id } of keys) {
-      this.reader.write(`  ${printable2(await this.names.describe(root_id))}
-`);
-    }
-  }
-  async readNewPassphrase() {
-    for (;; ) {
-      const first = await this.reader.read(`Passphrase for the export file (not shown; ${RECOMMENDED_EXPORT_PASSPHRASE_LENGTH} or more characters recommended): `, { hidden: true });
-      if (first.length === 0) {
-        this.reader.write(`Nothing entered.
-`);
-        continue;
-      }
-      if (first.length < RECOMMENDED_EXPORT_PASSPHRASE_LENGTH) {
-        this.reader.write(`Note: shorter than the recommended ${RECOMMENDED_EXPORT_PASSPHRASE_LENGTH} characters; every key in the file is only as safe as this passphrase.
-`);
-      }
-      const second = await this.reader.read("Repeat it: ", { hidden: true });
-      if (first === second)
-        return first;
-      this.reader.write(`The two entries differ.
-`);
-    }
-  }
-}
-
 // src/transfer/keyTransfer.ts
-import { readFile } from "node:fs/promises";
 function idOf(file2) {
   return `${file2.tenant_id}/${file2.root_id}/${file2.kid}`;
 }
@@ -25041,6 +27643,50 @@ async function transferKeys(options, reader, systemKeyring = new OsKeyring) {
   const terminal = new TransferConsole(reader, new KeyTransfer(await openKeyStoresOnly(options, tenant, systemKeyring), names), names);
   await (options.mode === "export-keys" ? terminal.export(transferFile) : terminal.import(transferFile));
 }
+var WHILE_IT_RUNS = Number.POSITIVE_INFINITY;
+async function runBackup(options, reader, systemKeyring = new OsKeyring) {
+  const file2 = parsed(options.backupFile);
+  const config2 = await loadTokenConfig(options.configPath);
+  const url2 = apiUrlFor(options, config2);
+  const http = new HttpClient(url2, config2.token);
+  const tenant = config2.tenant_id;
+  const sealed = {
+    api: new SealedApi(http),
+    session: new SealedSession(WHILE_IT_RUNS),
+    tenant,
+    stores: options.mode === "export" ? await openStores(options, tenant, systemKeyring, await storesOf(options, systemKeyring, toStderr)) : await openKeyStoresOnly(options, tenant, systemKeyring),
+    names: namesOf(options)
+  };
+  const parts = {
+    kb: new KbApi(http),
+    sealed,
+    services: createSealedServices(sealed)
+  };
+  const terminal = new BackupConsole(reader);
+  try {
+    if (options.mode === "export") {
+      const exporter = new Exporter(parts, {
+        selection: {
+          spaces: options.exportSpaceIds.length === 0 ? null : options.exportSpaceIds,
+          documents: options.exportDocumentIds
+        },
+        skipLocked: options.skipLocked,
+        source: { url: url2, tenant_id: tenant },
+        clientVersion: VERSION
+      }, terminal.progress);
+      await terminal.export(exporter, file2, options.compress ? "gzip" : "none");
+      return;
+    }
+    const importer = new Importer(parts, {
+      tenantId: tenant,
+      intoSpaceId: options.intoSpaceId,
+      store: options.store ?? "default"
+    }, terminal.progress);
+    await terminal.import(importer, file2);
+  } finally {
+    sealed.session.lockAll();
+  }
+}
 async function atTerminal(options, typed2, run, whenLeft = () => "was aborted") {
   if (!process.stdin.isTTY) {
     throw new StartupError(`--${options.mode} needs a terminal: ${typed2} is typed into it`);
@@ -25134,12 +27780,12 @@ async function serve(options, transport, systemKeyring = new OsKeyring, onboardi
 }) {
   const session = new SealedSession(options.idleTtlMs);
   let hosted = null;
-  const open4 = async (config2, chosen) => {
+  const open5 = async (config2, chosen) => {
     const opened = await openTools(options, config2, session, systemKeyring, chosen);
     hosted = opened.hosted;
     return opened;
   };
-  const tools = existsSync4(options.configPath) ? await authorizedServer(options, open4, systemKeyring, onboarding) : await unauthorizedServer(options, open4, systemKeyring, onboarding);
+  const tools = existsSync5(options.configPath) ? await authorizedServer(options, open5, systemKeyring, onboarding) : await unauthorizedServer(options, open5, systemKeyring, onboarding);
   const sweep = setInterval(() => session.expireIdle(), IDLE_SWEEP_MS);
   sweep.unref();
   tools.server.onclose = () => {
@@ -25155,16 +27801,16 @@ async function serve(options, transport, systemKeyring = new OsKeyring, onboardi
     }
   };
 }
-async function authorizedServer(options, open4, systemKeyring, onboarding) {
+async function authorizedServer(options, open5, systemKeyring, onboarding) {
   const config2 = await loadTokenConfig(options.configPath);
   const chosen = await storesOf(options, systemKeyring, onboarding.log);
   const parts = {
-    ...await open4(config2, chosen),
+    ...await open5(config2, chosen),
     localInstructions: SEALED_INSTRUCTIONS
   };
   return new ToolServer(VERSION, instructionsOf(parts), await toolSetOf(parts));
 }
-async function unauthorizedServer(options, open4, systemKeyring, onboarding) {
+async function unauthorizedServer(options, open5, systemKeyring, onboarding) {
   const chosen = await storesOf(options, systemKeyring, onboarding.log);
   let server = null;
   const connection = new Connection({
@@ -25180,7 +27826,7 @@ async function unauthorizedServer(options, open4, systemKeyring, onboarding) {
       onInvited
     }),
     connected: async ({ config: config2 }) => {
-      const opened = await open4(config2, chosen);
+      const opened = await open5(config2, chosen);
       try {
         await server?.replaceTools(await toolSetOf({
           localTools: [connection.tool(), ...opened.localTools],
@@ -25221,7 +27867,7 @@ function registeredArgs(options) {
 async function setUp(options, parts) {
   const { log } = parts;
   const chosen = await storesOf(options, parts.systemKeyring, log);
-  if (existsSync4(options.configPath)) {
+  if (existsSync5(options.configPath)) {
     const config2 = await loadTokenConfig(options.configPath);
     apiUrlFor(options, config2);
     log(`This computer is already authorized for ${config2.url} (${options.configPath}).`);
@@ -25271,6 +27917,11 @@ async function main(argv, env) {
     await atTerminal(options, "the passphrase of the export file", (reader) => transferKeys(options, reader));
     return;
   }
+  if (options.mode === "export" || options.mode === "import") {
+    const importing = options.mode === "import";
+    await atTerminal(options, "the passphrase of the export file", (reader) => runBackup(options, reader), () => importing ? "was interrupted: what was imported so far stays in the account" : "was interrupted: the export file was not completed");
+    return;
+  }
   if (options.mode === "delete-key") {
     let removing = false;
     await atTerminal(options, "the name or the id of the seal root", (reader) => deleteKey(options, reader, new OsKeyring, () => {