superbee 0.4.3-pre.6 → 0.4.3-pre.8

package/dist/superbee.mjs

@@ -44,7 +44,7 @@ var __toESM = (mod, isNodeMode, target3) => (target3 = mod != null ? __create(__
 var define_SUPERBEE_BUILD_IDENTITY_default;
 var init_define_SUPERBEE_BUILD_IDENTITY = __esm({
   "<define:__SUPERBEE_BUILD_IDENTITY__>"() {
-    define_SUPERBEE_BUILD_IDENTITY_default = { schema: "superbee.build-identity.v1", package: { name: "superbee", version: "0.4.3-pre.6" }, source: { commit: "e4dbff30e3806cbcb70d658e41f3a29d46d069c8", dirty: false }, artifact: { channel: "npm-package" }, compatibility_contracts: { skill: 1, hook: 1, mcp: 1 } };
+    define_SUPERBEE_BUILD_IDENTITY_default = { schema: "superbee.build-identity.v1", package: { name: "superbee", version: "0.4.3-pre.8" }, source: { commit: "9d37b0a82d04092a95ebb2fd95d9faf93964d384", dirty: false }, artifact: { channel: "npm-package" }, compatibility_contracts: { skill: 1, hook: 1, mcp: 1 } };
   }
 });
 
@@ -27545,7 +27545,7 @@ var init_whole_document_transport = __esm({
     init_version_transport();
     init_read_adapter();
     HOSTED_MANAGED_FIELDS = /* @__PURE__ */ new Set(["actor", "superbee_updated_by", "generated", "verified", "timestamp", "okf_version"]);
-    IMPORT_CARRIED_FIELDS = Object.freeze(["generated", "timestamp", "actor", "okf_version"]);
+    IMPORT_CARRIED_FIELDS = Object.freeze(["generated", "timestamp", "actor", "okf_version", "superbee_updated_by", "verified"]);
     IMPORT_DROPPED_FIELDS = Object.freeze([...HOSTED_MANAGED_FIELDS].filter((field) => !IMPORT_CARRIED_FIELDS.includes(field)));
     FRONTMATTER_KEY_LIMIT = 32;
     UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
@@ -28287,12 +28287,37 @@ async function deleteLocal(local, id, options = {}) {
   }
 }
 async function retireQuietly(backend, mode, target3) {
+  let failed = false, failure3;
   try {
     await retireAcknowledgedBody(backend, mode, target3);
   } catch (error51) {
-    const name = error51?.name;
-    if (!(error51 instanceof JournalGuardConflict) && !(typeof name === "string" && TRANSIENT_STORAGE_ERRORS.has(name))) throw error51;
+    failed = true;
+    failure3 = error51;
   }
+  try {
+    if (!failed || failure3 instanceof JournalGuardConflict) retirementFailures.get(backend)?.delete(target3);
+    else recordRetirementFailure(backend, target3, failure3);
+  } catch {
+  }
+}
+function recordRetirementFailure(backend, target3, error51) {
+  let failures = retirementFailures.get(backend);
+  if (!failures) retirementFailures.set(backend, failures = /* @__PURE__ */ new Map());
+  const previous3 = failures.get(target3);
+  const described = describeRetirementError(error51);
+  failures.set(target3, { target: target3, failures: (previous3?.failures ?? 0) + 1, error: described, since: previous3?.since ?? (/* @__PURE__ */ new Date()).toISOString() });
+}
+function describeRetirementError(error51) {
+  let name = "Error", message = "";
+  try {
+    const candidate = error51;
+    if (candidate !== null && typeof candidate === "object") {
+      if (typeof candidate.name === "string" && candidate.name) name = candidate.name;
+      if (typeof candidate.message === "string") message = candidate.message;
+    } else message = String(error51);
+  } catch {
+  }
+  return { name: name.slice(0, 64), message: message.slice(0, RETIREMENT_MESSAGE_CHARS) };
 }
 function conflictResolutionKey(id) {
   return `conflict-resolution:${id}`;
@@ -29055,7 +29080,7 @@ async function reclaimInFlight(local) {
   }
   return reclaimed;
 }
-var BOOTSTRAP_KEY, SYNC_KEY, PULL_KEY, ACKNOWLEDGED_KEY, EMPTY_REGISTRY, UNSETTLED_STATES, DEFAULT_BATCH_SIZE, DEFAULT_CONCURRENCY, MIN_BOUNDED_DELETIONS, COMPOSE_ATTEMPTS, TRANSIENT_STORAGE_ERRORS, ConflictReviewStaleError, BUSY_REFUSAL_CODES, PULL_MARK_ATTEMPTS;
+var BOOTSTRAP_KEY, SYNC_KEY, PULL_KEY, ACKNOWLEDGED_KEY, EMPTY_REGISTRY, UNSETTLED_STATES, DEFAULT_BATCH_SIZE, DEFAULT_CONCURRENCY, MIN_BOUNDED_DELETIONS, COMPOSE_ATTEMPTS, RETIREMENT_MESSAGE_CHARS, retirementFailures, ConflictReviewStaleError, BUSY_REFUSAL_CODES, PULL_MARK_ATTEMPTS;
 var init_local_bundle = __esm({
   "../browser-local/src/local-bundle.ts"() {
     "use strict";
@@ -29084,7 +29109,8 @@ var init_local_bundle = __esm({
     DEFAULT_CONCURRENCY = 8;
     MIN_BOUNDED_DELETIONS = 8;
     COMPOSE_ATTEMPTS = 3;
-    TRANSIENT_STORAGE_ERRORS = /* @__PURE__ */ new Set(["AbortError", "InvalidStateError", "TransactionInactiveError", "UnknownError"]);
+    RETIREMENT_MESSAGE_CHARS = 512;
+    retirementFailures = /* @__PURE__ */ new WeakMap();
     ConflictReviewStaleError = class extends Error {
       constructor() {
         super("The conflict changed since review. Inspect it again before choosing a resolution.");
@@ -88299,17 +88325,16 @@ function monotonicEvolutionBlockers(current, desired, blockers) {
       );
     }
   }
-  const currentDeclared = /* @__PURE__ */ new Set([...current.fields.required, ...current.fields.optional]);
   const desiredDeclared = /* @__PURE__ */ new Set([...desired.fields.required, ...desired.fields.optional]);
   for (const [field, desiredValues] of Object.entries(desired.fields.values)) {
     const currentValues = current.fields.values[field];
     if (!currentValues) {
-      if (desiredDeclared.has(field) && !currentDeclared.has(field)) continue;
+      if (desiredDeclared.has(field)) continue;
       evolutionBlocker(
         blockers,
         "RECIPE_EVOLUTION_NON_MONOTONIC",
         desired.id,
-        `automatic evolution cannot add an enum restriction to '${field}' for '${desired.governs}'; only a field newly declared by the same plan may gain one`,
+        `automatic evolution cannot add an enum restriction to '${field}' for '${desired.governs}'; declare '${field}' in fields.required or fields.optional first`,
         field
       );
       continue;
@@ -88368,6 +88393,20 @@ function monotonicEvolutionBlockers(current, desired, blockers) {
     );
   }
 }
+function addedFieldRestrictions(current, desired) {
+  const types = /* @__PURE__ */ new Map();
+  for (const [field, type] of Object.entries(desired.fields.types ?? {})) {
+    if (!Object.hasOwn(current.fields.types ?? {}, field)) types.set(field, type);
+  }
+  const currentDeclared = /* @__PURE__ */ new Set([...current.fields.required, ...current.fields.optional]);
+  const values = /* @__PURE__ */ new Map();
+  for (const [field, allowed] of Object.entries(desired.fields.values)) {
+    if (!Object.hasOwn(current.fields.values, field) && currentDeclared.has(field)) {
+      values.set(field, allowed.map((value) => String(value)));
+    }
+  }
+  return { types, values };
+}
 function addedLinkTypes(current, desired) {
   const currentLinks = current.links ?? {};
   return Object.keys(desired.links ?? {}).filter((linkType) => !Object.hasOwn(currentLinks, linkType));
@@ -88423,6 +88462,7 @@ async function prepareRecipeEvolution(bundle, sourceRecipe) {
   const proofs = [];
   const desiredKinds = /* @__PURE__ */ new Map();
   const addedLinkTexts = /* @__PURE__ */ new Set();
+  const addedRestrictions = /* @__PURE__ */ new Map();
   const skippedConventions = [];
   const installedConventions = await query2(bundle, { prefix: CONVENTIONS_PREFIX, type: "Convention" }, {
     onSkip: (skipped) => skippedConventions.push(skipped)
@@ -88567,6 +88607,7 @@ async function prepareRecipeEvolution(bundle, sourceRecipe) {
     });
     if (!unchanged2 && existing.doc.frontmatter.type === "Convention" && parsedCurrent.ok && parsedCandidate.ok && parsedCurrent.kind.governs === parsedCandidate.kind.governs) {
       monotonicEvolutionBlockers(parsedCurrent.kind, parsedCandidate.kind, blockers);
+      addedRestrictions.set(parsedCandidate.kind.governs, addedFieldRestrictions(parsedCurrent.kind, parsedCandidate.kind));
       for (const linkType of addedLinkTypes(parsedCurrent.kind, parsedCandidate.kind)) addedLinkTexts.add(linkType);
     }
   }
@@ -88651,6 +88692,8 @@ async function prepareRecipeEvolution(bundle, sourceRecipe) {
       );
     }
     for (const kind2 of changingKinds) {
+      const added = addedRestrictions.get(kind2.governs);
+      const violations = /* @__PURE__ */ new Map();
       for (const doc2 of docs) {
         if (String(doc2.frontmatter.type) !== kind2.governs) continue;
         instancesChecked += 1;
@@ -88659,16 +88702,39 @@ async function prepareRecipeEvolution(bundle, sourceRecipe) {
           id: doc2.id,
           current_version: contentVersion(doc2)
         });
-        for (const warning of projectKindValidationWarnings(okfVersion, kind2, validateAgainstKind(doc2, kind2))) {
-          evolutionBlocker(
-            blockers,
-            "RECIPE_EVOLUTION_INSTANCE_INVALID",
-            doc2.id,
-            warning.message,
-            warning.field
-          );
+        const stored = validateAgainstKind(doc2, kind2);
+        const projected = projectKindValidationWarnings(okfVersion, kind2, stored);
+        for (const [index2, warning] of projected.entries()) {
+          const field = stored[index2].field ?? "";
+          const restriction = warning.code === "KIND_FIELD_TYPE" && added?.types.has(field) ? `fields.types.${field}` : (warning.code === "KIND_FIELD_VALUE" || warning.code === "KIND_FIELD_ARITY") && added?.values.has(field) ? `fields.values.${field}` : void 0;
+          if (restriction === void 0) {
+            evolutionBlocker(
+              blockers,
+              "RECIPE_EVOLUTION_INSTANCE_INVALID",
+              doc2.id,
+              warning.message,
+              warning.field
+            );
+            continue;
+          }
+          const entry = violations.get(restriction) ?? { field, docs: /* @__PURE__ */ new Map() };
+          if (!entry.docs.has(doc2.id)) entry.docs.set(doc2.id, warning.message);
+          violations.set(restriction, entry);
         }
       }
+      for (const [restriction, { field, docs: violating }] of violations) {
+        const ids = [...violating.keys()].sort();
+        const named = ids.slice(0, RESTRICTION_BLOCKER_DOC_CAP).join(", ");
+        const more = ids.length > RESTRICTION_BLOCKER_DOC_CAP ? `, and ${ids.length - RESTRICTION_BLOCKER_DOC_CAP} more` : "";
+        const declared = restriction.startsWith("fields.types.") ? `type '${added.types.get(field)}'` : `allowed values [${added.values.get(field).join(", ")}]`;
+        evolutionBlocker(
+          blockers,
+          "RECIPE_EVOLUTION_RESTRICTION_VIOLATED",
+          kind2.id,
+          `adding ${declared} to '${field}' for '${kind2.governs}' would make ${ids.length} existing document(s) invalid: ${named}${more}; fix them first (e.g. ${ids[0]}: ${violating.get(ids[0])})`,
+          restriction
+        );
+      }
     }
     if (addedLinkTexts.size > 0) {
       const proven = new Set(instanceProofs.map((proof) => proof.id));
@@ -88836,7 +88902,7 @@ async function applyRecipeEvolution(bundle, recipe2, expectedPlanToken, actor) {
     counts: { updated, unchanged: completed.length - updated }
   };
 }
-var RECIPE_EVOLUTION_WRITE_REGISTRY, PRESERVED_ROOT_METADATA, BUNDLE_LOCAL_PLACEMENT;
+var RECIPE_EVOLUTION_WRITE_REGISTRY, PRESERVED_ROOT_METADATA, BUNDLE_LOCAL_PLACEMENT, RESTRICTION_BLOCKER_DOC_CAP;
 var init_recipe_evolution = __esm({
   "../cli/src/recipe-evolution.ts"() {
     "use strict";
@@ -88849,6 +88915,7 @@ var init_recipe_evolution = __esm({
     RECIPE_EVOLUTION_WRITE_REGISTRY = { kinds: /* @__PURE__ */ new Map(), warnings: [] };
     PRESERVED_ROOT_METADATA = /* @__PURE__ */ new Set(["timestamp", "actor", "generated", "verified", "superbee_updated_by"]);
     BUNDLE_LOCAL_PLACEMENT = /* @__PURE__ */ new Set(["order"]);
+    RESTRICTION_BLOCKER_DOC_CAP = 10;
   }
 });
 
@@ -89036,7 +89103,9 @@ it compares definitions, permits additive declarations only, revalidates existin
 returns one exact apply command. Applying requires that plan's token, recomputes the preflight, and
 writes each changed convention with exact-version CAS. Concurrent non-target changes are detected
 by a postcondition check and reported with completed work. It never replaces existing values,
-active View assets, or artifacts omitted from the source.
+active View assets, or artifacts omitted from the source. It may add a field type (fields.types) or
+an enum (fields.values) to a declared field only when every existing instance conforms; otherwise
+the plan names the violating documents. It never changes or removes a type or an enum.
 
 Options:
   --dir <path>          Bundle directory (default: discovered from the cwd)
@@ -134329,9 +134398,806 @@ var init_publish_state = __esm({
   }
 });
 
-// ../cli/src/commands/checkout-adopt.ts
+// ../cli/src/commands/export.ts
+import { randomBytes as randomBytes9 } from "node:crypto";
+import { homedir as homedir39 } from "node:os";
+import { link as link3, lstat as lstat8, mkdir as mkdir4, open as open4, readdir as readdir8, realpath as realpath11, rename as rename2, rm as rm2, unlink as unlink13 } from "node:fs/promises";
 import path54 from "node:path";
-import { lstat as lstat8, realpath as realpath11 } from "node:fs/promises";
+import { parseArgs as parseArgs41 } from "node:util";
+function exportDeps(partial2) {
+  return {
+    stdout: partial2.stdout ?? ((text5) => void process.stdout.write(text5)),
+    auth: partial2.auth ?? defaultHostedAuthDeps(homedir39()),
+    cwd: partial2.cwd ?? process.cwd(),
+    ...partial2.fetch ? { fetch: partial2.fetch } : {}
+  };
+}
+async function entryKind(target3) {
+  let info;
+  try {
+    info = await lstat8(target3);
+  } catch (error51) {
+    if (error51.code === "ENOENT") return "absent";
+    throw error51;
+  }
+  if (!info.isDirectory()) return "other";
+  return (await readdir8(target3)).length === 0 ? "empty-dir" : "dir";
+}
+function shown(paths) {
+  return [...paths].sort().slice(0, SHOWN);
+}
+function refusalCode(body) {
+  const error51 = body?.error;
+  if (typeof error51 === "string") return error51;
+  const code3 = error51?.code;
+  return typeof code3 === "string" ? code3 : void 0;
+}
+async function namedClient(source, deps2, resume2) {
+  const { target: target3 } = source;
+  const account = await connectHostedAccount(target3, { ...source.workspace !== null ? { workspace: source.workspace } : {}, resume: resume2, deadlineMs: EXPORT_DEADLINE_MS }, deps2);
+  const { reference } = resolveBundleReference(
+    { slug: source.slug, bundleId: source.bundleId },
+    account,
+    target3,
+    (named) => `${cliInvocation()} export ${commandToken(named)} --host ${commandToken(hostArgument(target3))} --to <folder>`
+  );
+  return { client: reference.slug === null ? account.client : account.client.within(reference.slug), slug: reference.slug };
+}
+async function fetchExport(source, deps2, resume2) {
+  const named = source.binding ? null : await namedClient(source, deps2, resume2);
+  const client = named ? named.client : (await connectCheckout(source.binding, { resume: resume2, deadlineMs: EXPORT_DEADLINE_MS }, deps2)).client;
+  const slug = named ? named.slug : source.binding.workspace_slug ?? null;
+  return fetchExportThrough({ client, slug, source, resume: resume2 });
+}
+async function fetchExportThrough(request3) {
+  const { source } = request3;
+  const { bundleId: bundleId2, target: target3 } = source;
+  for (let attempt = 1; ; attempt += 1) {
+    const chain = new ExportPageChain();
+    let bytes = 0;
+    let cursor;
+    let moved = false;
+    for (; ; ) {
+      let page;
+      for (let tries = 1; page === void 0; tries += 1) {
+        const answer2 = await exportAnswer(request3, { bundleId: bundleId2, paged: true, ...cursor !== void 0 ? { cursor } : {} });
+        if (answer2.refused === "invalid_input" && cursor === void 0 && attempt === 1) return verified(await readArchive(await wholeAnswer(request3), source, MAX_EXPORT_BYTES), source);
+        if (answer2.refused === "concurrent_change") {
+          moved = true;
+          break;
+        }
+        try {
+          if (answer2.refused !== void 0) throw await exportRefusal(request3, answer2.refused, answer2.status);
+          page = verified(await readArchive(answer2.ok, source, MAX_EXPORT_BYTES - bytes), source, { paged: true });
+        } catch (error51) {
+          const again = error51 instanceof CliError && (error51.details?.reason === "export_incomplete" || answer2.refused === "backend_unavailable" && error51.code === "TRANSIENT");
+          if (!again || tries >= 2) throw error51;
+          await pause2(PAGE_RETRY_MS);
+        }
+      }
+      if (moved) break;
+      bytes += page.bytes;
+      cursor = joining(source, () => chain.add(page));
+      if (cursor === void 0) return joining(source, () => chain.joined());
+    }
+    if (attempt >= PAGED_EXPORT_ATTEMPTS) {
+      throw new CliError("TRANSIENT", `'${bundleId2}' kept changing on ${target3.origin} while it was exported; nothing was written`, {
+        details: { reason: "export_source_changed", bundle_id: bundleId2, host: target3.origin, retryable: true },
+        help: "retry the same command once the bundle is not being edited"
+      });
+    }
+    const base = PAGED_EXPORT_RESTART_MS[attempt - 1];
+    await pause2(Math.round(base / 2 + Math.random() * base / 2));
+  }
+}
+async function exportAnswer({ client, source, resume: resume2 }, input) {
+  let answer2;
+  try {
+    answer2 = await client.carrier.stream(`${client.prefix}/export`, input, client.signal);
+  } catch (error51) {
+    throw hostedFailure(error51, source.target, resume2);
+  }
+  if (!answer2.ok) return { refused: refusalCode(answer2.body) ?? "RUNTIME", status: answer2.status };
+  return { ok: answer2.body };
+}
+async function wholeAnswer(request3) {
+  const answer2 = await exportAnswer(request3, { bundleId: request3.source.bundleId });
+  if (answer2.refused !== void 0) throw await exportRefusal(request3, answer2.refused, answer2.status);
+  return answer2.ok;
+}
+function exportTooLarge(source) {
+  return new CliError("RUNTIME", `${source.target.origin} answered an export larger than ${MAX_EXPORT_BYTES} bytes`, {
+    details: { reason: "export_too_large", host: source.target.origin, bundle_id: source.bundleId, retryable: false, next: "the person exports it with Export bundle in the Superbee app" },
+    help: `${cliInvocation()} whoami --host ${commandToken(hostArgument(source.target))}`
+  });
+}
+async function exportRefusal({ client, slug, source, resume: resume2 }, code3, status2) {
+  const { target: target3, bundleId: bundleId2 } = source;
+  if (code3 === "bundle_not_found") {
+    if (source.binding) return await bundleAbsent(source.binding, client);
+    const text5 = hostedBundleReferenceText({ slug, bundleId: bundleId2 });
+    return new CliError("NOT_FOUND", `no hosted bundle '${text5}' is visible to you on ${target3.origin}`, {
+      details: { bundle_id: bundleId2, ...slug !== null ? { reference: text5 } : {}, host: target3.origin },
+      help: hostedListCommand(target3)
+    });
+  }
+  if (code3 === "result_too_large") {
+    return new CliError("FORBIDDEN", `hosted bundle '${bundleId2}' is larger than an export carries`, {
+      details: { reason: "bundle_too_large", bundle_id: bundleId2, host: target3.origin, next: "the person exports it with Export bundle in the Superbee app" },
+      help: `${cliInvocation()} whoami --host ${commandToken(hostArgument(target3))}`
+    });
+  }
+  if (code3 === "validation_failed") {
+    return new CliError("FORBIDDEN", `hosted bundle '${bundleId2}' holds a path an export cannot carry`, {
+      details: { reason: "unexportable_path", bundle_id: bundleId2, host: target3.origin, next: "the person renames the document or file in the Superbee app, then the same command is retried" },
+      help: `${cliInvocation()} whoami --host ${commandToken(hostArgument(target3))}`
+    });
+  }
+  return hostedFailure(new RemoteError(`hosted export answered ${status2}`, code3, status2), target3, resume2);
+}
+async function readArchive(body, source, budget) {
+  const { target: target3, bundleId: bundleId2 } = source;
+  const reader = body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const part = await reader.read();
+      if (part.done) break;
+      size += part.value.byteLength;
+      if (size > budget) throw exportTooLarge(source);
+      chunks.push(part.value);
+    }
+  } catch (error51) {
+    if (error51 instanceof CliError) throw error51;
+    throw new CliError("TRANSIENT", `the export of '${bundleId2}' from ${target3.origin} stopped part way; nothing was written`, {
+      details: { reason: "export_incomplete", bundle_id: bundleId2, host: target3.origin, retryable: true },
+      help: "retry the same command"
+    });
+  } finally {
+    void reader.cancel().catch(() => {
+    });
+  }
+  const archive = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    archive.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return archive;
+}
+function verified(archive, source, options = {}) {
+  return refusingArchive(source, () => verifyExport(archive, source.bundleId, options));
+}
+function joining(source, join19) {
+  return refusingArchive(source, join19);
+}
+function refusingArchive(source, verify) {
+  try {
+    return verify();
+  } catch (error51) {
+    if (!(error51 instanceof ExportArchiveError)) throw error51;
+    if (error51.problem === "incomplete") {
+      throw new CliError("TRANSIENT", `the export of '${source.bundleId}' was not completed by the host; nothing was written`, {
+        details: { reason: "export_incomplete", bundle_id: source.bundleId, host: source.target.origin, retryable: true },
+        help: "retry the same command"
+      });
+    }
+    throw new CliError("RUNTIME", `${source.target.origin} answered an export this CLI refuses (${error51.message}); nothing was written`, {
+      details: { reason: `export_${error51.problem}`, bundle_id: source.bundleId, host: source.target.origin, retryable: false },
+      help: "upgrade Superbee (npm install -g superbee); if it persists, report this bundle and reason"
+    });
+  }
+}
+async function writeNewFile(file2, bytes) {
+  const handle = await open4(file2, "wx", 420);
+  try {
+    await handle.writeFile(bytes);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function writeEntries(root, entries) {
+  for (const entry of entries) {
+    const file2 = path54.join(root, ...entry.path.split("/"));
+    await mkdir4(path54.dirname(file2), { recursive: true });
+    await writeNewFile(file2, entry.bytes);
+  }
+}
+function gitRun(dir, args) {
+  let result3;
+  try {
+    result3 = runGit(dir, args);
+  } catch (error51) {
+    const missing2 = error51.code === "GIT_MISSING";
+    throw new CliError(missing2 ? "GIT_MISSING" : "RUNTIME", `git could not run (${error51 instanceof Error ? error51.message : String(error51)})`, {
+      details: { reason: missing2 ? "git_missing" : "git_unavailable" },
+      help: "install git, or export without --git"
+    });
+  }
+  if (result3.status !== 0) {
+    throw new CliError("RUNTIME", `git ${args.find((arg) => !arg.startsWith("-") && !arg.includes("=")) ?? ""} failed: ${result3.stderr.trim().split("\n").at(-1) ?? ""}`, {
+      details: { reason: "git_failed" },
+      help: "fix the git error, then retry the same command"
+    });
+  }
+  return result3.stdout.trim();
+}
+function commitExport(dir, message, options) {
+  const quiet = ["-c", "core.hooksPath=/dev/null"];
+  gitRun(dir, [...quiet, "init", "-q"]);
+  gitRun(dir, ["symbolic-ref", "HEAD", `refs/heads/${BOARD_BRANCH}`]);
+  const excluded = ["--", ".", `:(exclude)${IN_PLACE_STAGING}`, `:(exclude)${CHECKOUT_MARKER_DIR}`];
+  gitRun(dir, ["add", "-A", ...options.force ? ["--force"] : [], ...excluded]);
+  gitRun(dir, [...quiet, ...identityFlags(dir), "-c", "commit.gpgsign=false", "commit", "-q", "--no-verify", "--allow-empty", "-m", message]);
+  const committed = { branch: BOARD_BRANCH, commit: gitRun(dir, ["rev-parse", "HEAD"]) };
+  if (options.force) return committed;
+  const ignored = gitRun(dir, ["ls-files", "--others", "--ignored", "--exclude-standard", ...excluded]).split("\n").filter(Boolean);
+  return ignored.length === 0 ? committed : { ...committed, ignored: { count: ignored.length, paths: shown(ignored) } };
+}
+function commitMessage(source, exported) {
+  return `Export ${source.bundleId} from ${source.target.origin} at revision ${exported.source.revision}
+
+superbee export, ${exported.exportedAt}: ${exported.counts.documents} documents, ${exported.counts.reserved} reserved files, ${exported.counts.blobs} blobs. History is not included.
+`;
+}
+function stagingName(target3) {
+  return path54.join(path54.dirname(target3), `.${path54.basename(target3)}.superbee-export-${process.pid}-${randomBytes9(6).toString("hex")}.partial`);
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error51) {
+    return error51.code === "EPERM";
+  }
+}
+async function removeAbandonedStaging(target3) {
+  const prefix = `.${path54.basename(target3)}.superbee-export-`;
+  let removed = 0;
+  let names;
+  try {
+    names = await readdir8(path54.dirname(target3));
+  } catch {
+    return 0;
+  }
+  for (const name of names) {
+    if (!name.startsWith(prefix)) continue;
+    const match = /^(\d+)-[0-9a-f]{12}\.partial$/.exec(name.slice(prefix.length));
+    if (!match) continue;
+    const age = await lstat8(path54.join(path54.dirname(target3), name)).then((info) => Date.now() - info.mtimeMs, () => 0);
+    if (processAlive(Number(match[1])) && age < ABANDONED_AFTER_MS) continue;
+    await rm2(path54.join(path54.dirname(target3), name), { recursive: true, force: true });
+    removed += 1;
+  }
+  return removed;
+}
+async function assertStandalone(target3, home2) {
+  const parent = path54.dirname(target3);
+  const help2 = "pass --to <folder> outside any bundle, board or checkout";
+  const checkout2 = await hostedCheckoutAt(parent, home2);
+  if (checkout2) {
+    throw new CliError("FORBIDDEN", `refusing to export inside the hosted checkout at ${checkout2.path}`, { details: { reason: "inside_checkout", enclosing: checkout2.path }, help: help2 });
+  }
+  const enclosing = await findBundleRoot(parent).catch(() => null);
+  if (enclosing) {
+    throw new CliError("FORBIDDEN", `refusing to export inside the local bundle at ${enclosing}`, { details: { reason: "inside_bundle", enclosing }, help: help2 });
+  }
+  const binding = await resolveProjectBinding(parent).catch(() => null);
+  if (binding) {
+    throw new CliError("FORBIDDEN", `refusing to export inside a project bound to a board (${binding.file})`, { details: { reason: "inside_bound_project", binding: binding.file }, help: help2 });
+  }
+}
+async function exportToFolder(source, toArg, git2, deps2, mode, resume2) {
+  const requested = path54.resolve(deps2.cwd, toArg);
+  assertBundleOutsidePrivateState(requested, deps2.auth.home);
+  const found = await entryKind(requested);
+  if (found === "other") throw new CliError("ALREADY_EXISTS", `${requested} exists and is not a folder`, { details: { reason: "not_a_folder", folder: requested }, help: "pass --to <new folder>" });
+  if (found === "dir") throw new CliError("ALREADY_EXISTS", `${requested} is not empty`, { details: { reason: "not_empty", folder: requested }, help: "pass --to <new or empty folder>" });
+  await mkdir4(path54.dirname(requested), { recursive: true });
+  const target3 = path54.join(await realpath11(path54.dirname(requested)), path54.basename(requested));
+  assertBundleOutsidePrivateState(target3, deps2.auth.home);
+  await assertStandalone(target3, deps2.auth.home);
+  const exported = await fetchExport(source, deps2, resume2);
+  const abandoned = await removeAbandonedStaging(target3);
+  const staging = stagingName(target3);
+  await mkdir4(staging);
+  let gitResult = null;
+  try {
+    await writeEntries(staging, exported.entries);
+    if (git2) gitResult = commitExport(staging, commitMessage(source, exported), { force: true });
+    const now = await entryKind(target3);
+    if (now === "dir" || now === "other") throw new CliError("ALREADY_EXISTS", `${target3} is no longer empty`, { details: { reason: "not_empty", folder: target3 }, help: "pass --to <new or empty folder>" });
+    try {
+      await rename2(staging, target3);
+    } catch (error51) {
+      const code3 = error51.code;
+      if (code3 === "ENOTEMPTY" || code3 === "EEXIST" || code3 === "ENOTDIR") {
+        throw new CliError("ALREADY_EXISTS", `${target3} is no longer empty`, { details: { reason: "not_empty", folder: target3 }, help: "pass --to <new or empty folder>" });
+      }
+      throw error51;
+    }
+  } catch (error51) {
+    await rm2(staging, { recursive: true, force: true }).catch(() => {
+    });
+    throw error51;
+  }
+  const home2 = await bundleHomeAt(target3, { home: deps2.auth.home });
+  deps2.stdout(
+    render(
+      {
+        export: "created",
+        folder: target3,
+        home: home2.home,
+        bundle_id: source.bundleId,
+        host: source.target.origin,
+        revision: exported.source.revision,
+        exported_at: exported.exportedAt,
+        okf_edition: exported.source.okfEdition,
+        documents: exported.counts.documents,
+        reserved: exported.counts.reserved,
+        blobs: exported.counts.blobs,
+        bytes: exported.bytes,
+        root_index: exported.entries.some((entry) => entry.path === "index.md"),
+        ...gitResult ? { git: gitResult } : {},
+        ...abandoned > 0 ? { removed_abandoned_exports: abandoned } : {},
+        hosted: HOSTED_UNCHANGED,
+        history: NO_HISTORY,
+        help: nextSteps(target3, gitResult !== null)
+      },
+      mode
+    )
+  );
+}
+function nextSteps(folder, git2) {
+  const steps = [commandFragment`${cliInvocation()} status --dir ${commandToken(folder)}`];
+  if (git2) steps.push(commandFragment`git -C ${commandToken(folder)} remote add origin <url> && ${cliInvocation()} sync --establish --dir ${commandToken(folder)}`);
+  return steps;
+}
+function isJournal(value) {
+  const record6 = value;
+  return record6 !== null && typeof record6 === "object" && record6.schema === JOURNAL_SCHEMA && typeof record6.bundle_id === "string" && typeof record6.host === "string" && typeof record6.audience === "string" && Number.isSafeInteger(record6.revision) && typeof record6.exported_at === "string" && typeof record6.git === "boolean" && Array.isArray(record6.adds) && record6.adds.every((entry) => typeof entry === "string") && Number.isSafeInteger(record6.same) && Array.isArray(record6.kept_local) && record6.kept_local.every((entry) => typeof entry === "string") && Array.isArray(record6.deleted_locally) && record6.deleted_locally.every((entry) => typeof entry === "string") && Number.isSafeInteger(record6.unsent_kept);
+}
+async function stagingDir(folder) {
+  const staging = path54.join(folder, IN_PLACE_STAGING);
+  try {
+    if (!(await lstat8(staging)).isDirectory()) return null;
+    return await realpath11(staging) === path54.join(await realpath11(folder), IN_PLACE_STAGING) ? staging : null;
+  } catch {
+    return null;
+  }
+}
+async function readJournal(folder) {
+  const staging = await stagingDir(folder);
+  if (!staging) return null;
+  let journal;
+  const read = readRegularFileNoFollowSync(path54.join(staging, JOURNAL));
+  if (read.state !== "present" || read.bytes.byteLength > MAX_JOURNAL_BYTES) return null;
+  try {
+    const value = JSON.parse(read.bytes.toString("utf8"));
+    if (!isJournal(value)) return null;
+    journal = value;
+  } catch {
+    return null;
+  }
+  const marker = readCheckoutMarker(folder);
+  if (!marker || marker.bundle_id !== journal.bundle_id || marker.host !== bindingHostArgument({ origin: journal.host, audience: journal.audience })) return null;
+  return journal;
+}
+async function sameBytes(file2, bytes) {
+  const read = readRegularFileNoFollowSync(file2);
+  return read.state === "present" && Buffer.compare(read.bytes, Buffer.from(bytes)) === 0;
+}
+async function placementOf(folder, entry) {
+  let info;
+  try {
+    info = await lstat8(path54.join(folder, ...entry.path.split("/")));
+  } catch (error51) {
+    const code3 = error51.code;
+    if (code3 === "ENOENT") return "add";
+    if (code3 === "ENOTDIR") return "kept";
+    throw error51;
+  }
+  if (!info.isFile()) return "kept";
+  return await sameBytes(path54.join(folder, ...entry.path.split("/")), entry.bytes) ? "same" : "kept";
+}
+async function placeStaged(folder, staging, relative2) {
+  const final = path54.join(folder, ...relative2.split("/"));
+  const staged = path54.join(staging, "files", ...relative2.split("/"));
+  try {
+    if ((await lstat8(staged)).isFile()) {
+      const stagedParent = await realpath11(path54.dirname(staged));
+      if (!stagedParent.startsWith(`${await realpath11(staging)}${path54.sep}`)) return "kept";
+    } else return "kept";
+  } catch (error51) {
+    if (error51.code !== "ENOENT") return "kept";
+    return await lstat8(final).then((info) => info.isFile(), () => false) ? "same" : "kept";
+  }
+  try {
+    await mkdir4(path54.dirname(final), { recursive: true });
+    const parent = await realpath11(path54.dirname(final));
+    if (parent !== folder && !parent.startsWith(`${folder}${path54.sep}`)) return "kept";
+  } catch {
+    return "kept";
+  }
+  let outcome;
+  try {
+    await link3(staged, final);
+    outcome = "added";
+  } catch (error51) {
+    const code3 = error51.code;
+    if (code3 !== "EEXIST") throw error51;
+    const stagedRead = readRegularFileNoFollowSync(staged);
+    outcome = stagedRead.state === "present" && await sameBytes(final, stagedRead.bytes) ? "same" : "kept";
+  }
+  await unlink13(staged).catch(() => {
+  });
+  return outcome;
+}
+async function writeJournal(staging, journal) {
+  const temp = path54.join(staging, `.${JOURNAL}.${randomBytes9(6).toString("hex")}.tmp`);
+  await writeNewFile(temp, Buffer.from(`${JSON.stringify(journal)}
+`, "utf8"));
+  await rename2(temp, path54.join(staging, JOURNAL));
+}
+async function finishInPlace(folder, journal) {
+  const staging = await stagingDir(folder);
+  if (!staging) throw new CliError("RUNTIME", `the in-place export's staging folder in ${folder} is gone`, { help: `${cliInvocation()} export --in-place --dir ${commandToken(folder)}` });
+  const added = [];
+  const kept = [...journal.kept_local];
+  let same = journal.same;
+  for (const relative2 of journal.adds) {
+    classifyEntryPath(relative2);
+    const outcome = await placeStaged(folder, staging, relative2);
+    if (outcome === "added") added.push(relative2);
+    else if (outcome === "same") same += 1;
+    else kept.push(relative2);
+  }
+  let git2 = null;
+  if (journal.git) {
+    git2 = await ownCommit(folder) ?? commitExport(folder, `Export ${journal.bundle_id} from ${journal.host} at revision ${journal.revision}
+
+superbee export --in-place, ${journal.exported_at}. History is not included.
+`, { force: false });
+  }
+  await rm2(path54.join(staging, "files"), { recursive: true, force: true });
+  await unlink13(path54.join(staging, JOURNAL)).catch(() => {
+  });
+  await rm2(staging, { recursive: true, force: true });
+  const marker = await removeCheckoutMarker(folder, { origin: journal.host, audience: journal.audience, bundle_id: journal.bundle_id }).catch(() => false) ? "removed" : "none";
+  return { added, kept, same, git: git2, marker };
+}
+function inPlaceReceipt(folder, journal, finished, homeName, resumed) {
+  return {
+    export: "converted",
+    folder,
+    home: homeName,
+    bundle_id: journal.bundle_id,
+    host: journal.host,
+    revision: journal.revision,
+    exported_at: journal.exported_at,
+    ...resumed ? { resumed: true } : {},
+    binding: "removed (the folder is no longer a hosted checkout)",
+    marker: finished.marker,
+    added: finished.added.length,
+    ...finished.added.length > 0 ? { added_paths: shown(finished.added) } : {},
+    unchanged: finished.same,
+    kept_local: finished.kept.length,
+    ...finished.kept.length > 0 ? { kept_local_paths: shown(finished.kept), kept_local_note: "these files differ from the host's (or block its path); the folder's own were kept" } : {},
+    ...journal.deleted_locally.length > 0 ? { deleted_locally: journal.deleted_locally.length, deleted_locally_paths: shown(journal.deleted_locally), deleted_locally_note: "deleted in this folder and not sent; the host's copies were not put back" } : {},
+    ...journal.unsent_kept > 0 ? { unsent_kept: journal.unsent_kept, unsent_note: "changes sync had not sent stay in this folder only" } : {},
+    ...finished.git ? { git: finished.git } : {},
+    hosted: HOSTED_UNCHANGED,
+    history: NO_HISTORY,
+    help: nextSteps(folder, finished.git !== null)
+  };
+}
+async function ownCommit(folder) {
+  const head = runGit(folder, ["rev-parse", "--verify", "--quiet", "HEAD"]);
+  const top = runGit(folder, ["rev-parse", "--show-toplevel"]);
+  const own5 = top.status === 0 && await realpath11(top.stdout.trim()).catch(() => "") === await realpath11(folder).catch(() => folder);
+  if (!own5 || head.status !== 0) return null;
+  return { branch: runGit(folder, ["symbolic-ref", "-q", "--short", "HEAD"]).stdout.trim() || BOARD_BRANCH, commit: head.stdout.trim() };
+}
+async function assertNoRepository(folder) {
+  if (await lstat8(path54.join(folder, ".git")).then(() => true, () => false)) {
+    throw new CliError("ALREADY_EXISTS", `${folder} already holds a Git repository`, {
+      details: { reason: "already_git", folder },
+      help: `${cliInvocation()} export --in-place --dir ${commandToken(folder)}`
+    });
+  }
+}
+async function exportInPlace(dirArg, git2, keepUnsent, deps2, mode, resume2) {
+  const requested = path54.resolve(deps2.cwd, dirArg ?? ".");
+  assertBundleOutsidePrivateState(requested, deps2.auth.home);
+  const binding = await hostedCheckoutFor(dirArg === void 0 ? [] : ["--dir", dirArg], deps2.auth.home, deps2.cwd);
+  if (!binding) {
+    const folder2 = await realpath11(requested).catch(() => requested);
+    const journal = await readJournal(folder2);
+    if (journal) {
+      const finished = await finishInPlace(folder2, journal);
+      const home4 = await bundleHomeAt(folder2, { home: deps2.auth.home });
+      deps2.stdout(render(inPlaceReceipt(folder2, journal, finished, home4.home, true), mode));
+      return;
+    }
+    if (await entryKind(folder2) === "absent") throw new CliError("NOT_FOUND", `${folder2} does not exist`, { help: `${cliInvocation()} export --in-place --dir <checkout folder>` });
+    const marker = readCheckoutMarker(folder2);
+    if (marker) {
+      const existing = git2 ? await ownCommit(folder2) : null;
+      if (git2 && !existing) await assertNoRepository(folder2);
+      const staging = await stagingDir(folder2);
+      if (staging && !await lstat8(path54.join(staging, JOURNAL)).then(() => true, () => false)) await rm2(staging, { recursive: true, force: true });
+      await removeCheckoutMarker(folder2, { origin: marker.host, audience: `${marker.host}/mcp`, bundle_id: marker.bundle_id });
+      const committed = existing ?? (git2 ? commitExport(folder2, `Export ${marker.bundle_id} (an unbound copy of a hosted checkout)
+
+superbee export --in-place. Nothing was fetched from the host; history is not included.
+`, { force: false }) : null);
+      const home4 = await bundleHomeAt(folder2, { home: deps2.auth.home });
+      deps2.stdout(
+        render(
+          {
+            export: "converted",
+            folder: folder2,
+            home: home4.home,
+            bundle_id: marker.bundle_id,
+            from: "an unbound copy of a hosted checkout",
+            marker: "removed",
+            fetched: false,
+            note: `nothing was fetched: the files are kept as they are. To fill in what the copy lacks from the host first, adopt it (${cliInvocation()} checkout --adopt <folder> --host <url>), then export --in-place`,
+            ...committed ? { git: committed } : {},
+            hosted: HOSTED_UNCHANGED,
+            history: NO_HISTORY,
+            help: nextSteps(folder2, committed !== null)
+          },
+          mode
+        )
+      );
+      return;
+    }
+    const home3 = await bundleHomeAt(folder2, { home: deps2.auth.home });
+    deps2.stdout(render({ export: "unchanged", folder: folder2, home: home3.home, reason: "not a hosted checkout: nothing to convert" }, mode));
+    return;
+  }
+  const folder = binding.path;
+  if (git2) await assertNoRepository(folder);
+  const status2 = await hostedStatus(binding, deps2.auth.home);
+  if (status2.sync.state === "busy") {
+    throw new CliError("CONFLICT", `another command holds the checkout lock for ${folder}`, { details: { reason: "checkout_busy", folder }, help: "wait for it to finish, then retry the same command" });
+  }
+  const unsentRefusal = (count5, sync3) => new CliError("CONFLICT", `the checkout of '${binding.bundle_id}' at ${folder} has ${count5} change(s) not on the host`, {
+    details: {
+      reason: "unsent_changes",
+      folder,
+      ...sync3,
+      keep_them_here_only: commandFragment`${cliInvocation()} export --in-place --dir ${commandToken(folder)} --keep-unsent${git2 ? commandFragment` --git` : commandFragment``}`
+    },
+    help: commandFragment`${cliInvocation()} sync --dir ${commandToken(folder)}`
+  });
+  const early = Number(status2.sync.unsent ?? 0) + Number(status2.sync.conflicts ?? 0) + Number(status2.sync.held_files ?? 0) + Number(status2.sync.held_deletions ?? 0);
+  if (early > 0 && !keepUnsent) throw unsentRefusal(early, status2.sync);
+  const source = { target: resolveHostedTarget(binding.audience), bundleId: binding.bundle_id, slug: binding.workspace_slug ?? null, workspace: null, binding };
+  const exported = await fetchExport(source, deps2, resume2);
+  const result3 = await filesystemPushRoleLocks().request(checkoutLockName(folder), { ifAvailable: true }, async (lock) => {
+    if (!lock) {
+      throw new CliError("CONFLICT", `another command holds the checkout lock for ${folder}`, { details: { reason: "checkout_busy", folder }, help: "wait for it to finish, then retry the same command" });
+    }
+    const current = await bindingForPath(deps2.auth.home, folder);
+    if (!current || current.checkout_id !== binding.checkout_id) {
+      throw new CliError("CONFLICT", `the checkout at ${folder} changed while it was exported`, { details: { reason: "checkout_changed", folder }, help: "retry the same command" });
+    }
+    const store = await FileJournaledBackend.open({ directory: checkoutStoreDir(deps2.auth.home, binding.checkout_id), readOnly: true });
+    let pending;
+    try {
+      const classified = await classifyCheckout(binding, deps2.auth.home, store);
+      pending = /* @__PURE__ */ new Set([...classified.unsent, ...classified.conflicts, ...classified.held.keys(), ...classified.heldDeletions]);
+    } finally {
+      await store.close();
+    }
+    if (pending.size > 0 && !keepUnsent) throw unsentRefusal(pending.size, { unsent_ids: shown([...pending]) });
+    const staging = path54.join(folder, IN_PLACE_STAGING);
+    await rm2(staging, { recursive: true, force: true });
+    await mkdir4(path54.join(staging, "files"), { recursive: true });
+    const adds = [];
+    const kept = [];
+    const deletedLocally = [];
+    let same = 0;
+    for (const entry of exported.entries) {
+      const id = entry.kind === "document" ? entry.path.slice(0, -3) : entry.path;
+      const placement = await placementOf(folder, entry);
+      if (placement === "add" && pending.has(id)) {
+        deletedLocally.push(entry.path);
+        continue;
+      }
+      if (placement === "same") same += 1;
+      else if (placement === "kept") kept.push(entry.path);
+      else {
+        const file2 = path54.join(staging, "files", ...entry.path.split("/"));
+        await mkdir4(path54.dirname(file2), { recursive: true });
+        await writeNewFile(file2, entry.bytes);
+        adds.push(entry.path);
+      }
+    }
+    const journal = {
+      schema: JOURNAL_SCHEMA,
+      bundle_id: binding.bundle_id,
+      host: binding.origin,
+      audience: binding.audience,
+      revision: exported.source.revision,
+      exported_at: exported.exportedAt,
+      git: git2,
+      adds,
+      same,
+      kept_local: kept,
+      deleted_locally: deletedLocally,
+      unsent_kept: pending.size
+    };
+    await writeJournal(staging, journal);
+    await releaseCheckout(deps2.auth.home, binding);
+    return { journal, finished: await finishInPlace(folder, journal) };
+  });
+  const home2 = await bundleHomeAt(folder, { home: deps2.auth.home });
+  deps2.stdout(render(inPlaceReceipt(folder, result3.journal, result3.finished, home2.home, false), mode));
+}
+async function exportCommand(argv2, partial2 = {}) {
+  const deps2 = exportDeps(partial2);
+  const { values, positionals } = parseLeafOrUsage(
+    () => parseArgs41({
+      args: argv2,
+      options: {
+        to: { type: "string" },
+        "in-place": { type: "boolean" },
+        dir: { type: "string" },
+        host: { type: "string" },
+        workspace: { type: "string" },
+        git: { type: "boolean" },
+        "keep-unsent": { type: "boolean" },
+        json: { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      },
+      allowPositionals: true
+    }),
+    CLI_LEAVES.export
+  );
+  if (values.help) {
+    deps2.stdout(renderUsage(EXPORT_USAGE));
+    return;
+  }
+  const mode = resolveMode(values);
+  const usage3 = (message) => new CliError("USAGE", message, { help: `${cliInvocation()} export --help` });
+  const named = positionals[0];
+  const inPlace = values["in-place"] === true;
+  if (inPlace === (values.to !== void 0)) throw usage3("pass exactly one of --to <folder> and --in-place");
+  if (named !== void 0 && values.dir !== void 0) throw usage3("pass a bundle id or --dir <checkout>, not both");
+  if (named === void 0 && (values.host !== void 0 || values.workspace !== void 0)) throw usage3("--host and --workspace go with a bundle id; a checkout uses its own");
+  if (inPlace && named !== void 0) throw usage3("--in-place converts a checkout folder: pass --dir <checkout>, not a bundle id");
+  if (!inPlace && values["keep-unsent"]) throw usage3("--keep-unsent goes with --in-place");
+  const reference = named === void 0 ? void 0 : parseHostedBundleReference(named);
+  if (named !== void 0 && !reference) throw usage3(`'${named}' is not a hosted bundle id or <workspace>/<bundle-id>`);
+  const git2 = values.git === true;
+  const resume2 = commandFragment`${cliInvocation()} export${named !== void 0 ? commandFragment` ${commandToken(named)}` : commandFragment``}${values.dir !== void 0 ? commandFragment` --dir ${commandToken(path54.resolve(deps2.cwd, values.dir))}` : commandFragment``}${values.to !== void 0 ? commandFragment` --to ${commandToken(path54.resolve(deps2.cwd, values.to))}` : commandFragment``}${inPlace ? commandFragment` --in-place` : commandFragment``}${values.host !== void 0 ? commandFragment` --host ${commandToken(values.host)}` : commandFragment``}${values.workspace !== void 0 ? commandFragment` --workspace ${commandToken(values.workspace)}` : commandFragment``}${git2 ? commandFragment` --git` : commandFragment``}${values["keep-unsent"] ? commandFragment` --keep-unsent` : commandFragment``}${values.json ? commandFragment` --json` : commandFragment``}`;
+  if (values.dir !== void 0) assertBundleOutsidePrivateState(path54.resolve(deps2.cwd, values.dir), deps2.auth.home);
+  if (inPlace) {
+    await exportInPlace(values.dir, git2, values["keep-unsent"] === true, deps2, mode, resume2);
+    return;
+  }
+  let source;
+  if (reference) {
+    const named2 = await requireHostedBundleHost(values.host, deps2.auth);
+    source = {
+      target: named2.target,
+      bundleId: reference.bundleId,
+      slug: reference.slug,
+      workspace: workspaceForNamedHost(named2, values.workspace) ?? null,
+      binding: null
+    };
+  } else {
+    const binding = await hostedCheckoutFor(values.dir === void 0 ? [] : ["--dir", values.dir], deps2.auth.home, deps2.cwd);
+    if (!binding) {
+      throw new CliError("NOT_FOUND", `${path54.resolve(deps2.cwd, values.dir ?? ".")} is not a hosted checkout`, {
+        details: { reason: "not_a_checkout" },
+        help: `${cliInvocation()} export <bundle-id> --to ${commandToken(values.to)}`
+      });
+    }
+    source = { target: resolveHostedTarget(binding.audience), bundleId: binding.bundle_id, slug: binding.workspace_slug ?? null, workspace: null, binding };
+  }
+  await exportToFolder(source, values.to, git2, deps2, mode, resume2);
+}
+var EXPORT_USAGE, EXPORT_DEADLINE_MS, SHOWN, JOURNAL, JOURNAL_SCHEMA, MAX_JOURNAL_BYTES, NO_HISTORY, HOSTED_UNCHANGED, PAGED_EXPORT_ATTEMPTS, PAGED_EXPORT_RESTART_MS, PAGE_RETRY_MS, pause2, ABANDONED_AFTER_MS;
+var init_export = __esm({
+  "../cli/src/commands/export.ts"() {
+    "use strict";
+    init_define_SUPERBEE_BUILD_IDENTITY();
+    init_define_SUPERBEE_UPDATE_POLICY();
+    init_src();
+    init_filesystem_push_role();
+    init_src2();
+    init_args();
+    init_bundle2();
+    init_bundle_home();
+    init_command_spec();
+    init_command_text();
+    init_errors4();
+    init_invocation();
+    init_output2();
+    init_private_state_bundle_boundary();
+    init_nofollow_read();
+    init_autopull2();
+    init_session();
+    init_discovery();
+    init_binding();
+    init_client();
+    init_account();
+    init_refusals();
+    init_reference();
+    init_sync2();
+    init_status();
+    init_file_journaled_backend();
+    init_marker();
+    init_export_archive();
+    init_export_archive();
+    EXPORT_USAGE = `superbee export \u2014 copy a hosted bundle out of hosted Superbee
+
+Usage:
+  superbee export <bundle-id> --to <folder> [--host <url>] [--workspace <id>] [--git] [--json]
+  superbee export [--dir <checkout>] --to <folder> [--git] [--json]
+  superbee export [--dir <checkout>] --in-place [--git] [--keep-unsent] [--json]
+
+Fetches the hosted bundle's portable export: every document, reserved file (index.md, log.md)
+and blob at its latest confirmed revision, byte for byte as the host stores them. The archive is
+verified whole (every entry against the host's digest manifest) before any file is written.
+Signs in if needed (AUTH_REQUIRED, exit 4, carries the one link to relay and the command to
+re-run). The hosted bundle is never changed. History is not exported: the folder holds the
+current revision only.
+
+--to <folder> writes a new local bundle there. The folder must be new or empty; it appears
+complete or not at all. With a bundle id the host is --host, else your last sign-in; with
+--dir (or run inside a checkout) the checkout's own host and bundle are used. A bundle id in more
+than one of your workspaces is named <workspace>/<bundle-id>, or with --workspace.
+
+--in-place converts a hosted checkout into a plain local bundle: it adds the files the checkout
+lacks (blobs, reserved files, documents added on the host), never overwrites a file, then
+forgets the checkout's binding. It refuses a checkout with changes sync has not sent, conflicts
+or held files; run 'superbee sync' first, or pass --keep-unsent to keep them in this folder only.
+If it is interrupted, re-running the same command finishes it.
+
+--git makes the result a Git board: a repository on branch '${BOARD_BRANCH}' whose first commit is the
+export. Share it with 'git remote add origin <url>' and 'superbee sync --establish'.
+
+Options:
+  --to <folder>       New or empty folder to export into
+  --in-place          Convert the hosted checkout (--dir, else the current folder) into a local bundle
+  --dir <checkout>    The hosted checkout to export (default: the current folder)
+  --host <url>        Hosted Superbee URL, with a bundle id; default: your last sign-in
+  --workspace <id>    With a bundle id: your workspace that holds it, by id or slug
+  --git               Initialize a Git repository on branch '${BOARD_BRANCH}' and commit the export
+  --keep-unsent       With --in-place: convert even with unsent changes, conflicts or held files
+  --json              Emit compact JSON instead of TOON
+  -h, --help          Show this help
+
+Examples:
+  superbee export team.knowledge --to ~/work/team-knowledge --git
+  superbee export --dir ~/work/team --to ~/work/team-copy
+  superbee export --dir ~/work/team --in-place
+`;
+    EXPORT_DEADLINE_MS = 6e4;
+    SHOWN = 20;
+    JOURNAL = IN_PLACE_JOURNAL;
+    JOURNAL_SCHEMA = 1;
+    MAX_JOURNAL_BYTES = 8 * 1024 * 1024;
+    NO_HISTORY = "not exported: the folder holds the current revision only";
+    HOSTED_UNCHANGED = "unchanged: the hosted bundle still exists and was not modified";
+    PAGED_EXPORT_ATTEMPTS = 3;
+    PAGED_EXPORT_RESTART_MS = [500, 1500];
+    PAGE_RETRY_MS = 1e3;
+    pause2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+    ABANDONED_AFTER_MS = 60 * 60 * 1e3;
+  }
+});
+
+// ../cli/src/commands/checkout-adopt.ts
+import path55 from "node:path";
+import { lstat as lstat9, realpath as realpath12 } from "node:fs/promises";
 function readLeaf(file2) {
   const read = readRegularFileNoFollowSync(file2);
   if (read.state === "missing") return null;
@@ -134354,11 +135220,11 @@ async function withCheckoutLock(folder, body) {
   });
 }
 async function adopt(folderArg, options, deps2, mode) {
-  const folder = path54.resolve(deps2.cwd, folderArg);
+  const folder = path55.resolve(deps2.cwd, folderArg);
   let canonical2;
   try {
-    canonical2 = await realpath11(folder);
-    if (!(await lstat8(canonical2)).isDirectory()) throw new Error("not a folder");
+    canonical2 = await realpath12(folder);
+    if (!(await lstat9(canonical2)).isDirectory()) throw new Error("not a folder");
   } catch {
     throw new CliError("NOT_FOUND", `${folder} is not a folder`, { help: `${cliInvocation()} checkout --adopt <folder> --host <url>` });
   }
@@ -134373,7 +135239,7 @@ async function adopt(folderArg, options, deps2, mode) {
     }
     if (options.workspace !== void 0 && await rebindToWorkspace(canonical2, bound, options, deps2, mode)) return;
     const marker2 = await writeCheckoutMarker(canonical2, bound).catch(() => null);
-    deps2.stdout(render({ adopted: "unchanged", ...bindingView(bound), marker: marker2 ? "written" : "present", help: nextSteps(canonical2) }, mode));
+    deps2.stdout(render({ adopted: "unchanged", ...bindingView(bound), marker: marker2 ? "written" : "present", help: nextSteps2(canonical2) }, mode));
     return;
   }
   const folderMarker = readCheckoutMarker(canonical2);
@@ -134413,7 +135279,7 @@ async function adopt(folderArg, options, deps2, mode) {
           ...marker2 ? { marker: "written" } : {},
           catalog: relocated ? { relocated: true, label: relocated.label, id: relocated.id } : { relocated: false, note: "no catalog entry named the old folder" },
           ...options.workspace !== void 0 ? { workspace_flag: "ignored: a moved checkout keeps the workspace it was bound with" } : {},
-          help: [...nextSteps(canonical2), `${cliInvocation()} sync --dir ${commandToken(canonical2)}`]
+          help: [...nextSteps2(canonical2), `${cliInvocation()} sync --dir ${commandToken(canonical2)}`]
         },
         mode
       )
@@ -134465,7 +135331,7 @@ async function adopt(folderArg, options, deps2, mode) {
   const typed = { slug: marker.workspace_slug ?? null, bundleId: bundleId2 };
   await assertStandaloneFolder(canonical2);
   const resume2 = commandFragment`${cliInvocation()} checkout --adopt ${commandToken(canonical2)} --host ${commandToken(bindingHostArgument(target3))}${options.workspace !== void 0 ? commandFragment` --workspace ${commandToken(options.workspace)}` : commandFragment``}${options.json ? commandFragment` --json` : commandFragment``}`;
-  const connection = await connectHostedBundle(typed, target3, options.workspace, deps2, resume2);
+  const connection = await connectHostedBundle(typed, target3, options.workspace, deps2, resume2, { deadlineMs: EXPORT_DEADLINE_MS });
   if (typed.slug === null && connection.reference.slug !== null) {
     const found = readBundleListing(await connection.client.bundles()).lookup({ slug: null, bundleId: bundleId2 });
     if (found.holders > 1) {
@@ -134477,8 +135343,12 @@ async function adopt(folderArg, options, deps2, mode) {
     }
   }
   const published = await readPublishedExtras(home2, canonical2);
-  const extras = published && published.host === target3.origin && published.bundle_id === bundleId2 ? published.extras : void 0;
-  const result3 = await bindFolderInPlace({ canonical: canonical2, target: target3, bundleId: bundleId2, connection, deps: deps2, resume: resume2, ...extras ? { extras } : {} });
+  const host = await adoptedExtras(canonical2, exportRequestFor(connection, target3, bundleId2, resume2));
+  const extras = {
+    ...host.extras,
+    ...published && published.host === target3.origin && published.bundle_id === bundleId2 ? published.extras : {}
+  };
+  const result3 = await bindWithExtras({ canonical: canonical2, target: target3, bundleId: bundleId2, connection, deps: deps2, resume: resume2, extras }, host);
   if (published) await clearPublishedExtras(home2, canonical2);
   const cataloged = await registerInCatalog(home2, result3.binding);
   const syncHelp = `${cliInvocation()} sync --dir ${commandToken(canonical2)}`;
@@ -134492,8 +135362,9 @@ async function adopt(folderArg, options, deps2, mode) {
         ...result3.conflicts.length > 0 ? { conflicts: listed(result3.conflicts) } : {},
         ...result3.localOnly.length > 0 ? { local_only: listed(result3.localOnly), local_only_note: "the next sync sends these as new documents, which re-creates any the host deleted since the copy was made; delete any you do not want first" } : {},
         root_index: result3.rootIndex,
+        ...result3.otherFiles ? { other_files: result3.otherFiles, warning: "files other than documents were not checked against the host" } : {},
         ...result3.markerWritten ? { marker: "written" } : {},
-        help: result3.conflicts.length > 0 ? [`${cliInvocation()} sync --dir ${commandToken(canonical2)} --inspect --doc ${commandToken(result3.conflicts[0])}`, syncHelp] : [syncHelp, ...nextSteps(canonical2)]
+        help: result3.conflicts.length > 0 ? [`${cliInvocation()} sync --dir ${commandToken(canonical2)} --inspect --doc ${commandToken(result3.conflicts[0])}`, syncHelp] : [syncHelp, ...nextSteps2(canonical2)]
       },
       mode
     )
@@ -134508,7 +135379,7 @@ async function rebindToWorkspace(canonical2, bound, options, deps2, mode) {
   }
   const target3 = resolveHostedTarget(options.host);
   const resume2 = commandFragment`${cliInvocation()} checkout --adopt ${commandToken(canonical2)} --host ${commandToken(bindingHostArgument(target3))} --workspace ${commandToken(options.workspace)}${options.json ? commandFragment` --json` : commandFragment``}`;
-  const connection = await connectHostedBundle({ slug: null, bundleId: bound.bundle_id }, target3, options.workspace, deps2, resume2);
+  const connection = await connectHostedBundle({ slug: null, bundleId: bound.bundle_id }, target3, options.workspace, deps2, resume2, { deadlineMs: EXPORT_DEADLINE_MS });
   const slug = connection.reference.slug;
   if (slug === null || slug === (bound.workspace_slug ?? null)) return false;
   if (connection.identity.principalId !== bound.principal_id) {
@@ -134557,7 +135428,8 @@ async function rebindToWorkspace(canonical2, bound, options, deps2, mode) {
     await releaseCheckout(home2, bound);
     return pending;
   });
-  const result3 = await bindFolderInPlace({ canonical: canonical2, target: target3, bundleId: bound.bundle_id, connection, deps: deps2, resume: resume2 });
+  const host = await adoptedExtras(canonical2, exportRequestFor(connection, target3, bound.bundle_id, resume2));
+  const result3 = await bindWithExtras({ canonical: canonical2, target: target3, bundleId: bound.bundle_id, connection, deps: deps2, resume: resume2, extras: host.extras }, host);
   deps2.stdout(
     render(
       {
@@ -134571,7 +135443,7 @@ async function rebindToWorkspace(canonical2, bound, options, deps2, mode) {
         documents: { placed: result3.placed.length, matched: result3.matched.length, conflicts: result3.conflicts.length, local_only: result3.localOnly.length },
         ...result3.conflicts.length > 0 ? { conflicts: listed(result3.conflicts) } : {},
         ...result3.localOnly.length > 0 ? { local_only: listed(result3.localOnly) } : {},
-        help: [`${cliInvocation()} sync --dir ${commandToken(canonical2)}`, ...nextSteps(canonical2)]
+        help: [`${cliInvocation()} sync --dir ${commandToken(canonical2)}`, ...nextSteps2(canonical2)]
       },
       mode
     )
@@ -134629,7 +135501,7 @@ async function bindFolderInPlace(input) {
       const hostIds = /* @__PURE__ */ new Set();
       for (const head of heads) {
         hostIds.add(head.id);
-        const file2 = path54.join(canonical2, pathFromConceptId(head.id));
+        const file2 = path55.join(canonical2, pathFromConceptId(head.id));
         if (await parentUnsafe(canonical2, file2)) {
           conflicts.push(head.id);
           continue;
@@ -134663,12 +135535,12 @@ async function bindFolderInPlace(input) {
       if (index2) {
         const hostRoot2 = Buffer.from(index2.content, "utf8");
         root = digestOf(hostRoot2);
-        const current = readLeaf(path54.join(canonical2, ROOT_INDEX));
+        const current = readLeaf(path55.join(canonical2, ROOT_INDEX));
         if (current === "unsafe") rootIndex = "kept (not a plain file; sync holds it)";
         else if (current === null) {
-          const placedRoot = (await placeNew(path54.join(canonical2, ROOT_INDEX), hostRoot2)).placed;
+          const placedRoot = (await placeNew(path55.join(canonical2, ROOT_INDEX), hostRoot2)).placed;
           if (placedRoot) {
-            placedFiles.set(path54.join(canonical2, ROOT_INDEX), root);
+            placedFiles.set(path55.join(canonical2, ROOT_INDEX), root);
             rootBase = index2.version;
           }
           rootIndex = placedRoot ? "placed" : "kept";
@@ -134703,6 +135575,25 @@ async function bindFolderInPlace(input) {
     }
   });
 }
+function exportRequestFor(connection, target3, bundleId2, resume2) {
+  const { client, reference } = connection;
+  return {
+    client: reference.slug === null ? client : client.within(reference.slug),
+    slug: reference.slug,
+    source: { target: target3, bundleId: bundleId2, slug: reference.slug, workspace: null, binding: null },
+    resume: resume2
+  };
+}
+async function bindWithExtras(input, host) {
+  try {
+    const result3 = await bindFolderInPlace(input);
+    return host.unplaced === null ? result3 : { ...result3, otherFiles: `not recorded: ${host.unplaced}; files other than documents here that differ from nothing on record read as edits until the next checkout` };
+  } catch (error51) {
+    await removePlaced(input.canonical, host.placed, false).catch(() => {
+    });
+    throw error51;
+  }
+}
 var LISTED;
 var init_checkout_adopt = __esm({
   "../cli/src/commands/checkout-adopt.ts"() {
@@ -134730,24 +135621,25 @@ var init_checkout_adopt = __esm({
     init_sync_scan();
     init_checkout_store();
     init_checkout();
+    init_export();
     LISTED = 20;
   }
 });
 
 // ../cli/src/commands/checkout.ts
-import { homedir as homedir39 } from "node:os";
-import { lstat as lstat9, mkdir as mkdir4, readFile as readFile5, readdir as readdir8, realpath as realpath12, rmdir as rmdir3, stat as stat8, unlink as unlink13 } from "node:fs/promises";
-import path55 from "node:path";
-import { parseArgs as parseArgs41 } from "node:util";
+import { homedir as homedir40 } from "node:os";
+import { lstat as lstat10, mkdir as mkdir5, readFile as readFile5, readdir as readdir9, realpath as realpath13, rmdir as rmdir3, stat as stat8, unlink as unlink14 } from "node:fs/promises";
+import path56 from "node:path";
+import { parseArgs as parseArgs42 } from "node:util";
 function checkoutDeps(partial2) {
   return {
     stdout: partial2.stdout ?? ((text5) => void process.stdout.write(text5)),
-    auth: partial2.auth ?? defaultHostedAuthDeps(homedir39()),
+    auth: partial2.auth ?? defaultHostedAuthDeps(homedir40()),
     cwd: partial2.cwd ?? process.cwd(),
     ...partial2.fetch ? { fetch: partial2.fetch } : {}
   };
 }
-async function entryKind(target3) {
+async function entryKind2(target3) {
   let info;
   try {
     info = await stat8(target3);
@@ -134756,7 +135648,7 @@ async function entryKind(target3) {
     throw error51;
   }
   if (!info.isDirectory()) return "other";
-  return (await readdir8(target3)).length === 0 ? "empty-dir" : "dir";
+  return (await readdir9(target3)).length === 0 ? "empty-dir" : "dir";
 }
 function bindingView(binding) {
   return {
@@ -134769,11 +135661,11 @@ function bindingView(binding) {
     folder: binding.path
   };
 }
-function nextSteps(folder) {
+function nextSteps2(folder) {
   return [`${cliInvocation()} list --dir ${commandToken(folder)}`, `${cliInvocation()} status --dir ${commandToken(folder)}`];
 }
 async function assertStandaloneFolder(folder) {
-  const parent = path55.dirname(folder);
+  const parent = path56.dirname(folder);
   const enclosing = await findBundleRoot(parent).catch(() => null);
   if (enclosing) {
     throw new CliError("FORBIDDEN", `refusing to check out inside the local bundle at ${enclosing}`, {
@@ -134832,17 +135724,17 @@ function lockFailure2(error51, folder) {
   return error51;
 }
 async function canonicalFolder(folder) {
-  const parent = path55.dirname(folder);
-  await mkdir4(parent, { recursive: true });
+  const parent = path56.dirname(folder);
+  await mkdir5(parent, { recursive: true });
   let link4 = false;
   try {
-    link4 = (await lstat9(folder)).isSymbolicLink();
+    link4 = (await lstat10(folder)).isSymbolicLink();
   } catch (error51) {
     if (error51.code !== "ENOENT") throw error51;
   }
-  if (!link4) return path55.join(await realpath12(parent), path55.basename(folder));
+  if (!link4) return path56.join(await realpath13(parent), path56.basename(folder));
   try {
-    return await realpath12(folder);
+    return await realpath13(folder);
   } catch {
     throw new CliError("USAGE", `the --dir folder ${folder} is a symbolic link to a folder that does not exist`, { help: "pass --dir <the real folder>" });
   }
@@ -134873,25 +135765,25 @@ async function removePlaced(folder, placed, createdFolder) {
   const dirs = /* @__PURE__ */ new Set();
   for (const [file2, digest3] of placed) {
     try {
-      if (digestOf(await readFile5(file2)) === digest3) await unlink13(file2);
+      if (digestOf(await readFile5(file2)) === digest3) await unlink14(file2);
     } catch {
     }
-    for (let dir = path55.dirname(file2); dir !== folder && dir.startsWith(`${folder}${path55.sep}`); dir = path55.dirname(dir)) dirs.add(dir);
+    for (let dir = path56.dirname(file2); dir !== folder && dir.startsWith(`${folder}${path56.sep}`); dir = path56.dirname(dir)) dirs.add(dir);
   }
   for (const dir of [...dirs].sort((a, b) => b.length - a.length)) await rmdir3(dir).catch(() => {
   });
   if (createdFolder) await rmdir3(folder).catch(() => {
   });
-  return await entryKind(folder) !== "dir";
+  return await entryKind2(folder) !== "dir";
 }
 async function release(folderArg, deps2, mode) {
-  const folder = path55.resolve(deps2.cwd, folderArg);
+  const folder = path56.resolve(deps2.cwd, folderArg);
   let canonical2;
   try {
-    canonical2 = (await lstat9(folder)).isSymbolicLink() ? await realpath12(folder) : path55.join(await realpath12(path55.dirname(folder)), path55.basename(folder));
+    canonical2 = (await lstat10(folder)).isSymbolicLink() ? await realpath13(folder) : path56.join(await realpath13(path56.dirname(folder)), path56.basename(folder));
   } catch {
     try {
-      canonical2 = path55.join(await realpath12(path55.dirname(folder)), path55.basename(folder));
+      canonical2 = path56.join(await realpath13(path56.dirname(folder)), path56.basename(folder));
     } catch {
       canonical2 = folder;
     }
@@ -134928,7 +135820,7 @@ async function release(folderArg, deps2, mode) {
 }
 async function checkoutHost(flag, folder, typed, values, home2, env, fetchImpl) {
   if (flag === void 0) {
-    const real = await realpath12(folder).catch(() => null);
+    const real = await realpath13(folder).catch(() => null);
     const bound = real ? await bindingForPath(home2, real).catch(() => null) : null;
     if (bound) return { target: checkoutTarget(bound), workspace: values.workspace, origin: {} };
   }
@@ -134942,7 +135834,7 @@ async function checkoutHost(flag, folder, typed, values, home2, env, fetchImpl)
 async function checkout(argv2, partial2 = {}) {
   const deps2 = checkoutDeps(partial2);
   const { values, positionals } = parseLeafOrUsage(
-    () => parseArgs41({
+    () => parseArgs42({
       args: argv2,
       options: {
         host: { type: "string" },
@@ -134984,21 +135876,21 @@ async function checkout(argv2, partial2 = {}) {
     throw new CliError("USAGE", `'${positionals[0]}' is not a hosted bundle id or <workspace>/<bundle-id>`, { help: `${cliInvocation()} checkout --help` });
   }
   const bundleId2 = typed.bundleId;
-  const folder = path55.resolve(deps2.cwd, values.dir ?? bundleId2);
+  const folder = path56.resolve(deps2.cwd, values.dir ?? bundleId2);
   assertBundleOutsidePrivateState(folder, deps2.auth.home);
   const { target: target3, workspace: workspaceFlag2, origin: hostOrigin } = await checkoutHost(values.host, folder, typed, values, deps2.auth.home, deps2.auth.env, deps2.auth.fetch);
   const prefix = syncRoutePrefix(target3);
   const resume2 = commandFragment`${cliInvocation()} checkout ${commandToken(hostedBundleReferenceText(typed))} --host ${commandToken(hostArgument(target3))} --dir ${commandToken(folder)}${workspaceFlag2 !== void 0 ? commandFragment` --workspace ${commandToken(workspaceFlag2)}` : commandFragment``}${values.json ? commandFragment` --json` : commandFragment``}`;
-  const found = await entryKind(folder);
+  const found = await entryKind2(folder);
   if (found === "other") {
     throw new CliError("ALREADY_EXISTS", `${folder} exists and is not a folder`, { help: "pass --dir <new folder>" });
   }
   if (found === "dir") {
-    const existing = await bindingForPath(deps2.auth.home, await realpath12(folder));
+    const existing = await bindingForPath(deps2.auth.home, await realpath13(folder));
     const sameWorkspace = workspaceFlag2 === void 0 || workspaceFlag2 === existing?.workspace_slug || workspaceFlag2 === existing?.workspace;
     const asked = typed.slug === null && sameWorkspace ? { slug: existing?.workspace_slug ?? null, bundleId: bundleId2 } : typed;
     if (existing && bindsBundle(existing, target3, asked)) {
-      deps2.stdout(render({ checkout: "unchanged", ...bindingView(existing), help: nextSteps(existing.path) }, mode));
+      deps2.stdout(render({ checkout: "unchanged", ...bindingView(existing), help: nextSteps2(existing.path) }, mode));
       return;
     }
     const marker = existing ? null : readCheckoutMarker(folder);
@@ -135009,7 +135901,7 @@ async function checkout(argv2, partial2 = {}) {
     });
   }
   await assertStandaloneFolder(folder);
-  const { identity, reader, listed: listed2, workspace, reference, definitionWrites, documentInputBytes } = await connectHostedBundle(typed, target3, workspaceFlag2, deps2, resume2);
+  const { identity, reader, listed: listed2, workspace, reference, client, definitionWrites, documentInputBytes } = await connectHostedBundle(typed, target3, workspaceFlag2, deps2, resume2, { deadlineMs: EXPORT_DEADLINE_MS });
   const canonical2 = await canonicalFolder(folder);
   let createdFolder = false;
   const placed = /* @__PURE__ */ new Map();
@@ -135021,7 +135913,7 @@ async function checkout(argv2, partial2 = {}) {
         help: "wait for it to finish, then retry the same command"
       });
     }
-    const kind2 = await entryKind(canonical2);
+    const kind2 = await entryKind2(canonical2);
     if (kind2 === "dir" || kind2 === "other") {
       throw new CliError("ALREADY_EXISTS", `${canonical2} is no longer empty`, { details: { reason: "not_empty", folder: canonical2 }, help: "pass --dir <new or empty folder>" });
     }
@@ -135031,7 +135923,7 @@ async function checkout(argv2, partial2 = {}) {
       await releaseCheckout(deps2.auth.home, replaced);
     }
     if (kind2 === "absent") {
-      await mkdir4(canonical2);
+      await mkdir5(canonical2);
       createdFolder = true;
     }
     const identityNow = await folderIdentity(canonical2);
@@ -135066,9 +135958,12 @@ async function checkout(argv2, partial2 = {}) {
       const stored = await store.readHeads({ project: (head) => head.id });
       assertProjectable(stored, bundleId2, target3);
       const exported = await exportFresh(store, canonical2, (file2, digest3) => placed.set(file2, digest3));
-      if (exported.kept.length > 0) {
+      const portable = await exportOrReason({ client: reference.slug === null ? client : client.within(reference.slug), slug: reference.slug, source: { target: target3, bundleId: bundleId2, slug: reference.slug, workspace: workspaceFlag2 ?? null, binding: null }, resume: resume2 });
+      const extras = typeof portable === "string" ? NO_EXTRAS : await placeExtras(portable, canonical2, (file2, digest3) => placed.set(file2, digest3));
+      const kept = [...exported.kept, ...extras.kept];
+      if (kept.length > 0) {
         throw new CliError("CONFLICT", `files appeared in ${canonical2} during checkout`, {
-          details: { reason: "folder_changed", kept: exported.kept.slice(0, 20), kept_total: exported.kept.length },
+          details: { reason: "folder_changed", kept: kept.slice(0, 20), kept_total: kept.length },
           help: "retry the same command once nothing else writes to the folder"
         });
       }
@@ -135079,14 +135974,14 @@ async function checkout(argv2, partial2 = {}) {
         if (id !== ROOT_INDEX && version4) files[id] = { digest: digest3, version: version4 };
       }
       const rootBase = exported.exported[ROOT_INDEX] !== void 0 ? (await store.readReserved("", "index.md"))?.version ?? null : null;
-      await writeProjection(deps2.auth.home, binding.checkout_id, { files, root: exported.exported[ROOT_INDEX] ?? null, rootBase });
+      await writeProjection(deps2.auth.home, binding.checkout_id, { files, root: exported.exported[ROOT_INDEX] ?? null, rootBase, extras: extras.placed });
       const markerFile = await writeCheckoutMarker(canonical2, binding);
       if (markerFile) placed.set(markerFile, digestOf(checkoutMarkerBytes(binding)));
       const ready = { ...binding, state: "ready" };
       await writeBinding(deps2.auth.home, ready);
       await recordPulled(deps2.auth.home, ready.checkout_id);
       await indexCheckoutPath(deps2.auth.home, ready);
-      return { binding: ready, documents: exported.documents, root: exported.root, digest: marker.headsDigest ?? null };
+      return { binding: ready, documents: exported.documents, root: exported.root, unplaced: typeof portable === "string" ? portable : null, reserved: extras.reserved, other: extras.other, digest: marker.headsDigest ?? null };
     } catch (error51) {
       await store?.close().catch(() => {
       });
@@ -135119,22 +136014,96 @@ async function checkout(argv2, partial2 = {}) {
         catalog: cataloged,
         documents: result3.documents,
         root_index: result3.root,
+        ...result3.unplaced === null ? { reserved_files: result3.reserved, other_files: result3.other } : {
+          other_files: `not placed: ${result3.unplaced}, so reserved files below the root and files other than documents stay on the host; superbee export copies them`,
+          warning: "this checkout lacks the host's files other than documents, and sync never brings them: check out again into a new folder to get them"
+        },
         heads_digest: result3.digest,
         ...replacedBinding ? { replaced_stale_checkout: { bundle_id: replacedBinding.bundle_id, host: replacedBinding.origin } } : {},
         mode: "sync",
         refused: REFUSED_SUMMARY,
-        help: nextSteps(result3.binding.path)
+        help: nextSteps2(result3.binding.path)
       },
       mode
     )
   );
 }
-async function connectHostedBundle(typed, target3, workspaceFlag2, deps2, resume2) {
+async function exportOrReason(request3) {
+  try {
+    return await fetchExportThrough(request3);
+  } catch (error51) {
+    if (!(error51 instanceof CliError)) throw error51;
+    if (error51.details?.code === "not_found" && error51.details?.status === 404) return `${request3.source.target.origin} serves no bundle export`;
+    const reason = error51.details?.reason ?? error51.details?.code;
+    return `the bundle export could not be read: ${error51.message.replace(/; nothing was written$/, "")}${typeof reason === "string" ? ` (${reason})` : ""}`;
+  }
+}
+async function adoptedExtras(folder, request3) {
+  const portable = await exportOrReason(request3);
+  if (typeof portable === "string") return { extras: {}, placed: /* @__PURE__ */ new Map(), unplaced: portable };
+  const extras = {};
+  const placed = /* @__PURE__ */ new Map();
+  for (const entry of portable.entries) {
+    if (entry.kind === "document" || entry.path === ROOT_INDEX) continue;
+    const file2 = path56.join(folder, ...entry.path.split("/"));
+    if (await parentUnsafe(folder, file2)) continue;
+    const found = readRegularFileNoFollowSync(file2);
+    if (found.state === "missing") {
+      try {
+        await ensureParentInside(folder, file2);
+      } catch (error51) {
+        if (error51 instanceof UnsafePlacementError) continue;
+        throw error51;
+      }
+      if ((await placeNew(file2, entry.bytes)).placed) {
+        extras[entry.path] = digestOf(entry.bytes);
+        placed.set(file2, digestOf(entry.bytes));
+      }
+      continue;
+    }
+    if (found.state === "present" && Buffer.from(entry.bytes).equals(found.bytes)) extras[entry.path] = digestOf(entry.bytes);
+  }
+  return { extras, placed, unplaced: null };
+}
+async function placeExtras(exported, folder, onPlaced) {
+  const placed = {};
+  const kept = [];
+  let reserved = 0;
+  let other = 0;
+  for (const entry of exported.entries) {
+    if (entry.kind === "document" || entry.path === ROOT_INDEX) continue;
+    const file2 = path56.join(folder, ...entry.path.split("/"));
+    try {
+      await ensureParentInside(folder, file2);
+    } catch (error51) {
+      if (!(error51 instanceof UnsafePlacementError)) throw error51;
+      kept.push(entry.path);
+      continue;
+    }
+    const outcome = await placeNew(file2, entry.bytes);
+    if (!outcome.placed) {
+      kept.push(entry.path);
+      continue;
+    }
+    const digest3 = digestOf(entry.bytes);
+    onPlaced(file2, digest3);
+    placed[entry.path] = digest3;
+    if (entry.kind === "reserved") reserved += 1;
+    else other += 1;
+  }
+  return { placed, reserved, other, kept };
+}
+async function connectHostedBundle(typed, target3, workspaceFlag2, deps2, resume2, options = {}) {
   const { bundleId: bundleId2 } = typed;
   const command = (named) => `${cliInvocation()} checkout ${commandToken(named)} --host ${commandToken(hostArgument(target3))}`;
   const account = await connectHostedAccount(
     target3,
-    { workspace: workspaceFlag2, resume: resume2, otherWorkspace: `${command(hostedBundleReferenceText(typed))} --workspace <id>` },
+    {
+      workspace: workspaceFlag2,
+      resume: resume2,
+      otherWorkspace: `${command(hostedBundleReferenceText(typed))} --workspace <id>`,
+      ...options.deadlineMs !== void 0 ? { deadlineMs: options.deadlineMs } : {}
+    },
     deps2
   );
   const { client, identity, workspace } = account;
@@ -135218,7 +136187,7 @@ function assertProjectable(ids, bundleId2, target3) {
     });
   }
 }
-var CHECKOUT_DOCUMENT_LIMIT, CHECKOUT_USAGE, REFUSED_SUMMARY;
+var CHECKOUT_DOCUMENT_LIMIT, CHECKOUT_USAGE, NO_EXTRAS, REFUSED_SUMMARY;
 var init_checkout = __esm({
   "../cli/src/commands/checkout.ts"() {
     "use strict";
@@ -135236,6 +136205,7 @@ var init_checkout = __esm({
     init_invocation();
     init_output2();
     init_private_state_bundle_boundary();
+    init_nofollow_read();
     init_session();
     init_account();
     init_freshness2();
@@ -135247,6 +136217,7 @@ var init_checkout = __esm({
     init_catalog();
     init_marker();
     init_checkout_adopt();
+    init_export();
     init_reference();
     CHECKOUT_DOCUMENT_LIMIT = 1e4;
     CHECKOUT_USAGE = `superbee checkout \u2014 mirror a hosted bundle into a local folder
@@ -135262,8 +136233,11 @@ hosted bundle into --dir (default: ./<bundle-id>), which must be new or empty. T
 else, for a folder that is already a checkout, its own host, else the host of your last sign-in
 when it is the only host you are signed in to (never SUPERBEE_HOST alone); signed in to more than
 one host, a checkout without --host is refused and names them. The receipt names the host it
-bound. The folder holds plain bundle files, so every command runs on it with --dir <folder>. The
-link to the host is kept in private state, keyed by the folder's path, never in the folder.
+bound. The folder holds plain bundle files, so every command runs on it with --dir <folder>: the
+same files 'superbee export' writes (documents, every index.md and log.md, and other files such as
+data/*.json), with the bytes the host stores. Sync sends documents only; it leaves the other files
+be while they are as placed. The link to the host is kept in private state, keyed by the folder's
+path, never in the folder.
 Re-running for the same folder and bundle is a no-op. A checkout whose folder was deleted, or
 replaced by a new empty folder, is replaced, unless it holds changes sync has not sent yet; a
 checkout emptied in place is refused, because removing every file is a pending edit.
@@ -135321,6 +136295,7 @@ Examples:
   superbee checkout --adopt ~/restored/team --host https://mcp.getsuperbee.com
   superbee checkout --release ~/work/team
 `;
+    NO_EXTRAS = Object.freeze({ placed: {}, reserved: 0, other: 0, kept: [] });
     REFUSED_SUMMARY = Object.freeze(
       HOSTED_CHECKOUT_REFUSALS.filter((row4) => row4.reason !== "checkout_target").map((row4) => {
         const words = row4.words.join(" ");
@@ -135330,800 +136305,6 @@ Examples:
   }
 });
 
-// ../cli/src/commands/export.ts
-import { randomBytes as randomBytes9 } from "node:crypto";
-import { homedir as homedir40 } from "node:os";
-import { link as link3, lstat as lstat10, mkdir as mkdir5, open as open4, readdir as readdir9, realpath as realpath13, rename as rename2, rm as rm2, unlink as unlink14 } from "node:fs/promises";
-import path56 from "node:path";
-import { parseArgs as parseArgs42 } from "node:util";
-function exportDeps(partial2) {
-  return {
-    stdout: partial2.stdout ?? ((text5) => void process.stdout.write(text5)),
-    auth: partial2.auth ?? defaultHostedAuthDeps(homedir40()),
-    cwd: partial2.cwd ?? process.cwd(),
-    ...partial2.fetch ? { fetch: partial2.fetch } : {}
-  };
-}
-async function entryKind2(target3) {
-  let info;
-  try {
-    info = await lstat10(target3);
-  } catch (error51) {
-    if (error51.code === "ENOENT") return "absent";
-    throw error51;
-  }
-  if (!info.isDirectory()) return "other";
-  return (await readdir9(target3)).length === 0 ? "empty-dir" : "dir";
-}
-function shown(paths) {
-  return [...paths].sort().slice(0, SHOWN);
-}
-function refusalCode(body) {
-  const error51 = body?.error;
-  if (typeof error51 === "string") return error51;
-  const code3 = error51?.code;
-  return typeof code3 === "string" ? code3 : void 0;
-}
-async function namedClient(source, deps2, resume2) {
-  const { target: target3 } = source;
-  const account = await connectHostedAccount(target3, { ...source.workspace !== null ? { workspace: source.workspace } : {}, resume: resume2, deadlineMs: EXPORT_DEADLINE_MS }, deps2);
-  const { reference } = resolveBundleReference(
-    { slug: source.slug, bundleId: source.bundleId },
-    account,
-    target3,
-    (named) => `${cliInvocation()} export ${commandToken(named)} --host ${commandToken(hostArgument(target3))} --to <folder>`
-  );
-  return { client: reference.slug === null ? account.client : account.client.within(reference.slug), slug: reference.slug };
-}
-async function fetchExport(source, deps2, resume2) {
-  const { bundleId: bundleId2, target: target3 } = source;
-  const named = source.binding ? null : await namedClient(source, deps2, resume2);
-  const client = named ? named.client : (await connectCheckout(source.binding, { resume: resume2, deadlineMs: EXPORT_DEADLINE_MS }, deps2)).client;
-  const slug = named ? named.slug : source.binding.workspace_slug ?? null;
-  const request3 = { client, slug, source, resume: resume2 };
-  for (let attempt = 1; ; attempt += 1) {
-    const chain = new ExportPageChain();
-    let bytes = 0;
-    let cursor;
-    let moved = false;
-    for (; ; ) {
-      let page;
-      for (let tries = 1; page === void 0; tries += 1) {
-        const answer2 = await exportAnswer(request3, { bundleId: bundleId2, paged: true, ...cursor !== void 0 ? { cursor } : {} });
-        if (answer2.refused === "invalid_input" && cursor === void 0 && attempt === 1) return verified(await readArchive(await wholeAnswer(request3), source, MAX_EXPORT_BYTES), source);
-        if (answer2.refused === "concurrent_change") {
-          moved = true;
-          break;
-        }
-        try {
-          if (answer2.refused !== void 0) throw await exportRefusal(request3, answer2.refused, answer2.status);
-          page = verified(await readArchive(answer2.ok, source, MAX_EXPORT_BYTES - bytes), source, { paged: true });
-        } catch (error51) {
-          const again = error51 instanceof CliError && (error51.details?.reason === "export_incomplete" || answer2.refused === "backend_unavailable" && error51.code === "TRANSIENT");
-          if (!again || tries >= 2) throw error51;
-          await pause2(PAGE_RETRY_MS);
-        }
-      }
-      if (moved) break;
-      bytes += page.bytes;
-      cursor = joining(source, () => chain.add(page));
-      if (cursor === void 0) return joining(source, () => chain.joined());
-    }
-    if (attempt >= PAGED_EXPORT_ATTEMPTS) {
-      throw new CliError("TRANSIENT", `'${bundleId2}' kept changing on ${target3.origin} while it was exported; nothing was written`, {
-        details: { reason: "export_source_changed", bundle_id: bundleId2, host: target3.origin, retryable: true },
-        help: "retry the same command once the bundle is not being edited"
-      });
-    }
-    const base = PAGED_EXPORT_RESTART_MS[attempt - 1];
-    await pause2(Math.round(base / 2 + Math.random() * base / 2));
-  }
-}
-async function exportAnswer({ client, source, resume: resume2 }, input) {
-  let answer2;
-  try {
-    answer2 = await client.carrier.stream(`${client.prefix}/export`, input, client.signal);
-  } catch (error51) {
-    throw hostedFailure(error51, source.target, resume2);
-  }
-  if (!answer2.ok) return { refused: refusalCode(answer2.body) ?? "RUNTIME", status: answer2.status };
-  return { ok: answer2.body };
-}
-async function wholeAnswer(request3) {
-  const answer2 = await exportAnswer(request3, { bundleId: request3.source.bundleId });
-  if (answer2.refused !== void 0) throw await exportRefusal(request3, answer2.refused, answer2.status);
-  return answer2.ok;
-}
-function exportTooLarge(source) {
-  return new CliError("RUNTIME", `${source.target.origin} answered an export larger than ${MAX_EXPORT_BYTES} bytes`, {
-    details: { reason: "export_too_large", host: source.target.origin, bundle_id: source.bundleId, retryable: false, next: "the person exports it with Export bundle in the Superbee app" },
-    help: `${cliInvocation()} whoami --host ${commandToken(hostArgument(source.target))}`
-  });
-}
-async function exportRefusal({ client, slug, source, resume: resume2 }, code3, status2) {
-  const { target: target3, bundleId: bundleId2 } = source;
-  if (code3 === "bundle_not_found") {
-    if (source.binding) return await bundleAbsent(source.binding, client);
-    const text5 = hostedBundleReferenceText({ slug, bundleId: bundleId2 });
-    return new CliError("NOT_FOUND", `no hosted bundle '${text5}' is visible to you on ${target3.origin}`, {
-      details: { bundle_id: bundleId2, ...slug !== null ? { reference: text5 } : {}, host: target3.origin },
-      help: hostedListCommand(target3)
-    });
-  }
-  if (code3 === "result_too_large") {
-    return new CliError("FORBIDDEN", `hosted bundle '${bundleId2}' is larger than an export carries`, {
-      details: { reason: "bundle_too_large", bundle_id: bundleId2, host: target3.origin, next: "the person exports it with Export bundle in the Superbee app" },
-      help: `${cliInvocation()} whoami --host ${commandToken(hostArgument(target3))}`
-    });
-  }
-  if (code3 === "validation_failed") {
-    return new CliError("FORBIDDEN", `hosted bundle '${bundleId2}' holds a path an export cannot carry`, {
-      details: { reason: "unexportable_path", bundle_id: bundleId2, host: target3.origin, next: "the person renames the document or file in the Superbee app, then the same command is retried" },
-      help: `${cliInvocation()} whoami --host ${commandToken(hostArgument(target3))}`
-    });
-  }
-  return hostedFailure(new RemoteError(`hosted export answered ${status2}`, code3, status2), target3, resume2);
-}
-async function readArchive(body, source, budget) {
-  const { target: target3, bundleId: bundleId2 } = source;
-  const reader = body.getReader();
-  const chunks = [];
-  let size = 0;
-  try {
-    for (; ; ) {
-      const part = await reader.read();
-      if (part.done) break;
-      size += part.value.byteLength;
-      if (size > budget) throw exportTooLarge(source);
-      chunks.push(part.value);
-    }
-  } catch (error51) {
-    if (error51 instanceof CliError) throw error51;
-    throw new CliError("TRANSIENT", `the export of '${bundleId2}' from ${target3.origin} stopped part way; nothing was written`, {
-      details: { reason: "export_incomplete", bundle_id: bundleId2, host: target3.origin, retryable: true },
-      help: "retry the same command"
-    });
-  } finally {
-    void reader.cancel().catch(() => {
-    });
-  }
-  const archive = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) {
-    archive.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return archive;
-}
-function verified(archive, source, options = {}) {
-  return refusingArchive(source, () => verifyExport(archive, source.bundleId, options));
-}
-function joining(source, join19) {
-  return refusingArchive(source, join19);
-}
-function refusingArchive(source, verify) {
-  try {
-    return verify();
-  } catch (error51) {
-    if (!(error51 instanceof ExportArchiveError)) throw error51;
-    if (error51.problem === "incomplete") {
-      throw new CliError("TRANSIENT", `the export of '${source.bundleId}' was not completed by the host; nothing was written`, {
-        details: { reason: "export_incomplete", bundle_id: source.bundleId, host: source.target.origin, retryable: true },
-        help: "retry the same command"
-      });
-    }
-    throw new CliError("RUNTIME", `${source.target.origin} answered an export this CLI refuses (${error51.message}); nothing was written`, {
-      details: { reason: `export_${error51.problem}`, bundle_id: source.bundleId, host: source.target.origin, retryable: false },
-      help: "upgrade Superbee (npm install -g superbee); if it persists, report this bundle and reason"
-    });
-  }
-}
-async function writeNewFile(file2, bytes) {
-  const handle = await open4(file2, "wx", 420);
-  try {
-    await handle.writeFile(bytes);
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-}
-async function writeEntries(root, entries) {
-  for (const entry of entries) {
-    const file2 = path56.join(root, ...entry.path.split("/"));
-    await mkdir5(path56.dirname(file2), { recursive: true });
-    await writeNewFile(file2, entry.bytes);
-  }
-}
-function gitRun(dir, args) {
-  let result3;
-  try {
-    result3 = runGit(dir, args);
-  } catch (error51) {
-    const missing2 = error51.code === "GIT_MISSING";
-    throw new CliError(missing2 ? "GIT_MISSING" : "RUNTIME", `git could not run (${error51 instanceof Error ? error51.message : String(error51)})`, {
-      details: { reason: missing2 ? "git_missing" : "git_unavailable" },
-      help: "install git, or export without --git"
-    });
-  }
-  if (result3.status !== 0) {
-    throw new CliError("RUNTIME", `git ${args.find((arg) => !arg.startsWith("-") && !arg.includes("=")) ?? ""} failed: ${result3.stderr.trim().split("\n").at(-1) ?? ""}`, {
-      details: { reason: "git_failed" },
-      help: "fix the git error, then retry the same command"
-    });
-  }
-  return result3.stdout.trim();
-}
-function commitExport(dir, message, options) {
-  const quiet = ["-c", "core.hooksPath=/dev/null"];
-  gitRun(dir, [...quiet, "init", "-q"]);
-  gitRun(dir, ["symbolic-ref", "HEAD", `refs/heads/${BOARD_BRANCH}`]);
-  const excluded = ["--", ".", `:(exclude)${IN_PLACE_STAGING}`, `:(exclude)${CHECKOUT_MARKER_DIR}`];
-  gitRun(dir, ["add", "-A", ...options.force ? ["--force"] : [], ...excluded]);
-  gitRun(dir, [...quiet, ...identityFlags(dir), "-c", "commit.gpgsign=false", "commit", "-q", "--no-verify", "--allow-empty", "-m", message]);
-  const committed = { branch: BOARD_BRANCH, commit: gitRun(dir, ["rev-parse", "HEAD"]) };
-  if (options.force) return committed;
-  const ignored = gitRun(dir, ["ls-files", "--others", "--ignored", "--exclude-standard", ...excluded]).split("\n").filter(Boolean);
-  return ignored.length === 0 ? committed : { ...committed, ignored: { count: ignored.length, paths: shown(ignored) } };
-}
-function commitMessage(source, exported) {
-  return `Export ${source.bundleId} from ${source.target.origin} at revision ${exported.source.revision}
-
-superbee export, ${exported.exportedAt}: ${exported.counts.documents} documents, ${exported.counts.reserved} reserved files, ${exported.counts.blobs} blobs. History is not included.
-`;
-}
-function stagingName(target3) {
-  return path56.join(path56.dirname(target3), `.${path56.basename(target3)}.superbee-export-${process.pid}-${randomBytes9(6).toString("hex")}.partial`);
-}
-function processAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error51) {
-    return error51.code === "EPERM";
-  }
-}
-async function removeAbandonedStaging(target3) {
-  const prefix = `.${path56.basename(target3)}.superbee-export-`;
-  let removed = 0;
-  let names;
-  try {
-    names = await readdir9(path56.dirname(target3));
-  } catch {
-    return 0;
-  }
-  for (const name of names) {
-    if (!name.startsWith(prefix)) continue;
-    const match = /^(\d+)-[0-9a-f]{12}\.partial$/.exec(name.slice(prefix.length));
-    if (!match) continue;
-    const age = await lstat10(path56.join(path56.dirname(target3), name)).then((info) => Date.now() - info.mtimeMs, () => 0);
-    if (processAlive(Number(match[1])) && age < ABANDONED_AFTER_MS) continue;
-    await rm2(path56.join(path56.dirname(target3), name), { recursive: true, force: true });
-    removed += 1;
-  }
-  return removed;
-}
-async function assertStandalone(target3, home2) {
-  const parent = path56.dirname(target3);
-  const help2 = "pass --to <folder> outside any bundle, board or checkout";
-  const checkout2 = await hostedCheckoutAt(parent, home2);
-  if (checkout2) {
-    throw new CliError("FORBIDDEN", `refusing to export inside the hosted checkout at ${checkout2.path}`, { details: { reason: "inside_checkout", enclosing: checkout2.path }, help: help2 });
-  }
-  const enclosing = await findBundleRoot(parent).catch(() => null);
-  if (enclosing) {
-    throw new CliError("FORBIDDEN", `refusing to export inside the local bundle at ${enclosing}`, { details: { reason: "inside_bundle", enclosing }, help: help2 });
-  }
-  const binding = await resolveProjectBinding(parent).catch(() => null);
-  if (binding) {
-    throw new CliError("FORBIDDEN", `refusing to export inside a project bound to a board (${binding.file})`, { details: { reason: "inside_bound_project", binding: binding.file }, help: help2 });
-  }
-}
-async function exportToFolder(source, toArg, git2, deps2, mode, resume2) {
-  const requested = path56.resolve(deps2.cwd, toArg);
-  assertBundleOutsidePrivateState(requested, deps2.auth.home);
-  const found = await entryKind2(requested);
-  if (found === "other") throw new CliError("ALREADY_EXISTS", `${requested} exists and is not a folder`, { details: { reason: "not_a_folder", folder: requested }, help: "pass --to <new folder>" });
-  if (found === "dir") throw new CliError("ALREADY_EXISTS", `${requested} is not empty`, { details: { reason: "not_empty", folder: requested }, help: "pass --to <new or empty folder>" });
-  await mkdir5(path56.dirname(requested), { recursive: true });
-  const target3 = path56.join(await realpath13(path56.dirname(requested)), path56.basename(requested));
-  assertBundleOutsidePrivateState(target3, deps2.auth.home);
-  await assertStandalone(target3, deps2.auth.home);
-  const exported = await fetchExport(source, deps2, resume2);
-  const abandoned = await removeAbandonedStaging(target3);
-  const staging = stagingName(target3);
-  await mkdir5(staging);
-  let gitResult = null;
-  try {
-    await writeEntries(staging, exported.entries);
-    if (git2) gitResult = commitExport(staging, commitMessage(source, exported), { force: true });
-    const now = await entryKind2(target3);
-    if (now === "dir" || now === "other") throw new CliError("ALREADY_EXISTS", `${target3} is no longer empty`, { details: { reason: "not_empty", folder: target3 }, help: "pass --to <new or empty folder>" });
-    try {
-      await rename2(staging, target3);
-    } catch (error51) {
-      const code3 = error51.code;
-      if (code3 === "ENOTEMPTY" || code3 === "EEXIST" || code3 === "ENOTDIR") {
-        throw new CliError("ALREADY_EXISTS", `${target3} is no longer empty`, { details: { reason: "not_empty", folder: target3 }, help: "pass --to <new or empty folder>" });
-      }
-      throw error51;
-    }
-  } catch (error51) {
-    await rm2(staging, { recursive: true, force: true }).catch(() => {
-    });
-    throw error51;
-  }
-  const home2 = await bundleHomeAt(target3, { home: deps2.auth.home });
-  deps2.stdout(
-    render(
-      {
-        export: "created",
-        folder: target3,
-        home: home2.home,
-        bundle_id: source.bundleId,
-        host: source.target.origin,
-        revision: exported.source.revision,
-        exported_at: exported.exportedAt,
-        okf_edition: exported.source.okfEdition,
-        documents: exported.counts.documents,
-        reserved: exported.counts.reserved,
-        blobs: exported.counts.blobs,
-        bytes: exported.bytes,
-        root_index: exported.entries.some((entry) => entry.path === "index.md"),
-        ...gitResult ? { git: gitResult } : {},
-        ...abandoned > 0 ? { removed_abandoned_exports: abandoned } : {},
-        hosted: HOSTED_UNCHANGED,
-        history: NO_HISTORY,
-        help: nextSteps2(target3, gitResult !== null)
-      },
-      mode
-    )
-  );
-}
-function nextSteps2(folder, git2) {
-  const steps = [commandFragment`${cliInvocation()} status --dir ${commandToken(folder)}`];
-  if (git2) steps.push(commandFragment`git -C ${commandToken(folder)} remote add origin <url> && ${cliInvocation()} sync --establish --dir ${commandToken(folder)}`);
-  return steps;
-}
-function isJournal(value) {
-  const record6 = value;
-  return record6 !== null && typeof record6 === "object" && record6.schema === JOURNAL_SCHEMA && typeof record6.bundle_id === "string" && typeof record6.host === "string" && typeof record6.audience === "string" && Number.isSafeInteger(record6.revision) && typeof record6.exported_at === "string" && typeof record6.git === "boolean" && Array.isArray(record6.adds) && record6.adds.every((entry) => typeof entry === "string") && Number.isSafeInteger(record6.same) && Array.isArray(record6.kept_local) && record6.kept_local.every((entry) => typeof entry === "string") && Array.isArray(record6.deleted_locally) && record6.deleted_locally.every((entry) => typeof entry === "string") && Number.isSafeInteger(record6.unsent_kept);
-}
-async function stagingDir(folder) {
-  const staging = path56.join(folder, IN_PLACE_STAGING);
-  try {
-    if (!(await lstat10(staging)).isDirectory()) return null;
-    return await realpath13(staging) === path56.join(await realpath13(folder), IN_PLACE_STAGING) ? staging : null;
-  } catch {
-    return null;
-  }
-}
-async function readJournal(folder) {
-  const staging = await stagingDir(folder);
-  if (!staging) return null;
-  let journal;
-  const read = readRegularFileNoFollowSync(path56.join(staging, JOURNAL));
-  if (read.state !== "present" || read.bytes.byteLength > MAX_JOURNAL_BYTES) return null;
-  try {
-    const value = JSON.parse(read.bytes.toString("utf8"));
-    if (!isJournal(value)) return null;
-    journal = value;
-  } catch {
-    return null;
-  }
-  const marker = readCheckoutMarker(folder);
-  if (!marker || marker.bundle_id !== journal.bundle_id || marker.host !== bindingHostArgument({ origin: journal.host, audience: journal.audience })) return null;
-  return journal;
-}
-async function sameBytes(file2, bytes) {
-  const read = readRegularFileNoFollowSync(file2);
-  return read.state === "present" && Buffer.compare(read.bytes, Buffer.from(bytes)) === 0;
-}
-async function placementOf(folder, entry) {
-  let info;
-  try {
-    info = await lstat10(path56.join(folder, ...entry.path.split("/")));
-  } catch (error51) {
-    const code3 = error51.code;
-    if (code3 === "ENOENT") return "add";
-    if (code3 === "ENOTDIR") return "kept";
-    throw error51;
-  }
-  if (!info.isFile()) return "kept";
-  return await sameBytes(path56.join(folder, ...entry.path.split("/")), entry.bytes) ? "same" : "kept";
-}
-async function placeStaged(folder, staging, relative2) {
-  const final = path56.join(folder, ...relative2.split("/"));
-  const staged = path56.join(staging, "files", ...relative2.split("/"));
-  try {
-    if ((await lstat10(staged)).isFile()) {
-      const stagedParent = await realpath13(path56.dirname(staged));
-      if (!stagedParent.startsWith(`${await realpath13(staging)}${path56.sep}`)) return "kept";
-    } else return "kept";
-  } catch (error51) {
-    if (error51.code !== "ENOENT") return "kept";
-    return await lstat10(final).then((info) => info.isFile(), () => false) ? "same" : "kept";
-  }
-  try {
-    await mkdir5(path56.dirname(final), { recursive: true });
-    const parent = await realpath13(path56.dirname(final));
-    if (parent !== folder && !parent.startsWith(`${folder}${path56.sep}`)) return "kept";
-  } catch {
-    return "kept";
-  }
-  let outcome;
-  try {
-    await link3(staged, final);
-    outcome = "added";
-  } catch (error51) {
-    const code3 = error51.code;
-    if (code3 !== "EEXIST") throw error51;
-    const stagedRead = readRegularFileNoFollowSync(staged);
-    outcome = stagedRead.state === "present" && await sameBytes(final, stagedRead.bytes) ? "same" : "kept";
-  }
-  await unlink14(staged).catch(() => {
-  });
-  return outcome;
-}
-async function writeJournal(staging, journal) {
-  const temp = path56.join(staging, `.${JOURNAL}.${randomBytes9(6).toString("hex")}.tmp`);
-  await writeNewFile(temp, Buffer.from(`${JSON.stringify(journal)}
-`, "utf8"));
-  await rename2(temp, path56.join(staging, JOURNAL));
-}
-async function finishInPlace(folder, journal) {
-  const staging = await stagingDir(folder);
-  if (!staging) throw new CliError("RUNTIME", `the in-place export's staging folder in ${folder} is gone`, { help: `${cliInvocation()} export --in-place --dir ${commandToken(folder)}` });
-  const added = [];
-  const kept = [...journal.kept_local];
-  let same = journal.same;
-  for (const relative2 of journal.adds) {
-    classifyEntryPath(relative2);
-    const outcome = await placeStaged(folder, staging, relative2);
-    if (outcome === "added") added.push(relative2);
-    else if (outcome === "same") same += 1;
-    else kept.push(relative2);
-  }
-  let git2 = null;
-  if (journal.git) {
-    git2 = await ownCommit(folder) ?? commitExport(folder, `Export ${journal.bundle_id} from ${journal.host} at revision ${journal.revision}
-
-superbee export --in-place, ${journal.exported_at}. History is not included.
-`, { force: false });
-  }
-  await rm2(path56.join(staging, "files"), { recursive: true, force: true });
-  await unlink14(path56.join(staging, JOURNAL)).catch(() => {
-  });
-  await rm2(staging, { recursive: true, force: true });
-  const marker = await removeCheckoutMarker(folder, { origin: journal.host, audience: journal.audience, bundle_id: journal.bundle_id }).catch(() => false) ? "removed" : "none";
-  return { added, kept, same, git: git2, marker };
-}
-function inPlaceReceipt(folder, journal, finished, homeName, resumed) {
-  return {
-    export: "converted",
-    folder,
-    home: homeName,
-    bundle_id: journal.bundle_id,
-    host: journal.host,
-    revision: journal.revision,
-    exported_at: journal.exported_at,
-    ...resumed ? { resumed: true } : {},
-    binding: "removed (the folder is no longer a hosted checkout)",
-    marker: finished.marker,
-    added: finished.added.length,
-    ...finished.added.length > 0 ? { added_paths: shown(finished.added) } : {},
-    unchanged: finished.same,
-    kept_local: finished.kept.length,
-    ...finished.kept.length > 0 ? { kept_local_paths: shown(finished.kept), kept_local_note: "these files differ from the host's (or block its path); the folder's own were kept" } : {},
-    ...journal.deleted_locally.length > 0 ? { deleted_locally: journal.deleted_locally.length, deleted_locally_paths: shown(journal.deleted_locally), deleted_locally_note: "deleted in this folder and not sent; the host's copies were not put back" } : {},
-    ...journal.unsent_kept > 0 ? { unsent_kept: journal.unsent_kept, unsent_note: "changes sync had not sent stay in this folder only" } : {},
-    ...finished.git ? { git: finished.git } : {},
-    hosted: HOSTED_UNCHANGED,
-    history: NO_HISTORY,
-    help: nextSteps2(folder, finished.git !== null)
-  };
-}
-async function ownCommit(folder) {
-  const head = runGit(folder, ["rev-parse", "--verify", "--quiet", "HEAD"]);
-  const top = runGit(folder, ["rev-parse", "--show-toplevel"]);
-  const own5 = top.status === 0 && await realpath13(top.stdout.trim()).catch(() => "") === await realpath13(folder).catch(() => folder);
-  if (!own5 || head.status !== 0) return null;
-  return { branch: runGit(folder, ["symbolic-ref", "-q", "--short", "HEAD"]).stdout.trim() || BOARD_BRANCH, commit: head.stdout.trim() };
-}
-async function assertNoRepository(folder) {
-  if (await lstat10(path56.join(folder, ".git")).then(() => true, () => false)) {
-    throw new CliError("ALREADY_EXISTS", `${folder} already holds a Git repository`, {
-      details: { reason: "already_git", folder },
-      help: `${cliInvocation()} export --in-place --dir ${commandToken(folder)}`
-    });
-  }
-}
-async function exportInPlace(dirArg, git2, keepUnsent, deps2, mode, resume2) {
-  const requested = path56.resolve(deps2.cwd, dirArg ?? ".");
-  assertBundleOutsidePrivateState(requested, deps2.auth.home);
-  const binding = await hostedCheckoutFor(dirArg === void 0 ? [] : ["--dir", dirArg], deps2.auth.home, deps2.cwd);
-  if (!binding) {
-    const folder2 = await realpath13(requested).catch(() => requested);
-    const journal = await readJournal(folder2);
-    if (journal) {
-      const finished = await finishInPlace(folder2, journal);
-      const home4 = await bundleHomeAt(folder2, { home: deps2.auth.home });
-      deps2.stdout(render(inPlaceReceipt(folder2, journal, finished, home4.home, true), mode));
-      return;
-    }
-    if (await entryKind2(folder2) === "absent") throw new CliError("NOT_FOUND", `${folder2} does not exist`, { help: `${cliInvocation()} export --in-place --dir <checkout folder>` });
-    const marker = readCheckoutMarker(folder2);
-    if (marker) {
-      const existing = git2 ? await ownCommit(folder2) : null;
-      if (git2 && !existing) await assertNoRepository(folder2);
-      const staging = await stagingDir(folder2);
-      if (staging && !await lstat10(path56.join(staging, JOURNAL)).then(() => true, () => false)) await rm2(staging, { recursive: true, force: true });
-      await removeCheckoutMarker(folder2, { origin: marker.host, audience: `${marker.host}/mcp`, bundle_id: marker.bundle_id });
-      const committed = existing ?? (git2 ? commitExport(folder2, `Export ${marker.bundle_id} (an unbound copy of a hosted checkout)
-
-superbee export --in-place. Nothing was fetched from the host; history is not included.
-`, { force: false }) : null);
-      const home4 = await bundleHomeAt(folder2, { home: deps2.auth.home });
-      deps2.stdout(
-        render(
-          {
-            export: "converted",
-            folder: folder2,
-            home: home4.home,
-            bundle_id: marker.bundle_id,
-            from: "an unbound copy of a hosted checkout",
-            marker: "removed",
-            fetched: false,
-            note: `nothing was fetched: the files are kept as they are. To fill in what the copy lacks from the host first, adopt it (${cliInvocation()} checkout --adopt <folder> --host <url>), then export --in-place`,
-            ...committed ? { git: committed } : {},
-            hosted: HOSTED_UNCHANGED,
-            history: NO_HISTORY,
-            help: nextSteps2(folder2, committed !== null)
-          },
-          mode
-        )
-      );
-      return;
-    }
-    const home3 = await bundleHomeAt(folder2, { home: deps2.auth.home });
-    deps2.stdout(render({ export: "unchanged", folder: folder2, home: home3.home, reason: "not a hosted checkout: nothing to convert" }, mode));
-    return;
-  }
-  const folder = binding.path;
-  if (git2) await assertNoRepository(folder);
-  const status2 = await hostedStatus(binding, deps2.auth.home);
-  if (status2.sync.state === "busy") {
-    throw new CliError("CONFLICT", `another command holds the checkout lock for ${folder}`, { details: { reason: "checkout_busy", folder }, help: "wait for it to finish, then retry the same command" });
-  }
-  const unsentRefusal = (count5, sync3) => new CliError("CONFLICT", `the checkout of '${binding.bundle_id}' at ${folder} has ${count5} change(s) not on the host`, {
-    details: {
-      reason: "unsent_changes",
-      folder,
-      ...sync3,
-      keep_them_here_only: commandFragment`${cliInvocation()} export --in-place --dir ${commandToken(folder)} --keep-unsent${git2 ? commandFragment` --git` : commandFragment``}`
-    },
-    help: commandFragment`${cliInvocation()} sync --dir ${commandToken(folder)}`
-  });
-  const early = Number(status2.sync.unsent ?? 0) + Number(status2.sync.conflicts ?? 0) + Number(status2.sync.held_files ?? 0) + Number(status2.sync.held_deletions ?? 0);
-  if (early > 0 && !keepUnsent) throw unsentRefusal(early, status2.sync);
-  const source = { target: resolveHostedTarget(binding.audience), bundleId: binding.bundle_id, slug: binding.workspace_slug ?? null, workspace: null, binding };
-  const exported = await fetchExport(source, deps2, resume2);
-  const result3 = await filesystemPushRoleLocks().request(checkoutLockName(folder), { ifAvailable: true }, async (lock) => {
-    if (!lock) {
-      throw new CliError("CONFLICT", `another command holds the checkout lock for ${folder}`, { details: { reason: "checkout_busy", folder }, help: "wait for it to finish, then retry the same command" });
-    }
-    const current = await bindingForPath(deps2.auth.home, folder);
-    if (!current || current.checkout_id !== binding.checkout_id) {
-      throw new CliError("CONFLICT", `the checkout at ${folder} changed while it was exported`, { details: { reason: "checkout_changed", folder }, help: "retry the same command" });
-    }
-    const store = await FileJournaledBackend.open({ directory: checkoutStoreDir(deps2.auth.home, binding.checkout_id), readOnly: true });
-    let pending;
-    try {
-      const classified = await classifyCheckout(binding, deps2.auth.home, store);
-      pending = /* @__PURE__ */ new Set([...classified.unsent, ...classified.conflicts, ...classified.held.keys(), ...classified.heldDeletions]);
-    } finally {
-      await store.close();
-    }
-    if (pending.size > 0 && !keepUnsent) throw unsentRefusal(pending.size, { unsent_ids: shown([...pending]) });
-    const staging = path56.join(folder, IN_PLACE_STAGING);
-    await rm2(staging, { recursive: true, force: true });
-    await mkdir5(path56.join(staging, "files"), { recursive: true });
-    const adds = [];
-    const kept = [];
-    const deletedLocally = [];
-    let same = 0;
-    for (const entry of exported.entries) {
-      const id = entry.kind === "document" ? entry.path.slice(0, -3) : entry.path;
-      const placement = await placementOf(folder, entry);
-      if (placement === "add" && pending.has(id)) {
-        deletedLocally.push(entry.path);
-        continue;
-      }
-      if (placement === "same") same += 1;
-      else if (placement === "kept") kept.push(entry.path);
-      else {
-        const file2 = path56.join(staging, "files", ...entry.path.split("/"));
-        await mkdir5(path56.dirname(file2), { recursive: true });
-        await writeNewFile(file2, entry.bytes);
-        adds.push(entry.path);
-      }
-    }
-    const journal = {
-      schema: JOURNAL_SCHEMA,
-      bundle_id: binding.bundle_id,
-      host: binding.origin,
-      audience: binding.audience,
-      revision: exported.source.revision,
-      exported_at: exported.exportedAt,
-      git: git2,
-      adds,
-      same,
-      kept_local: kept,
-      deleted_locally: deletedLocally,
-      unsent_kept: pending.size
-    };
-    await writeJournal(staging, journal);
-    await releaseCheckout(deps2.auth.home, binding);
-    return { journal, finished: await finishInPlace(folder, journal) };
-  });
-  const home2 = await bundleHomeAt(folder, { home: deps2.auth.home });
-  deps2.stdout(render(inPlaceReceipt(folder, result3.journal, result3.finished, home2.home, false), mode));
-}
-async function exportCommand(argv2, partial2 = {}) {
-  const deps2 = exportDeps(partial2);
-  const { values, positionals } = parseLeafOrUsage(
-    () => parseArgs42({
-      args: argv2,
-      options: {
-        to: { type: "string" },
-        "in-place": { type: "boolean" },
-        dir: { type: "string" },
-        host: { type: "string" },
-        workspace: { type: "string" },
-        git: { type: "boolean" },
-        "keep-unsent": { type: "boolean" },
-        json: { type: "boolean" },
-        help: { type: "boolean", short: "h" }
-      },
-      allowPositionals: true
-    }),
-    CLI_LEAVES.export
-  );
-  if (values.help) {
-    deps2.stdout(renderUsage(EXPORT_USAGE));
-    return;
-  }
-  const mode = resolveMode(values);
-  const usage3 = (message) => new CliError("USAGE", message, { help: `${cliInvocation()} export --help` });
-  const named = positionals[0];
-  const inPlace = values["in-place"] === true;
-  if (inPlace === (values.to !== void 0)) throw usage3("pass exactly one of --to <folder> and --in-place");
-  if (named !== void 0 && values.dir !== void 0) throw usage3("pass a bundle id or --dir <checkout>, not both");
-  if (named === void 0 && (values.host !== void 0 || values.workspace !== void 0)) throw usage3("--host and --workspace go with a bundle id; a checkout uses its own");
-  if (inPlace && named !== void 0) throw usage3("--in-place converts a checkout folder: pass --dir <checkout>, not a bundle id");
-  if (!inPlace && values["keep-unsent"]) throw usage3("--keep-unsent goes with --in-place");
-  const reference = named === void 0 ? void 0 : parseHostedBundleReference(named);
-  if (named !== void 0 && !reference) throw usage3(`'${named}' is not a hosted bundle id or <workspace>/<bundle-id>`);
-  const git2 = values.git === true;
-  const resume2 = commandFragment`${cliInvocation()} export${named !== void 0 ? commandFragment` ${commandToken(named)}` : commandFragment``}${values.dir !== void 0 ? commandFragment` --dir ${commandToken(path56.resolve(deps2.cwd, values.dir))}` : commandFragment``}${values.to !== void 0 ? commandFragment` --to ${commandToken(path56.resolve(deps2.cwd, values.to))}` : commandFragment``}${inPlace ? commandFragment` --in-place` : commandFragment``}${values.host !== void 0 ? commandFragment` --host ${commandToken(values.host)}` : commandFragment``}${values.workspace !== void 0 ? commandFragment` --workspace ${commandToken(values.workspace)}` : commandFragment``}${git2 ? commandFragment` --git` : commandFragment``}${values["keep-unsent"] ? commandFragment` --keep-unsent` : commandFragment``}${values.json ? commandFragment` --json` : commandFragment``}`;
-  if (values.dir !== void 0) assertBundleOutsidePrivateState(path56.resolve(deps2.cwd, values.dir), deps2.auth.home);
-  if (inPlace) {
-    await exportInPlace(values.dir, git2, values["keep-unsent"] === true, deps2, mode, resume2);
-    return;
-  }
-  let source;
-  if (reference) {
-    const named2 = await requireHostedBundleHost(values.host, deps2.auth);
-    source = {
-      target: named2.target,
-      bundleId: reference.bundleId,
-      slug: reference.slug,
-      workspace: workspaceForNamedHost(named2, values.workspace) ?? null,
-      binding: null
-    };
-  } else {
-    const binding = await hostedCheckoutFor(values.dir === void 0 ? [] : ["--dir", values.dir], deps2.auth.home, deps2.cwd);
-    if (!binding) {
-      throw new CliError("NOT_FOUND", `${path56.resolve(deps2.cwd, values.dir ?? ".")} is not a hosted checkout`, {
-        details: { reason: "not_a_checkout" },
-        help: `${cliInvocation()} export <bundle-id> --to ${commandToken(values.to)}`
-      });
-    }
-    source = { target: resolveHostedTarget(binding.audience), bundleId: binding.bundle_id, slug: binding.workspace_slug ?? null, workspace: null, binding };
-  }
-  await exportToFolder(source, values.to, git2, deps2, mode, resume2);
-}
-var EXPORT_USAGE, EXPORT_DEADLINE_MS, SHOWN, JOURNAL, JOURNAL_SCHEMA, MAX_JOURNAL_BYTES, NO_HISTORY, HOSTED_UNCHANGED, PAGED_EXPORT_ATTEMPTS, PAGED_EXPORT_RESTART_MS, PAGE_RETRY_MS, pause2, ABANDONED_AFTER_MS;
-var init_export = __esm({
-  "../cli/src/commands/export.ts"() {
-    "use strict";
-    init_define_SUPERBEE_BUILD_IDENTITY();
-    init_define_SUPERBEE_UPDATE_POLICY();
-    init_src();
-    init_filesystem_push_role();
-    init_src2();
-    init_args();
-    init_bundle2();
-    init_bundle_home();
-    init_command_spec();
-    init_command_text();
-    init_errors4();
-    init_invocation();
-    init_output2();
-    init_private_state_bundle_boundary();
-    init_nofollow_read();
-    init_autopull2();
-    init_session();
-    init_discovery();
-    init_binding();
-    init_client();
-    init_account();
-    init_refusals();
-    init_reference();
-    init_sync2();
-    init_status();
-    init_file_journaled_backend();
-    init_marker();
-    init_export_archive();
-    init_export_archive();
-    EXPORT_USAGE = `superbee export \u2014 copy a hosted bundle out of hosted Superbee
-
-Usage:
-  superbee export <bundle-id> --to <folder> [--host <url>] [--workspace <id>] [--git] [--json]
-  superbee export [--dir <checkout>] --to <folder> [--git] [--json]
-  superbee export [--dir <checkout>] --in-place [--git] [--keep-unsent] [--json]
-
-Fetches the hosted bundle's portable export: every document, reserved file (index.md, log.md)
-and blob at its latest confirmed revision, byte for byte as the host stores them. The archive is
-verified whole (every entry against the host's digest manifest) before any file is written.
-Signs in if needed (AUTH_REQUIRED, exit 4, carries the one link to relay and the command to
-re-run). The hosted bundle is never changed. History is not exported: the folder holds the
-current revision only.
-
---to <folder> writes a new local bundle there. The folder must be new or empty; it appears
-complete or not at all. With a bundle id the host is --host, else your last sign-in; with
---dir (or run inside a checkout) the checkout's own host and bundle are used. A bundle id in more
-than one of your workspaces is named <workspace>/<bundle-id>, or with --workspace.
-
---in-place converts a hosted checkout into a plain local bundle: it adds the files the checkout
-lacks (blobs, reserved files, documents added on the host), never overwrites a file, then
-forgets the checkout's binding. It refuses a checkout with changes sync has not sent, conflicts
-or held files; run 'superbee sync' first, or pass --keep-unsent to keep them in this folder only.
-If it is interrupted, re-running the same command finishes it.
-
---git makes the result a Git board: a repository on branch '${BOARD_BRANCH}' whose first commit is the
-export. Share it with 'git remote add origin <url>' and 'superbee sync --establish'.
-
-Options:
-  --to <folder>       New or empty folder to export into
-  --in-place          Convert the hosted checkout (--dir, else the current folder) into a local bundle
-  --dir <checkout>    The hosted checkout to export (default: the current folder)
-  --host <url>        Hosted Superbee URL, with a bundle id; default: your last sign-in
-  --workspace <id>    With a bundle id: your workspace that holds it, by id or slug
-  --git               Initialize a Git repository on branch '${BOARD_BRANCH}' and commit the export
-  --keep-unsent       With --in-place: convert even with unsent changes, conflicts or held files
-  --json              Emit compact JSON instead of TOON
-  -h, --help          Show this help
-
-Examples:
-  superbee export team.knowledge --to ~/work/team-knowledge --git
-  superbee export --dir ~/work/team --to ~/work/team-copy
-  superbee export --dir ~/work/team --in-place
-`;
-    EXPORT_DEADLINE_MS = 6e4;
-    SHOWN = 20;
-    JOURNAL = IN_PLACE_JOURNAL;
-    JOURNAL_SCHEMA = 1;
-    MAX_JOURNAL_BYTES = 8 * 1024 * 1024;
-    NO_HISTORY = "not exported: the folder holds the current revision only";
-    HOSTED_UNCHANGED = "unchanged: the hosted bundle still exists and was not modified";
-    PAGED_EXPORT_ATTEMPTS = 3;
-    PAGED_EXPORT_RESTART_MS = [500, 1500];
-    PAGE_RETRY_MS = 1e3;
-    pause2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
-    ABANDONED_AFTER_MS = 60 * 60 * 1e3;
-  }
-});
-
 // ../cli/src/commands/op.ts
 import { homedir as homedir41 } from "node:os";
 import path57 from "node:path";
@@ -136410,8 +136591,9 @@ function cleanAuthor(author) {
 function gitVersions(board, id, rel, current, okfVersion, now, documentInputBytes) {
   const repoPath = board.prefix === "" ? rel : `${board.prefix}/${rel}`;
   const log = runGit(board.top, ["log", "--no-renames", "--format=%H%x1f%an <%ae>%x1f%aI", "HEAD", "--", repoPath]);
-  if (log.status !== 0) return { rows: [], skipped: 0 };
+  if (log.status !== 0) return { rows: [], skipped: 0, oversized: [] };
   const rows = [];
+  const oversized = [];
   let skipped = 0;
   let previous3 = current;
   for (const line2 of log.stdout.split("\n").filter(Boolean)) {
@@ -136438,19 +136620,24 @@ function gitVersions(board, id, rel, current, okfVersion, now, documentInputByte
       skipped += 1;
       continue;
     }
+    const frontmatter = Object.fromEntries(
+      Object.entries(parsed2.frontmatter).filter(([key2]) => !IMPORT_DROPPED_FIELDS.includes(key2))
+    );
+    if (Buffer.byteLength(JSON.stringify(frontmatter)) > FRONTMATTER_JSON_BYTES) {
+      skipped += 1;
+      oversized.push(`${rel}@${sha.slice(0, 12)}`);
+      continue;
+    }
     rows.push({
       documentId: id,
       label: `imported:git/${sha}`,
       author: cleanAuthor(author ?? ""),
       authoredAt: new Date(when).toISOString(),
-      // An imported version never asserts verification or host attribution, as a current document does not.
-      frontmatter: Object.fromEntries(
-        Object.entries(parsed2.frontmatter).filter(([key2]) => !IMPORT_DROPPED_FIELDS.includes(key2))
-      ),
+      frontmatter,
       body: parsed2.body ?? ""
     });
   }
-  return { rows: rows.reverse(), skipped };
+  return { rows: rows.reverse(), skipped, oversized };
 }
 async function okfVersionOf(rootIndex) {
   if (rootIndex === null) return void 0;
@@ -136593,7 +136780,12 @@ async function planPublish(folder, options) {
       throw error51;
     }
     if (request3.kind !== "create") throw new Error(`'${id}' became a ${request3.kind} request`);
-    if (Buffer.byteLength(JSON.stringify(request3.payload.frontmatter)) > FRONTMATTER_JSON_BYTES) {
+    const frontmatterBytes = Buffer.byteLength(JSON.stringify(request3.payload.frontmatter));
+    if ("verified" in request3.payload.frontmatter && frontmatterBytes <= FRONTMATTER_JSON_BYTES && frontmatterBytes > FRONTMATTER_JSON_BYTES - VERIFIED_STAMP_ROOM_BYTES) {
+      blockers.push({ path: entry.rel, reason: "too_large", message: `'${id}' carries verified and leaves less than ${VERIFIED_STAMP_ROOM_BYTES} bytes of the ${FRONTMATTER_JSON_BYTES / 1024} KiB of frontmatter the host stores for its stamps on later edits; shorten its frontmatter` });
+      continue;
+    }
+    if (frontmatterBytes > FRONTMATTER_JSON_BYTES) {
       blockers.push({ path: entry.rel, reason: "too_large", message: `'${id}' has more than the ${FRONTMATTER_JSON_BYTES / 1024} KiB of frontmatter the host stores, counting ${request3.provenance.carried.join(", ")}` });
       continue;
     }
@@ -136633,6 +136825,7 @@ async function planPublish(folder, options) {
         const versions = gitVersions(options.board, file2.id, file2.rel, file2.text, okfVersion, options.now ?? Date.now(), documentInputBytes);
         history.push(...versions.rows);
         skippedVersions += versions.skipped;
+        for (const version4 of versions.oversized) skipped.push({ path: version4, reason: `an earlier version with more than the ${FRONTMATTER_JSON_BYTES / 1024} KiB of frontmatter the host stores; its history is imported without it` });
       }
       historyPlan = {
         mode: "git",
@@ -136773,7 +136966,7 @@ function packParts(content3, versions) {
   }
   return parts;
 }
-var MiB, PUBLISH_BOUNDS, STAGED_PUBLISH_BOUNDS, CONTENT_TYPES, HOSTED_KIND_WRITE, FORMAT_AT_EDGE, FORMAT_INSIDE, WIDEST_TARGET;
+var MiB, PUBLISH_BOUNDS, STAGED_PUBLISH_BOUNDS, CONTENT_TYPES, HOSTED_KIND_WRITE, VERIFIED_STAMP_ROOM_BYTES, FORMAT_AT_EDGE, FORMAT_INSIDE, WIDEST_TARGET;
 var init_publish_plan = __esm({
   "../cli/src/hosted/publish-plan.ts"() {
     "use strict";
@@ -136833,6 +137026,7 @@ var init_publish_plan = __esm({
       ".xml": "application/xml"
     };
     HOSTED_KIND_WRITE = Object.freeze({ strict: true, persistActor: true, producer: "process:superbee-hosted" });
+    VERIFIED_STAMP_ROOM_BYTES = 512;
     FORMAT_AT_EDGE = new RegExp("^\\p{Cf}|\\p{Cf}$", "u");
     FORMAT_INSIDE = new RegExp("(?![\\u200c\\u200d])\\p{Cf}", "u");
     WIDEST_TARGET = Object.freeze({ workspace: "w".repeat(64), bundleId: "b".repeat(128), name: "n".repeat(128) });
@@ -137193,7 +137387,7 @@ function provenanceOf(plan) {
   return {
     carried: plan.provenance.carried,
     dropped: plan.provenance.dropped,
-    note: "provenance travels as each file states it (a claim, not a verification); verification events and the last-editor attribution stay in the folder, and the host attributes the creation to you"
+    note: "provenance travels as each file states it (a claim, not a verification), so documents read on the host as they do here; the host records the creation as yours and stamps the writer itself on every later edit"
   };
 }
 function createRefusal(code3, message, context) {
@@ -137220,6 +137414,14 @@ function createRefusal(code3, message, context) {
         details,
         help: `put the files back as they were and re-run the same command to finish it; if the creation already finished, bind this folder to it (your edits become sync conflicts): ${cliInvocation()} checkout --adopt ${commandToken(context.folder)} --host ${commandToken(bindingHostArgument(context.target))}`
       });
+    case "validation_failed":
+      if (/sets (superbee_updated_by|verified)\b.*which only the host writes/.test(message)) {
+        return new CliError("FORBIDDEN", `${context.target.origin} does not yet keep each document's superbee_updated_by and verified on a new bundle, which this CLI carries`, {
+          details: { ...details, reason: "host_predates_provenance" },
+          help: "leave the files as they are: publish again once the host is updated, or publish with an earlier superbee CLI, which leaves those fields behind"
+        });
+      }
+      return new CliError("USAGE", `${context.target.origin} refused the bundle (${code3}): ${message}`, { details, help: "fix the files it names, then preview again" });
     default:
       return new CliError("USAGE", `${context.target.origin} refused the bundle (${code3}): ${message}`, { details, help: "fix the files it names, then preview again" });
   }
@@ -137666,9 +137868,10 @@ Without --yes, previews only, with no network: what travels (documents, reserved
 files), what stays (dot-files, links), how it is sent, every bound the host enforces, the history
 plan, and what will happen to the folder.
 
-Each document's provenance (generated, timestamp, actor, okf_version) travels as its file states
-it, a claim rather than a verification; verified and superbee_updated_by never travel. The
-preview and the receipt count both, per field.
+Each document's provenance (generated, timestamp, actor, okf_version, superbee_updated_by,
+verified) travels as its file states it, a claim rather than a verification, so the bundle reads
+on the host as it does here. The host still records the creation as yours, and stamps the writer
+itself on every later edit. The preview and the receipt count each field.
 
 A bundle within one request's bounds (at most 1,000 documents, 100 other files of 1 MB each,
 1,000 earlier versions, 1,500 objects in all, 3 MiB) is sent in one request. A larger one is sent