@arcadiasystems/morse-cli 0.1.0 → 0.3.0

package/dist/index.js

@@ -148,7 +148,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@arcadiasystems/morse-cli",
-  version: "0.1.0",
+  version: "0.3.0",
   description: "Command-line interface for the Morse decentralized CMS on Sui.",
   license: "MIT",
   type: "module",
@@ -194,11 +194,16 @@ var package_default = {
     lint: "biome check .",
     "lint:fix": "biome check --write .",
     test: "bun test",
+    "test:unit": "bun test test/*.test.ts",
+    "test:cli": "bun test test/cli/",
     "test:coverage": "bun test --coverage",
-    prepublishOnly: "tsc --noEmit && biome check . && bun test && bun run build"
+    "test:e2e": "MORSE_E2E=1 bun test test/e2e/",
+    coverage: "bun scripts/coverage-gate.ts",
+    check: "tsc --noEmit && biome check . && bun scripts/coverage-gate.ts",
+    prepublishOnly: "bun run check && bun run build"
   },
   dependencies: {
-    "@arcadiasystems/morse-sdk": "^0.1.4",
+    "@arcadiasystems/morse-sdk": "^0.3.0",
     "@mysten/seal": "1.1.3",
     "@mysten/sui": "2.16.2",
     "@mysten/walrus": "1.1.6",
@@ -313,27 +318,41 @@ class Output {
   }
   result(human, data) {
     if (this.options.json) {
-      process.stdout.write(`${toJson(data)}
+      this.out(`${toJson(data)}
 `);
       return;
     }
-    process.stdout.write(`${human}
+    this.out(`${human}
 `);
   }
   info(message) {
     if (this.options.quiet || this.options.json) {
       return;
     }
-    process.stderr.write(`${this.paint(message, DIM)}
+    this.err(`${this.paint(message, DIM)}
 `);
   }
   warn(message) {
     if (this.options.quiet || this.options.json) {
       return;
     }
-    process.stderr.write(`${this.paint(message, YELLOW)}
+    this.err(`${this.paint(message, YELLOW)}
 `);
   }
+  out(text) {
+    if (this.options.writeOut !== undefined) {
+      this.options.writeOut(text);
+      return;
+    }
+    process.stdout.write(text);
+  }
+  err(text) {
+    if (this.options.writeErr !== undefined) {
+      this.options.writeErr(text);
+      return;
+    }
+    process.stderr.write(text);
+  }
   paint(text, code) {
     return this.options.color ? `\x1B[${code}m${text}${RESET}` : text;
   }
@@ -766,79 +785,85 @@ function accountAddress(account, env = process.env) {
 }
 
 // src/commands/account.ts
+async function runAccountImport(output, gopts, env, signal) {
+  const secret = await readSecretToImport(env, signal);
+  const password = await resolvePassword("create", env, signal);
+  const address = await importKey(secret, password);
+  const profileName = await associateAccount(gopts, address);
+  output.info(`Imported ${address} into keystore.`);
+  output.result(`Imported account ${address} (profile "${profileName}").`, {
+    address,
+    profile: profileName
+  });
+}
+async function runAccountList(output, gopts) {
+  const addresses = await listAddresses();
+  const active = await resolveActiveAccount(gopts);
+  if (addresses.length === 0) {
+    output.result("No accounts. Import one with: morse account import", {
+      active,
+      accounts: []
+    });
+    return;
+  }
+  const human = addresses.map((address) => `${address === active ? "*" : " "} ${address}`).join(`
+`);
+  output.result(human, { active, accounts: addresses });
+}
+async function runAccountShow(output, gopts) {
+  const active = await resolveActiveAccount(gopts);
+  if (active === undefined) {
+    throw new UsageError("No active account. Import one with `morse account import` or set MORSE_ADDRESS.");
+  }
+  output.result(active, { address: active });
+}
+async function runAccountUse(output, gopts, address) {
+  if (!await hasKeystore(address)) {
+    throw new UsageError(`No keystore for ${address}. Import it first with: morse account import`);
+  }
+  const profileName = await associateAccount(gopts, address);
+  output.result(`Active account for "${profileName}" set to ${address}.`, {
+    address,
+    profile: profileName
+  });
+}
+async function runAccountExport(output, gopts, address, env, signal) {
+  if (output.isJson) {
+    throw new UsageError("account export is not available in --json mode.");
+  }
+  if (!isInteractive()) {
+    throw new UsageError("account export requires an interactive terminal.");
+  }
+  if (gopts.yes) {
+    throw new UsageError("account export does not accept --yes. Confirm interactively.");
+  }
+  const proceed = await confirm(`Reveal the secret key for ${address}? Anyone who sees it controls the account.`, { signal });
+  if (!proceed) {
+    cancelled();
+  }
+  const password = await resolvePassword("unlock", env, signal);
+  const secret = await unlockSecret(address, password);
+  process.stderr.write(`Warning: secret key follows. Handle it with care.
+`);
+  process.stdout.write(`${secret}
+`);
+}
 function registerAccountCommands(program) {
   const account = program.command("account").description("Import and manage encrypted signing keys");
   account.command("import").description("Import a private key into an encrypted keystore").action(async (_options, command) => {
-    const opts = globalOptions(command);
-    const output = outputFor(command);
-    const signal = sigintSignal();
-    const secret = await readSecretToImport(process.env, signal);
-    const password = await resolvePassword("create", process.env, signal);
-    const address = await importKey(secret, password);
-    const profileName = await associateAccount(opts, address);
-    output.info(`Imported ${address} into keystore.`);
-    output.result(`Imported account ${address} (profile "${profileName}").`, {
-      address,
-      profile: profileName
-    });
+    await runAccountImport(outputFor(command), globalOptions(command), process.env, sigintSignal());
   });
   account.command("list").description("List imported accounts").action(async (_options, command) => {
-    const output = outputFor(command);
-    const addresses = await listAddresses();
-    const active = await resolveActiveAccount(globalOptions(command));
-    if (addresses.length === 0) {
-      output.result("No accounts. Import one with: morse account import", {
-        active,
-        accounts: []
-      });
-      return;
-    }
-    const human = addresses.map((address) => `${address === active ? "*" : " "} ${address}`).join(`
-`);
-    output.result(human, { active, accounts: addresses });
+    await runAccountList(outputFor(command), globalOptions(command));
   });
   account.command("show").description("Print the active account address").action(async (_options, command) => {
-    const output = outputFor(command);
-    const active = await resolveActiveAccount(globalOptions(command));
-    if (active === undefined) {
-      throw new UsageError("No active account. Import one with `morse account import` or set MORSE_ADDRESS.");
-    }
-    output.result(active, { address: active });
+    await runAccountShow(outputFor(command), globalOptions(command));
   });
   account.command("use <address>").description("Set the active account for the current profile").action(async (address, _options, command) => {
-    const opts = globalOptions(command);
-    const output = outputFor(command);
-    if (!await hasKeystore(address)) {
-      throw new UsageError(`No keystore for ${address}. Import it first with: morse account import`);
-    }
-    const profileName = await associateAccount(opts, address);
-    output.result(`Active account for "${profileName}" set to ${address}.`, {
-      address,
-      profile: profileName
-    });
+    await runAccountUse(outputFor(command), globalOptions(command), address);
   });
   account.command("export <address>").description("Print a decrypted secret key (dangerous)").action(async (address, _options, command) => {
-    const output = outputFor(command);
-    if (output.isJson) {
-      throw new UsageError("account export is not available in --json mode.");
-    }
-    if (!isInteractive()) {
-      throw new UsageError("account export requires an interactive terminal.");
-    }
-    if (globalOptions(command).yes) {
-      throw new UsageError("account export does not accept --yes. Confirm interactively.");
-    }
-    const signal = sigintSignal();
-    const proceed = await confirm(`Reveal the secret key for ${address}? Anyone who sees it controls the account.`, { signal });
-    if (!proceed) {
-      cancelled();
-    }
-    const password = await resolvePassword("unlock", process.env, signal);
-    const secret = await unlockSecret(address, password);
-    process.stderr.write(`Warning: secret key follows. Handle it with care.
-`);
-    process.stdout.write(`${secret}
-`);
+    await runAccountExport(outputFor(command), globalOptions(command), address, process.env, sigintSignal());
   });
 }
 async function readSecretToImport(env, signal) {
@@ -857,33 +882,38 @@ async function readSecretToImport(env, signal) {
   }
   return secret;
 }
-async function associateAccount(opts, address) {
-  return updateActiveProfile(opts, { account: address });
+async function associateAccount(gopts, address) {
+  return updateActiveProfile(gopts, { account: address });
 }
-async function resolveActiveAccount(opts) {
-  return accountAddress(resolveSettings(opts, await loadConfig()).account);
+async function resolveActiveAccount(gopts) {
+  return accountAddress(resolveSettings(gopts, await loadConfig()).account);
 }
 
-// src/commands/cap.ts
+// src/commands/allowlist.ts
 import {
-  destroyPublisherCap,
-  issuePublisherCap,
-  revokePublisherCap,
-  toPublisherCapId as toPublisherCapId2,
+  addMember,
+  createAllowlist,
+  deleteAllowlist,
+  removeMember,
+  toAllowlistId,
   toSuiAddress as toSuiAddress3,
-  transferPublisherCap
+  transferAllowlistCap
 } from "@arcadiasystems/morse-sdk";
 
 // src/cli/context.ts
 import {
+  buildFilesEventTypes,
   DefaultSealAdapter,
   DefaultWalrusReadAdapter,
   DefaultWalrusWriteAdapter,
+  HttpAggregatorReadAdapter,
   KeypairAdapter,
   morseConfig,
+  RpcFilesReader,
   RpcPublicationReader
 } from "@arcadiasystems/morse-sdk";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
 async function buildReadContext(command) {
   const opts = globalOptions(command);
   const output = outputFor(command);
@@ -920,6 +950,20 @@ async function buildWriteContext(command) {
     address
   };
 }
+async function buildFilesReadContext(command) {
+  const base = await buildReadContext(command);
+  return {
+    ...base,
+    filesReader: RpcFilesReader.fromMorseConfig(base.config, base.client)
+  };
+}
+async function buildAllowlistWriteContext(command) {
+  const base = await buildWriteContext(command);
+  return {
+    ...base,
+    filesReader: RpcFilesReader.fromMorseConfig(base.config, base.client)
+  };
+}
 async function buildContentContext(command) {
   const { base, keypair, address } = await buildSignedBase(command);
   const network = base.settings.network;
@@ -935,74 +979,71 @@ async function buildEncryptContext(command) {
   const seal = DefaultSealAdapter.fromMorseConfig(ctx.config, {}, ctx.client);
   return { ...ctx, seal };
 }
-async function buildReadContentContext(command) {
+function walrusReadAdapter(base, network, viaAggregator) {
+  if (viaAggregator) {
+    return HttpAggregatorReadAdapter.fromMorseConfig(base.config, base.client);
+  }
+  return DefaultWalrusReadAdapter.fromConfig({
+    network,
+    suiClient: base.client
+  });
+}
+async function buildReadContentContext(command, opts = {}) {
   const base = await buildReadContext(command);
   const network = base.settings.network;
   if (network === "localnet") {
     throw new CliError("Walrus reads are not available on localnet. Use testnet or mainnet.", ExitCode.Usage);
   }
-  const walrusRead = DefaultWalrusReadAdapter.fromConfig({
-    network,
-    suiClient: base.client
-  });
-  return { ...base, walrusRead };
+  return {
+    ...base,
+    walrusRead: walrusReadAdapter(base, network, Boolean(opts.viaAggregator))
+  };
 }
-async function buildDecryptContext(command) {
+async function buildDecryptContext(command, opts = {}) {
   const { base, keypair, address } = await buildSignedBase(command);
   const network = base.settings.network;
   if (network === "localnet") {
     throw new CliError("Seal decryption is not available on localnet. Use testnet or mainnet.", ExitCode.Usage);
   }
   const seal = DefaultSealAdapter.fromMorseConfig(base.config, {}, base.client);
-  const walrusRead = DefaultWalrusReadAdapter.fromConfig({
-    network,
-    suiClient: base.client
-  });
-  return { ...base, keypair, address, seal, walrusRead };
-}
-
-// src/cli/target.ts
-import { toPublicationId } from "@arcadiasystems/morse-sdk";
-var OBJECT_ID = /^0x[0-9a-f]{1,64}$/i;
-var SLUG_PAGE_LIMIT = 50;
-async function resolvePublication(ctx, override) {
-  const value = override ?? ctx.settings.publication;
-  if (value === undefined) {
-    throw new UsageError("No publication selected. Pass --publication <slug|id> or run `morse use <slug|id>`.");
-  }
-  if (OBJECT_ID.test(value)) {
-    return toPublicationId(value.toLowerCase());
-  }
-  return resolveSlug(ctx, value);
+  return {
+    ...base,
+    keypair,
+    address,
+    seal,
+    walrusRead: walrusReadAdapter(base, network, Boolean(opts.viaAggregator))
+  };
 }
-function resolveCollection(ctx, override) {
-  const value = override ?? ctx.settings.collection;
-  if (value === undefined) {
-    throw new UsageError("No collection selected. Pass --collection <name> or run `morse use <slug|id> <collection>`.");
+async function buildFileDownloadContext(command, opts = {}) {
+  const base = await buildReadContext(command);
+  const network = base.settings.network;
+  if (network === "localnet") {
+    throw new CliError("Walrus reads are not available on localnet. Use testnet or mainnet.", ExitCode.Usage);
   }
-  return value;
+  return {
+    ...base,
+    filesReader: RpcFilesReader.fromMorseConfig(base.config, base.client),
+    walrusRead: walrusReadAdapter(base, network, Boolean(opts.viaAggregator)),
+    seal: DefaultSealAdapter.fromMorseConfig(base.config, {}, base.client),
+    unlockSigner: () => resolveSigner(base.settings.account, process.env, base.signal)
+  };
 }
-async function resolveSlug(ctx, slug) {
-  if (ctx.ownerAddress === undefined) {
-    throw new UsageError(`Cannot resolve the slug "${slug}" without an active account. Pass the publication id, or select an account.`);
+async function buildFileListContext(command, opts = {}) {
+  const base = await buildReadContext(command);
+  const originPackageId = base.config.filesEventOriginPackageId;
+  if (originPackageId === undefined) {
+    throw new CliError("File listing is unavailable on this network: no filesEventOriginPackageId in the config. Use testnet, or supply a config that sets it.", ExitCode.Usage);
   }
-  ctx.output.info(`Resolving slug "${slug}" among owned publications...`);
-  let cursor;
-  do {
-    const page = await ctx.reader.listPublicationsOwnedBy(ctx.ownerAddress, {
-      limit: SLUG_PAGE_LIMIT,
-      signal: ctx.signal,
-      ...cursor === undefined ? {} : { cursor }
-    });
-    for (const owned of page.results) {
-      const publication = await ctx.reader.getPublication(owned.publicationId, ctx.signal);
-      if (publication.slug === slug) {
-        return publication.id;
-      }
-    }
-    cursor = page.nextCursor ?? undefined;
-  } while (cursor !== undefined);
-  throw new UsageError(`No publication with slug "${slug}" owned by the active account. Pass the publication id instead.`);
+  const events = new SuiJsonRpcClient({
+    network: base.settings.network,
+    url: opts.indexerUrl ?? base.config.rpcUrl
+  });
+  return {
+    ...base,
+    filesReader: RpcFilesReader.fromMorseConfig(base.config, base.client),
+    events,
+    eventTypes: buildFilesEventTypes(originPackageId)
+  };
 }
 
 // src/format/ids.ts
@@ -1072,6 +1113,52 @@ function renderEntryList(entries) {
   return entries.map((entry) => `#${entry.id} ${entry.name} (${entry.revisions.length} revisions)`).join(`
 `);
 }
+function renderAllowlist(allowlist) {
+  const members = allowlist.members.length === 0 ? "(none)" : allowlist.members.map((m) => `  ${m}`).join(`
+`);
+  return [
+    `${allowlist.name} (${shortId(allowlist.id)})`,
+    `members (${allowlist.members.length}):`,
+    members
+  ].join(`
+`);
+}
+function renderAllowlistCapList(caps) {
+  if (caps.length === 0) {
+    return "No allowlist caps held by this address.";
+  }
+  return caps.map((cap) => `${cap.id}  allowlist ${cap.allowlistId}`).join(`
+`);
+}
+function renderFileList(items) {
+  if (items.length === 0) {
+    return "No files.";
+  }
+  const header = "id  name  size  encrypted  allowlist  created";
+  const rows = items.map((file) => {
+    const allowlist = file.allowlistId === null ? "public" : shortId(file.allowlistId);
+    const created = new Date(file.createdAtMs).toISOString().slice(0, 10);
+    const encrypted = file.encrypted ? "yes" : "no";
+    return `${shortId(file.id)}  ${file.name}  ${file.size}  ${encrypted}  ${allowlist}  ${created}`;
+  });
+  return [header, ...rows].join(`
+`);
+}
+function renderEncryptedFile(file) {
+  const lines = [
+    `${file.name} (${shortId(file.id)})`,
+    `contentType: ${file.contentType}`,
+    `size:        ${file.size}`,
+    `encrypted:   ${file.encrypted}`,
+    `blobId:      ${file.blobId}`,
+    `owner:       ${file.owner}`
+  ];
+  if (file.allowlistId !== null) {
+    lines.push(`allowlist:   ${file.allowlistId}`);
+  }
+  return lines.join(`
+`);
+}
 function headLabel(value) {
   return value === null ? "none" : String(value);
 }
@@ -1094,12 +1181,22 @@ function publisherCapOption(command) {
 function ownerCapOption(command) {
   return command.option("--owner-cap <id>", "OwnerCap ID (auto-resolved if omitted)");
 }
+function allowlistOption(command) {
+  return command.option("-a, --allowlist <id>", "Allowlist object id");
+}
+function allowlistCapOption(command) {
+  return command.option("--cap <id>", "Allowlist admin Cap id (auto-resolved from owned caps if omitted)");
+}
+function viaAggregatorOption(command) {
+  return command.option("--via-aggregator", "Fetch content via the Walrus aggregator HTTP service. More reliable when storage nodes are flaky; no client-side blob verification.");
+}
 function contentOptions(command) {
   return command.option("-f, --file <path>", "File to upload (or - for stdin)").option("--stdin", "Read content from stdin").option("--content-type <type>", "MIME content type (inferred from --file if omitted)").option("--epochs <n>", "Walrus storage epochs", "3");
 }
 
 // src/commands/resolve.ts
 import {
+  toAllowlistCapId,
   toOwnerCapId,
   toPublisherCapId
 } from "@arcadiasystems/morse-sdk";
@@ -1142,6 +1239,25 @@ async function resolvePublisherCap(reader, address, publicationId, override, sig
   } while (cursor !== undefined);
   throw new CliError(`No PublisherCap for ${publicationId} held by ${address}. Pass --publisher-cap, or check that the active account holds one.`, ExitCode.NotFound);
 }
+async function resolveAllowlistCap(filesReader, address, allowlistId, override, signal) {
+  if (override !== undefined) {
+    return toAllowlistCapId(override);
+  }
+  let cursor;
+  do {
+    const page = await filesReader.listAllowlistCapsOwnedBy(address, {
+      limit: PAGE_LIMIT,
+      signal,
+      ...cursor === undefined ? {} : { cursor }
+    });
+    const match = page.results.find((c) => c.allowlistId === allowlistId);
+    if (match !== undefined) {
+      return match.id;
+    }
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor !== undefined);
+  throw new CliError(`No allowlist Cap for ${allowlistId} held by ${address}. Pass --cap, or check that the active account administers it.`, ExitCode.NotFound);
+}
 
 // src/commands/shared.ts
 import { StorageMode } from "@arcadiasystems/morse-sdk";
@@ -1162,6 +1278,12 @@ function parsePositiveInt(value, name) {
 function parseLimit(value) {
   return parsePositiveInt(value, "--limit");
 }
+function parseByteSize(value, name) {
+  if (!/^\d+$/.test(value)) {
+    throw new UsageError(`${name} must be a non-negative integer, got "${value}".`);
+  }
+  return BigInt(value);
+}
 function parseId(value, name) {
   const id = Number(value);
   if (!Number.isInteger(id) || id < 0) {
@@ -1170,219 +1292,428 @@ function parseId(value, name) {
   return id;
 }
 
-// src/commands/cap.ts
-function registerCapCommands(program) {
-  const cap = program.command("cap").description("Manage PublisherCaps (write-access capabilities)");
-  cap.command("list [address]").description("List publisher caps held by an address (default: the active account)").option("--limit <n>", "Maximum results per page").option("--cursor <cursor>", "Continue from a previous page cursor").action(async (address, options, command) => {
-    const ctx = await buildReadContext(command);
-    const holder = address === undefined ? ctx.ownerAddress : toSuiAddress3(address);
-    if (holder === undefined) {
-      throw new UsageError("No address given and no active account. Pass an address or import an account.");
-    }
-    const page = await ctx.reader.listPublisherCapsOwnedBy(holder, {
-      signal: ctx.signal,
-      ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
-      ...options.cursor === undefined ? {} : { cursor: options.cursor }
-    });
-    if (page.nextCursor !== null) {
-      ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
-    }
-    ctx.output.result(renderPublisherCapList(page.results), {
-      results: page.results,
-      nextCursor: page.nextCursor
-    });
+// src/commands/allowlist.ts
+function requireAllowlistId(value) {
+  if (value === undefined) {
+    throw new UsageError("Pass --allowlist <id>.");
+  }
+  return toAllowlistId(value);
+}
+async function runAllowlistCreate(ctx, options) {
+  ctx.output.info(`Creating allowlist "${options.name}"...`);
+  const result = await createAllowlist(ctx.adapter, ctx.config, {
+    name: options.name,
+    signal: ctx.signal
   });
-  const issue = cap.command("issue <holder>").description("Issue a PublisherCap bound to an address");
-  publicationOption(ownerCapOption(issue)).action(async (holder, options, command) => {
-    const ctx = await buildWriteContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const holderAddress = toSuiAddress3(holder);
-    ctx.output.info("Resolving OwnerCap...");
-    const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
-    const result = await issuePublisherCap(ctx.adapter, ctx.config, {
-      publicationId: id,
-      ownerCapId,
-      holder: holderAddress,
-      signal: ctx.signal
-    });
-    ctx.output.result(`Issued PublisherCap ${result.publisherCapId} to ${holderAddress}. (tx: ${result.digest})`, result);
+  const human = [
+    `Created allowlist "${options.name}" (${result.allowlistId})`,
+    `  cap: ${result.capId}`,
+    `  tx:  ${result.digest}`,
+    "Save the cap id: it is the admin token for managing members."
+  ].join(`
+`);
+  ctx.output.result(human, result);
+}
+async function runAllowlistAddMember(ctx, member, options) {
+  const allowlistId = requireAllowlistId(options.allowlist);
+  const memberAddress = toSuiAddress3(member);
+  const capId = await resolveAllowlistCap(ctx.filesReader, ctx.address, allowlistId, options.cap, ctx.signal);
+  const result = await addMember(ctx.adapter, ctx.config, {
+    allowlistId,
+    capId,
+    member: memberAddress,
+    signal: ctx.signal
   });
-  const revoke = cap.command("revoke <publisherCapId>").description("Revoke a PublisherCap so it can no longer write");
-  publicationOption(ownerCapOption(revoke)).action(async (publisherCapId, options, command) => {
-    const ctx = await buildWriteContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const capId = toPublisherCapId2(publisherCapId);
-    const proceed = await confirm(`Revoke PublisherCap ${capId}? It can no longer be used to write.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
-    if (!proceed) {
-      cancelled();
-    }
-    ctx.output.info("Resolving OwnerCap...");
-    const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
-    const result = await revokePublisherCap(ctx.adapter, ctx.config, {
-      publicationId: id,
-      ownerCapId,
-      publisherCapId: capId,
-      signal: ctx.signal
-    });
-    ctx.output.result(`Revoked PublisherCap ${capId}. (tx: ${result.digest})`, result);
+  ctx.output.result(`Added ${memberAddress} to allowlist ${shortId(allowlistId)}. (tx: ${result.digest})`, result);
+}
+async function runAllowlistRemoveMember(ctx, member, options) {
+  const allowlistId = requireAllowlistId(options.allowlist);
+  const memberAddress = toSuiAddress3(member);
+  const capId = await resolveAllowlistCap(ctx.filesReader, ctx.address, allowlistId, options.cap, ctx.signal);
+  const result = await removeMember(ctx.adapter, ctx.config, {
+    allowlistId,
+    capId,
+    member: memberAddress,
+    signal: ctx.signal
   });
-  const destroy = cap.command("destroy <publisherCapId>").description("Destroy a PublisherCap held by the active account");
-  publicationOption(destroy).action(async (publisherCapId, options, command) => {
-    const ctx = await buildWriteContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const capId = toPublisherCapId2(publisherCapId);
-    const proceed = await confirm(`Destroy PublisherCap ${capId}? This is permanent.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
-    if (!proceed) {
-      cancelled();
-    }
-    const result = await destroyPublisherCap(ctx.adapter, ctx.config, {
-      publicationId: id,
-      publisherCapId: capId,
-      signal: ctx.signal
-    });
-    ctx.output.result(`Destroyed PublisherCap ${capId}. (tx: ${result.digest})`, result);
+  ctx.output.result(`Removed ${memberAddress} from allowlist ${shortId(allowlistId)}. (tx: ${result.digest})`, result);
+}
+async function runAllowlistTransferCap(ctx, recipient, options, gopts) {
+  const allowlistId = requireAllowlistId(options.allowlist);
+  const to = toSuiAddress3(recipient);
+  const proceed = await confirm(`Transfer admin of allowlist ${shortId(allowlistId)} to ${to}? You will lose member-management rights.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  ctx.output.info("Resolving allowlist Cap...");
+  const capId = await resolveAllowlistCap(ctx.filesReader, ctx.address, allowlistId, options.cap, ctx.signal);
+  const result = await transferAllowlistCap(ctx.adapter, ctx.config, {
+    capId,
+    recipient: to,
+    signal: ctx.signal
   });
-  cap.command("transfer <publisherCapId> <recipient>").description("Transfer a PublisherCap object to another address").action(async (publisherCapId, recipient, _options, command) => {
-    const ctx = await buildWriteContext(command);
-    const capId = toPublisherCapId2(publisherCapId);
-    const to = toSuiAddress3(recipient);
-    const proceed = await confirm(`Transfer PublisherCap ${capId} to ${to}?`, {
-      assumeYes: Boolean(globalOptions(command).yes),
-      signal: ctx.signal
-    });
-    if (!proceed) {
-      cancelled();
-    }
-    const result = await transferPublisherCap(ctx.adapter, ctx.config, {
-      publisherCapId: capId,
-      recipient: to,
-      signal: ctx.signal
-    });
-    ctx.output.result(`Transferred PublisherCap ${capId} to ${to}. (tx: ${result.digest})`, result);
+  ctx.output.result(`Transferred allowlist admin to ${to}. (tx: ${result.digest})`, result);
+}
+async function runAllowlistDelete(ctx, options, gopts) {
+  const allowlistId = requireAllowlistId(options.allowlist);
+  const proceed = await confirm(`Delete allowlist ${shortId(allowlistId)}? Files gated by it become permanently undecryptable.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  ctx.output.info("Resolving allowlist Cap...");
+  const capId = await resolveAllowlistCap(ctx.filesReader, ctx.address, allowlistId, options.cap, ctx.signal);
+  const result = await deleteAllowlist(ctx.adapter, ctx.config, {
+    allowlistId,
+    capId,
+    signal: ctx.signal
   });
+  ctx.output.result(`Deleted allowlist ${allowlistId}. (tx: ${result.digest})`, result);
 }
-
-// src/commands/collection.ts
-import { createCollection, deleteCollection } from "@arcadiasystems/morse-sdk";
-function registerCollectionCommands(program) {
-  const collection = program.command("collection").description("Manage collections within a publication");
-  const list = collection.command("list").description("List the collections in a publication");
-  publicationOption(list).action(async (options, command) => {
-    const ctx = await buildReadContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const publication = await ctx.reader.getPublication(id, ctx.signal);
-    ctx.output.result(renderCollectionList(publication.collections), {
-      publication: id,
-      collections: publication.collections
-    });
-  });
-  const create = collection.command("create <name>").description("Create a collection and select it as the active collection").option("--mode <mode>", "Storage mode: blob or quilt", "blob");
-  publicationOption(publisherCapOption(create)).action(async (name, options, command) => {
-    const ctx = await buildWriteContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const storageMode = coerceStorageMode(options.mode);
-    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
-    ctx.output.info(`Creating collection "${name}" (${storageMode})...`);
-    const result = await createCollection(ctx.adapter, ctx.config, {
-      publicationId: id,
-      publisherCapId,
-      name,
-      storageMode,
-      signal: ctx.signal
-    });
-    await updateActiveProfile(globalOptions(command), { collection: name });
-    ctx.output.result(`Created collection "${name}". Selected as the active collection. (tx: ${result.digest})`, result);
+async function runAllowlistGet(ctx, target) {
+  const result = await ctx.filesReader.getAllowlist(toAllowlistId(target), ctx.signal);
+  ctx.output.result(renderAllowlist(result), result);
+}
+async function runAllowlistListCaps(ctx, address, options) {
+  const holder = address === undefined ? ctx.ownerAddress : toSuiAddress3(address);
+  if (holder === undefined) {
+    throw new UsageError("No address given and no active account. Pass an address or import an account.");
+  }
+  const page = await ctx.filesReader.listAllowlistCapsOwnedBy(holder, {
+    signal: ctx.signal,
+    ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
+    ...options.cursor === undefined ? {} : { cursor: options.cursor }
   });
-  const remove = collection.command("delete <name>").description("Delete an empty collection");
-  publicationOption(publisherCapOption(remove)).action(async (name, options, command) => {
-    const ctx = await buildWriteContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const proceed = await confirm(`Delete collection "${name}" from ${shortId(id)}? It must be empty.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
-    if (!proceed) {
-      cancelled();
-    }
-    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
-    const result = await deleteCollection(ctx.adapter, ctx.config, {
-      publicationId: id,
-      publisherCapId,
-      name,
-      signal: ctx.signal
-    });
-    if (ctx.settings.collection === name) {
-      await updateActiveProfile(globalOptions(command), {
-        collection: undefined
-      });
-    }
-    ctx.output.result(`Deleted collection "${name}". (tx: ${result.digest})`, result);
+  if (page.nextCursor !== null) {
+    ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
+  }
+  ctx.output.result(renderAllowlistCapList(page.results), {
+    results: page.results,
+    nextCursor: page.nextCursor
   });
 }
-
-// src/commands/config.ts
-function registerConfigCommands(program) {
-  const config = program.command("config").description("Manage profiles and CLI configuration");
-  config.command("path").description("Print the config file path").action((_options, command) => {
-    const path = configFilePath();
-    outputFor(command).result(path, { path });
+function registerAllowlistCommands(program) {
+  const allowlist = program.command("allowlist").description("Manage allowlists that gate decryption of encrypted files");
+  allowlist.command("create").description("Create an allowlist and transfer its admin cap to you").requiredOption("-n, --name <name>", "Allowlist name").action(async (options, command) => {
+    await runAllowlistCreate(await buildWriteContext(command), options);
   });
-  config.command("list").description("List profiles and show the default").action(async (_options, command) => {
-    const cfg = await loadConfig();
-    outputFor(command).result(renderProfiles(cfg), {
-      defaultProfile: cfg.defaultProfile,
-      profiles: cfg.profiles
-    });
+  const addMemberCmd = allowlist.command("add-member <member>").description("Add a wallet address to an allowlist");
+  allowlistCapOption(allowlistOption(addMemberCmd)).action(async (member, options, command) => {
+    await runAllowlistAddMember(await buildAllowlistWriteContext(command), member, options);
   });
-  config.command("add <name>").description("Create or update a profile").requiredOption("--network <network>", "Sui network: testnet or localnet").option("--rpc <url>", "RPC URL override for this profile").action(async (name, options, command) => {
-    const network = coerceNetwork(options.network);
-    const cfg = await loadConfig();
-    const profiles = {
-      ...cfg.profiles,
-      [name]: {
-        network,
-        ...options.rpc === undefined ? {} : { rpc: options.rpc }
-      }
-    };
-    const defaultProfile = Object.keys(cfg.profiles).length === 0 ? name : cfg.defaultProfile;
-    await saveConfig({ ...cfg, profiles, defaultProfile });
-    outputFor(command).result(`Saved profile "${name}" (${network}).`, {
-      profile: name,
-      network,
-      rpc: options.rpc,
-      default: defaultProfile === name
-    });
+  const removeMemberCmd = allowlist.command("remove-member <member>").description("Remove a wallet address from an allowlist");
+  allowlistCapOption(allowlistOption(removeMemberCmd)).action(async (member, options, command) => {
+    await runAllowlistRemoveMember(await buildAllowlistWriteContext(command), member, options);
   });
-  config.command("use <name>").description("Set the default profile").action(async (name, _options, command) => {
-    const cfg = await loadConfig();
-    requireProfile(cfg, name);
-    await saveConfig({ ...cfg, defaultProfile: name });
-    outputFor(command).result(`Default profile set to "${name}".`, {
-      defaultProfile: name
-    });
+  const transferCmd = allowlist.command("transfer-cap <recipient>").description("Transfer allowlist admin rights to another address");
+  allowlistCapOption(allowlistOption(transferCmd)).action(async (recipient, options, command) => {
+    await runAllowlistTransferCap(await buildAllowlistWriteContext(command), recipient, options, globalOptions(command));
   });
-  config.command("remove <name>").description("Delete a profile").action(async (name, _options, command) => {
-    const cfg = await loadConfig();
-    requireProfile(cfg, name);
-    const { [name]: _removed, ...rest } = cfg.profiles;
-    const defaultProfile = cfg.defaultProfile === name ? Object.keys(rest)[0] ?? "default" : cfg.defaultProfile;
-    await saveConfig({ ...cfg, profiles: rest, defaultProfile });
-    outputFor(command).result(`Removed profile "${name}".`, {
-      removed: name,
-      defaultProfile,
-      profiles: Object.keys(rest)
-    });
+  const deleteCmd = allowlist.command("delete").description("Delete an allowlist (dependent files become undecryptable)");
+  allowlistCapOption(allowlistOption(deleteCmd)).action(async (options, command) => {
+    await runAllowlistDelete(await buildAllowlistWriteContext(command), options, globalOptions(command));
+  });
+  allowlist.command("get <allowlist>").description("Fetch an allowlist's name and members").action(async (target, _options, command) => {
+    await runAllowlistGet(await buildFilesReadContext(command), target);
+  });
+  allowlist.command("list-caps [address]").description("List allowlist admin caps held by an address (default: the active account)").option("--limit <n>", "Maximum results per page").option("--cursor <cursor>", "Continue from a previous page cursor").action(async (address, options, command) => {
+    await runAllowlistListCaps(await buildFilesReadContext(command), address, options);
   });
 }
-function requireProfile(config, name) {
-  if (!(name in config.profiles)) {
-    throw new UsageError(`No profile named "${name}". Create it with: morse config add ${name} --network testnet`);
-  }
-}
-function renderProfiles(config) {
-  const names = Object.keys(config.profiles);
-  if (names.length === 0) {
-    return "No profiles configured. Add one with: morse config add <name> --network testnet";
-  }
-  return names.map((name) => {
-    const profile = config.profiles[name];
+
+// src/commands/cap.ts
+import {
+  destroyPublisherCap,
+  issuePublisherCap,
+  revokePublisherCap,
+  toPublisherCapId as toPublisherCapId2,
+  toSuiAddress as toSuiAddress4,
+  transferPublisherCap
+} from "@arcadiasystems/morse-sdk";
+
+// src/cli/target.ts
+import { toPublicationId } from "@arcadiasystems/morse-sdk";
+var OBJECT_ID = /^0x[0-9a-f]{1,64}$/i;
+var SLUG_PAGE_LIMIT = 50;
+async function resolvePublication(ctx, override) {
+  const value = override ?? ctx.settings.publication;
+  if (value === undefined) {
+    throw new UsageError("No publication selected. Pass --publication <slug|id> or run `morse use <slug|id>`.");
+  }
+  if (OBJECT_ID.test(value)) {
+    return toPublicationId(value.toLowerCase());
+  }
+  return resolveSlug(ctx, value);
+}
+function resolveCollection(ctx, override) {
+  const value = override ?? ctx.settings.collection;
+  if (value === undefined) {
+    throw new UsageError("No collection selected. Pass --collection <name> or run `morse use <slug|id> <collection>`.");
+  }
+  return value;
+}
+async function resolveSlug(ctx, slug) {
+  if (ctx.ownerAddress === undefined) {
+    throw new UsageError(`Cannot resolve the slug "${slug}" without an active account. Pass the publication id, or select an account.`);
+  }
+  ctx.output.info(`Resolving slug "${slug}" among owned publications...`);
+  let cursor;
+  do {
+    const page = await ctx.reader.listPublicationsOwnedBy(ctx.ownerAddress, {
+      limit: SLUG_PAGE_LIMIT,
+      signal: ctx.signal,
+      ...cursor === undefined ? {} : { cursor }
+    });
+    for (const owned of page.results) {
+      const publication = await ctx.reader.getPublication(owned.publicationId, ctx.signal);
+      if (publication.slug === slug) {
+        return publication.id;
+      }
+    }
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor !== undefined);
+  throw new UsageError(`No publication with slug "${slug}" owned by the active account. Pass the publication id instead.`);
+}
+
+// src/commands/cap.ts
+async function runCapList(ctx, address, options) {
+  const holder = address === undefined ? ctx.ownerAddress : toSuiAddress4(address);
+  if (holder === undefined) {
+    throw new UsageError("No address given and no active account. Pass an address or import an account.");
+  }
+  const page = await ctx.reader.listPublisherCapsOwnedBy(holder, {
+    signal: ctx.signal,
+    ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
+    ...options.cursor === undefined ? {} : { cursor: options.cursor }
+  });
+  if (page.nextCursor !== null) {
+    ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
+  }
+  ctx.output.result(renderPublisherCapList(page.results), {
+    results: page.results,
+    nextCursor: page.nextCursor
+  });
+}
+async function runCapIssue(ctx, holder, options) {
+  const id = await resolvePublication(ctx, options.publication);
+  const holderAddress = toSuiAddress4(holder);
+  ctx.output.info("Resolving OwnerCap...");
+  const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
+  const result = await issuePublisherCap(ctx.adapter, ctx.config, {
+    publicationId: id,
+    ownerCapId,
+    holder: holderAddress,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Issued PublisherCap ${result.publisherCapId} to ${holderAddress}. (tx: ${result.digest})`, result);
+}
+async function runCapRevoke(ctx, publisherCapId, options, gopts) {
+  const id = await resolvePublication(ctx, options.publication);
+  const capId = toPublisherCapId2(publisherCapId);
+  const proceed = await confirm(`Revoke PublisherCap ${capId}? It can no longer be used to write.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  ctx.output.info("Resolving OwnerCap...");
+  const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
+  const result = await revokePublisherCap(ctx.adapter, ctx.config, {
+    publicationId: id,
+    ownerCapId,
+    publisherCapId: capId,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Revoked PublisherCap ${capId}. (tx: ${result.digest})`, result);
+}
+async function runCapDestroy(ctx, publisherCapId, options, gopts) {
+  const id = await resolvePublication(ctx, options.publication);
+  const capId = toPublisherCapId2(publisherCapId);
+  const proceed = await confirm(`Destroy PublisherCap ${capId}? This is permanent.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  const result = await destroyPublisherCap(ctx.adapter, ctx.config, {
+    publicationId: id,
+    publisherCapId: capId,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Destroyed PublisherCap ${capId}. (tx: ${result.digest})`, result);
+}
+async function runCapTransfer(ctx, publisherCapId, recipient, gopts) {
+  const capId = toPublisherCapId2(publisherCapId);
+  const to = toSuiAddress4(recipient);
+  const proceed = await confirm(`Transfer PublisherCap ${capId} to ${to}?`, {
+    assumeYes: Boolean(gopts.yes),
+    signal: ctx.signal
+  });
+  if (!proceed) {
+    cancelled();
+  }
+  const result = await transferPublisherCap(ctx.adapter, ctx.config, {
+    publisherCapId: capId,
+    recipient: to,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Transferred PublisherCap ${capId} to ${to}. (tx: ${result.digest})`, result);
+}
+function registerCapCommands(program) {
+  const cap = program.command("cap").description("Manage PublisherCaps (write-access capabilities)");
+  cap.command("list [address]").description("List publisher caps held by an address (default: the active account)").option("--limit <n>", "Maximum results per page").option("--cursor <cursor>", "Continue from a previous page cursor").action(async (address, options, command) => {
+    await runCapList(await buildReadContext(command), address, options);
+  });
+  const issue = cap.command("issue <holder>").description("Issue a PublisherCap bound to an address");
+  publicationOption(ownerCapOption(issue)).action(async (holder, options, command) => {
+    await runCapIssue(await buildWriteContext(command), holder, options);
+  });
+  const revoke = cap.command("revoke <publisherCapId>").description("Revoke a PublisherCap so it can no longer write");
+  publicationOption(ownerCapOption(revoke)).action(async (publisherCapId, options, command) => {
+    await runCapRevoke(await buildWriteContext(command), publisherCapId, options, globalOptions(command));
+  });
+  const destroy = cap.command("destroy <publisherCapId>").description("Destroy a PublisherCap held by the active account");
+  publicationOption(destroy).action(async (publisherCapId, options, command) => {
+    await runCapDestroy(await buildWriteContext(command), publisherCapId, options, globalOptions(command));
+  });
+  cap.command("transfer <publisherCapId> <recipient>").description("Transfer a PublisherCap object to another address").action(async (publisherCapId, recipient, _options, command) => {
+    await runCapTransfer(await buildWriteContext(command), publisherCapId, recipient, globalOptions(command));
+  });
+}
+
+// src/commands/collection.ts
+import { createCollection, deleteCollection } from "@arcadiasystems/morse-sdk";
+async function runCollectionList(ctx, options) {
+  const id = await resolvePublication(ctx, options.publication);
+  const publication = await ctx.reader.getPublication(id, ctx.signal);
+  ctx.output.result(renderCollectionList(publication.collections), {
+    publication: id,
+    collections: publication.collections
+  });
+}
+async function runCollectionCreate(ctx, name, options, gopts) {
+  const id = await resolvePublication(ctx, options.publication);
+  const storageMode = coerceStorageMode(options.mode);
+  const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+  ctx.output.info(`Creating collection "${name}" (${storageMode})...`);
+  const result = await createCollection(ctx.adapter, ctx.config, {
+    publicationId: id,
+    publisherCapId,
+    name,
+    storageMode,
+    signal: ctx.signal
+  });
+  await updateActiveProfile(gopts, { collection: name });
+  ctx.output.result(`Created collection "${name}". Selected as the active collection. (tx: ${result.digest})`, result);
+}
+async function runCollectionDelete(ctx, name, options, gopts) {
+  const id = await resolvePublication(ctx, options.publication);
+  const proceed = await confirm(`Delete collection "${name}" from ${shortId(id)}? It must be empty.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+  const result = await deleteCollection(ctx.adapter, ctx.config, {
+    publicationId: id,
+    publisherCapId,
+    name,
+    signal: ctx.signal
+  });
+  if (ctx.settings.collection === name) {
+    await updateActiveProfile(gopts, { collection: undefined });
+  }
+  ctx.output.result(`Deleted collection "${name}". (tx: ${result.digest})`, result);
+}
+function registerCollectionCommands(program) {
+  const collection = program.command("collection").description("Manage collections within a publication");
+  const list = collection.command("list").description("List the collections in a publication");
+  publicationOption(list).action(async (options, command) => {
+    await runCollectionList(await buildReadContext(command), options);
+  });
+  const create = collection.command("create <name>").description("Create a collection and select it as the active collection").option("--mode <mode>", "Storage mode: blob or quilt", "blob");
+  publicationOption(publisherCapOption(create)).action(async (name, options, command) => {
+    await runCollectionCreate(await buildWriteContext(command), name, options, globalOptions(command));
+  });
+  const remove = collection.command("delete <name>").description("Delete an empty collection");
+  publicationOption(publisherCapOption(remove)).action(async (name, options, command) => {
+    await runCollectionDelete(await buildWriteContext(command), name, options, globalOptions(command));
+  });
+}
+
+// src/commands/config.ts
+function runConfigPath(output) {
+  const path = configFilePath();
+  output.result(path, { path });
+}
+async function runConfigList(output) {
+  const cfg = await loadConfig();
+  output.result(renderProfiles(cfg), {
+    defaultProfile: cfg.defaultProfile,
+    profiles: cfg.profiles
+  });
+}
+async function runConfigAdd(output, name, options) {
+  const network = coerceNetwork(options.network);
+  const cfg = await loadConfig();
+  const profiles = {
+    ...cfg.profiles,
+    [name]: {
+      network,
+      ...options.rpc === undefined ? {} : { rpc: options.rpc }
+    }
+  };
+  const defaultProfile = Object.keys(cfg.profiles).length === 0 ? name : cfg.defaultProfile;
+  await saveConfig({ ...cfg, profiles, defaultProfile });
+  output.result(`Saved profile "${name}" (${network}).`, {
+    profile: name,
+    network,
+    rpc: options.rpc,
+    default: defaultProfile === name
+  });
+}
+async function runConfigUse(output, name) {
+  const cfg = await loadConfig();
+  requireProfile(cfg, name);
+  await saveConfig({ ...cfg, defaultProfile: name });
+  output.result(`Default profile set to "${name}".`, { defaultProfile: name });
+}
+async function runConfigRemove(output, name) {
+  const cfg = await loadConfig();
+  requireProfile(cfg, name);
+  const { [name]: _removed, ...rest } = cfg.profiles;
+  const defaultProfile = cfg.defaultProfile === name ? Object.keys(rest)[0] ?? "default" : cfg.defaultProfile;
+  await saveConfig({ ...cfg, profiles: rest, defaultProfile });
+  output.result(`Removed profile "${name}".`, {
+    removed: name,
+    defaultProfile,
+    profiles: Object.keys(rest)
+  });
+}
+function registerConfigCommands(program) {
+  const config = program.command("config").description("Manage profiles and CLI configuration");
+  config.command("path").description("Print the config file path").action((_options, command) => {
+    runConfigPath(outputFor(command));
+  });
+  config.command("list").description("List profiles and show the default").action(async (_options, command) => {
+    await runConfigList(outputFor(command));
+  });
+  config.command("add <name>").description("Create or update a profile").requiredOption("--network <network>", "Sui network: testnet or localnet").option("--rpc <url>", "RPC URL override for this profile").action(async (name, options, command) => {
+    await runConfigAdd(outputFor(command), name, options);
+  });
+  config.command("use <name>").description("Set the default profile").action(async (name, _options, command) => {
+    await runConfigUse(outputFor(command), name);
+  });
+  config.command("remove <name>").description("Delete a profile").action(async (name, _options, command) => {
+    await runConfigRemove(outputFor(command), name);
+  });
+}
+function requireProfile(config, name) {
+  if (!(name in config.profiles)) {
+    throw new UsageError(`No profile named "${name}". Create it with: morse config add ${name} --network testnet`);
+  }
+}
+function renderProfiles(config) {
+  const names = Object.keys(config.profiles);
+  if (names.length === 0) {
+    return "No profiles configured. Add one with: morse config add <name> --network testnet";
+  }
+  return names.map((name) => {
+    const profile = config.profiles[name];
     if (profile === undefined) {
       return name;
     }
@@ -1462,333 +1793,690 @@ import {
 import { SessionKey } from "@mysten/seal";
 var SESSION_KEY_TTL_MIN = 10;
 var SEAL_NONCE_BYTES = 16;
+async function runEntryAddEncrypted(ctx, name, options) {
+  const id = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  const epochs = parsePositiveInt(options.epochs, "--epochs");
+  const plaintext = await readContentBytes(options);
+  const contentType = resolveContentType(options.contentType, options.stdin ? undefined : options.file);
+  const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+  const sealId = buildPublisherSealId(id, crypto.getRandomValues(new Uint8Array(SEAL_NONCE_BYTES)));
+  ctx.output.info(`Encrypting and uploading ${plaintext.length} bytes...`);
+  const result = await addEncryptedEntryFromBytes(ctx.adapter, ctx.config, {
+    walrus: ctx.walrus,
+    seal: ctx.seal,
+    publicationId: id,
+    publisherCapId,
+    collectionName: collection,
+    name,
+    plaintext,
+    contentType,
+    sealId,
+    upload: { epochs, deletable: true },
+    signal: ctx.signal
+  });
+  ctx.output.result(`Added encrypted entry #${result.entryId} "${name}". (tx: ${result.digest})`, { ...result, sealId });
+}
+async function runEntryDecrypt(ctx, entryId, revisionId, options) {
+  if (ctx.output.isJson && options.out === undefined) {
+    throw new UsageError("Decrypting to stdout is not supported in --json mode; pass --out <path>.");
+  }
+  const id = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  const numericEntryId = parseId(entryId, "entryId");
+  const entryData = await ctx.reader.getEntry(id, collection, numericEntryId, ctx.signal);
+  if (revisionId === undefined && entryData.revisions.length === 0) {
+    throw new UsageError(`Entry #${numericEntryId} has no revisions.`);
+  }
+  const revisionIndex = revisionId === undefined ? entryData.revisions.length - 1 : parseId(revisionId, "revision");
+  const revision = entryData.revisions[revisionIndex];
+  if (revision === undefined) {
+    throw new UsageError(`Entry #${numericEntryId} has no revision at index ${revisionIndex}.`);
+  }
+  if (!revision.encrypted || revision.sealId === null) {
+    throw new UsageError(`Revision #${revisionIndex} of entry #${numericEntryId} is not encrypted.`);
+  }
+  const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+  ctx.output.info("Fetching ciphertext from Walrus...");
+  const ciphertext = await ctx.walrusRead.readBlobRef(revision.blobRef, {
+    signal: ctx.signal
+  });
+  ctx.output.info("Signing a SessionKey with the active account...");
+  const sessionKey = await SessionKey.create({
+    address: ctx.address,
+    packageId: ctx.config.originalPackageId ?? ctx.config.packageId,
+    ttlMin: SESSION_KEY_TTL_MIN,
+    signer: ctx.keypair,
+    suiClient: ctx.client
+  });
+  const plaintext = await ctx.seal.decrypt(ciphertext, {
+    sessionKey,
+    sealId: revision.sealId,
+    publisherCapId
+  });
+  if (options.out !== undefined) {
+    await writeFileContents(options.out, plaintext);
+    ctx.output.result(`Wrote ${plaintext.length} bytes to ${options.out}.`, {
+      entryId: numericEntryId,
+      revisionId: revisionIndex,
+      bytes: plaintext.length,
+      contentType: revision.contentType,
+      out: options.out
+    });
+    return;
+  }
+  process.stdout.write(plaintext);
+}
 function registerEncryptedEntryCommands(entry) {
   const add = entry.command("add-encrypted <name>").description("Encrypt a file or stdin with Seal and add it as a new entry");
   collectionOption(publicationOption(publisherCapOption(contentOptions(add)))).action(async (name, options, command) => {
-    const ctx = await buildEncryptContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const collection = resolveCollection(ctx, options.collection);
-    const epochs = parsePositiveInt(options.epochs, "--epochs");
-    const plaintext = await readContentBytes(options);
-    const contentType = resolveContentType(options.contentType, options.stdin ? undefined : options.file);
-    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
-    const sealId = buildPublisherSealId(id, crypto.getRandomValues(new Uint8Array(SEAL_NONCE_BYTES)));
-    ctx.output.info(`Encrypting and uploading ${plaintext.length} bytes...`);
-    const result = await addEncryptedEntryFromBytes(ctx.adapter, ctx.config, {
-      walrus: ctx.walrus,
-      seal: ctx.seal,
-      publicationId: id,
-      publisherCapId,
-      collectionName: collection,
-      name,
-      plaintext,
-      contentType,
-      sealId,
-      upload: { epochs, deletable: true },
-      signal: ctx.signal
-    });
-    ctx.output.result(`Added encrypted entry #${result.entryId} "${name}". (tx: ${result.digest})`, { ...result, sealId });
+    await runEntryAddEncrypted(await buildEncryptContext(command), name, options);
   });
   const decrypt = entry.command("decrypt <entryId> [revisionIndex]").description("Decrypt an encrypted revision by zero-based index (default: latest); signs a SessionKey with the active account").option("--out <path>", "Write plaintext to a file instead of stdout");
-  collectionOption(publicationOption(publisherCapOption(decrypt))).action(async (entryId, revisionId, options, command) => {
-    const ctx = await buildDecryptContext(command);
-    if (ctx.output.isJson && options.out === undefined) {
-      throw new UsageError("Decrypting to stdout is not supported in --json mode; pass --out <path>.");
-    }
-    const id = await resolvePublication(ctx, options.publication);
-    const collection = resolveCollection(ctx, options.collection);
-    const numericEntryId = parseId(entryId, "entryId");
-    const entryData = await ctx.reader.getEntry(id, collection, numericEntryId, ctx.signal);
-    if (revisionId === undefined && entryData.revisions.length === 0) {
-      throw new UsageError(`Entry #${numericEntryId} has no revisions.`);
-    }
-    const revisionIndex = revisionId === undefined ? entryData.revisions.length - 1 : parseId(revisionId, "revision");
-    const revision = entryData.revisions[revisionIndex];
-    if (revision === undefined) {
-      throw new UsageError(`Entry #${numericEntryId} has no revision at index ${revisionIndex}.`);
-    }
-    if (!revision.encrypted || revision.sealId === null) {
-      throw new UsageError(`Revision #${revisionIndex} of entry #${numericEntryId} is not encrypted.`);
-    }
-    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
-    ctx.output.info("Fetching ciphertext from Walrus...");
-    const ciphertext = await ctx.walrusRead.readBlobRef(revision.blobRef, {
-      signal: ctx.signal
-    });
-    ctx.output.info("Signing a SessionKey with the active account...");
-    const sessionKey = await SessionKey.create({
-      address: ctx.address,
-      packageId: ctx.config.originalPackageId ?? ctx.config.packageId,
-      ttlMin: SESSION_KEY_TTL_MIN,
-      signer: ctx.keypair,
-      suiClient: ctx.client
-    });
-    const plaintext = await ctx.seal.decrypt(ciphertext, {
-      sessionKey,
-      sealId: revision.sealId,
-      publisherCapId
-    });
-    if (options.out !== undefined) {
-      await writeFileContents(options.out, plaintext);
-      ctx.output.result(`Wrote ${plaintext.length} bytes to ${options.out}.`, {
-        entryId: numericEntryId,
-        revisionId: revisionIndex,
-        bytes: plaintext.length,
-        contentType: revision.contentType,
-        out: options.out
-      });
-      return;
-    }
-    process.stdout.write(plaintext);
+  collectionOption(publicationOption(publisherCapOption(viaAggregatorOption(decrypt)))).action(async (entryId, revisionId, options, command) => {
+    await runEntryDecrypt(await buildDecryptContext(command, {
+      viaAggregator: options.viaAggregator
+    }), entryId, revisionId, options);
   });
 }
 
 // src/commands/entry.ts
+async function runEntryGet(ctx, entryId, options) {
+  const id = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  const result = await ctx.reader.getEntry(id, collection, parseId(entryId, "entryId"), ctx.signal);
+  ctx.output.result(renderEntry(result), result);
+}
+async function runEntryList(ctx, options) {
+  const id = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  const page = await ctx.reader.listEntries(id, collection, {
+    signal: ctx.signal,
+    ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
+    ...options.cursor === undefined ? {} : { cursor: options.cursor }
+  });
+  if (page.nextCursor !== null) {
+    ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
+  }
+  ctx.output.result(renderEntryList(page.results), {
+    results: page.results,
+    nextCursor: page.nextCursor
+  });
+}
+async function runEntryScan(ctx, options) {
+  const id = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  const entries = [];
+  for await (const item of ctx.reader.scanEntries(id, collection, {
+    signal: ctx.signal
+  })) {
+    entries.push(item);
+  }
+  ctx.output.result(renderEntryList(entries), { results: entries });
+}
+async function runEntryAdd(ctx, name, options) {
+  const id = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  const epochs = parsePositiveInt(options.epochs, "--epochs");
+  const bytes = await readContentBytes(options);
+  const contentType = resolveContentType(options.contentType, options.stdin ? undefined : options.file);
+  const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+  ctx.output.info(`Uploading ${bytes.length} bytes to Walrus...`);
+  const result = await addEntryFromBytes(ctx.adapter, ctx.config, {
+    walrus: ctx.walrus,
+    publicationId: id,
+    publisherCapId,
+    collectionName: collection,
+    name,
+    bytes,
+    contentType,
+    upload: { epochs, deletable: true },
+    signal: ctx.signal
+  });
+  const aggregator = ctx.config.walrusEndpoints.aggregator;
+  const viewUrl = aggregator.length > 0 ? `${aggregator}/v1/blobs/${result.blobId}` : undefined;
+  const human = viewUrl === undefined ? `Added entry #${result.entryId} "${name}". (tx: ${result.digest})` : `Added entry #${result.entryId} "${name}". (tx: ${result.digest})
+  view: ${viewUrl}`;
+  ctx.output.result(human, { ...result, viewUrl: viewUrl ?? null });
+}
+async function runEntryDelete(ctx, entryId, options, gopts) {
+  const id = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  const numericEntryId = parseId(entryId, "entryId");
+  const proceed = await confirm(`Delete entry #${numericEntryId} from ${shortId(id)}/${collection}? This cannot be undone.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
+  const result = await deleteEntry(ctx.adapter, ctx.config, {
+    publicationId: id,
+    publisherCapId,
+    collectionName: collection,
+    entryId: numericEntryId,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Deleted entry #${numericEntryId}. (tx: ${result.digest})`, result);
+}
+async function runEntryRead(ctx, entryId, revisionId, options) {
+  if (ctx.output.isJson && options.out === undefined) {
+    throw new UsageError("Reading content to stdout is not supported in --json mode; pass --out <path>.");
+  }
+  const id = await resolvePublication(ctx, options.publication);
+  const collection = resolveCollection(ctx, options.collection);
+  const numericEntryId = parseId(entryId, "entryId");
+  const entryData = await ctx.reader.getEntry(id, collection, numericEntryId, ctx.signal);
+  if (revisionId === undefined && entryData.revisions.length === 0) {
+    throw new UsageError(`Entry #${numericEntryId} has no revisions.`);
+  }
+  const revisionIndex = revisionId === undefined ? entryData.revisions.length - 1 : parseId(revisionId, "revision");
+  const revision = entryData.revisions[revisionIndex];
+  if (revision === undefined) {
+    throw new UsageError(`Entry #${numericEntryId} has no revision at index ${revisionIndex}.`);
+  }
+  if (revision.encrypted) {
+    throw new UsageError(`Revision #${revisionIndex} of entry #${numericEntryId} is encrypted; use \`morse entry decrypt\`.`);
+  }
+  ctx.output.info("Fetching content from Walrus...");
+  const bytes = await ctx.walrusRead.readBlobRef(revision.blobRef, {
+    signal: ctx.signal
+  });
+  if (options.out !== undefined) {
+    await writeFileContents(options.out, bytes);
+    ctx.output.result(`Wrote ${bytes.length} bytes to ${options.out}.`, {
+      entryId: numericEntryId,
+      revisionId: revisionIndex,
+      bytes: bytes.length,
+      contentType: revision.contentType,
+      out: options.out
+    });
+    return;
+  }
+  process.stdout.write(bytes);
+}
 function registerEntryCommands(program) {
   const entry = program.command("entry").description("Read, add, and delete entries in a collection");
   const get = entry.command("get <entryId>").description("Fetch a single entry");
   collectionOption(publicationOption(get)).action(async (entryId, options, command) => {
-    const ctx = await buildReadContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const collection = resolveCollection(ctx, options.collection);
-    const result = await ctx.reader.getEntry(id, collection, parseId(entryId, "entryId"), ctx.signal);
-    ctx.output.result(renderEntry(result), result);
+    await runEntryGet(await buildReadContext(command), entryId, options);
   });
   const list = entry.command("list").description("List entries in a collection").option("--limit <n>", "Maximum results per page").option("--cursor <cursor>", "Continue from a previous page cursor");
   collectionOption(publicationOption(list)).action(async (options, command) => {
-    const ctx = await buildReadContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const collection = resolveCollection(ctx, options.collection);
-    const page = await ctx.reader.listEntries(id, collection, {
-      signal: ctx.signal,
-      ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
-      ...options.cursor === undefined ? {} : { cursor: options.cursor }
-    });
-    if (page.nextCursor !== null) {
-      ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
-    }
-    ctx.output.result(renderEntryList(page.results), {
-      results: page.results,
-      nextCursor: page.nextCursor
-    });
+    await runEntryList(await buildReadContext(command), options);
   });
   const scan = entry.command("scan").description("List every entry in a collection (auto-paginated)");
   collectionOption(publicationOption(scan)).action(async (options, command) => {
-    const ctx = await buildReadContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const collection = resolveCollection(ctx, options.collection);
-    const entries = [];
-    for await (const item of ctx.reader.scanEntries(id, collection, {
-      signal: ctx.signal
-    })) {
-      entries.push(item);
-    }
-    ctx.output.result(renderEntryList(entries), { results: entries });
+    await runEntryScan(await buildReadContext(command), options);
   });
   const add = entry.command("add <name>").description("Upload content from a file or stdin and add it as a new entry");
   collectionOption(publicationOption(publisherCapOption(contentOptions(add)))).action(async (name, options, command) => {
-    const ctx = await buildContentContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const collection = resolveCollection(ctx, options.collection);
-    const epochs = parsePositiveInt(options.epochs, "--epochs");
-    const bytes = await readContentBytes(options);
-    const contentType = resolveContentType(options.contentType, options.stdin ? undefined : options.file);
-    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
-    ctx.output.info(`Uploading ${bytes.length} bytes to Walrus...`);
-    const result = await addEntryFromBytes(ctx.adapter, ctx.config, {
-      walrus: ctx.walrus,
-      publicationId: id,
-      publisherCapId,
-      collectionName: collection,
-      name,
-      bytes,
-      contentType,
-      upload: { epochs, deletable: true },
-      signal: ctx.signal
-    });
-    const aggregator = ctx.config.walrusEndpoints.aggregator;
-    const viewUrl = aggregator.length > 0 ? `${aggregator}/v1/blobs/${result.blobId}` : undefined;
-    const human = viewUrl === undefined ? `Added entry #${result.entryId} "${name}". (tx: ${result.digest})` : `Added entry #${result.entryId} "${name}". (tx: ${result.digest})
-  view: ${viewUrl}`;
-    ctx.output.result(human, { ...result, viewUrl: viewUrl ?? null });
+    await runEntryAdd(await buildContentContext(command), name, options);
   });
   const remove = entry.command("delete <entryId>").description("Delete an entry and its revisions");
   collectionOption(publicationOption(publisherCapOption(remove))).action(async (entryId, options, command) => {
-    const ctx = await buildWriteContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const collection = resolveCollection(ctx, options.collection);
-    const numericEntryId = parseId(entryId, "entryId");
-    const proceed = await confirm(`Delete entry #${numericEntryId} from ${shortId(id)}/${collection}? This cannot be undone.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
-    if (!proceed) {
-      cancelled();
-    }
-    const publisherCapId = await resolvePublisherCap(ctx.reader, ctx.address, id, options.publisherCap, ctx.signal);
-    const result = await deleteEntry(ctx.adapter, ctx.config, {
-      publicationId: id,
-      publisherCapId,
-      collectionName: collection,
-      entryId: numericEntryId,
-      signal: ctx.signal
-    });
-    ctx.output.result(`Deleted entry #${numericEntryId}. (tx: ${result.digest})`, result);
+    await runEntryDelete(await buildWriteContext(command), entryId, options, globalOptions(command));
   });
   const read = entry.command("read <entryId> [revisionIndex]").description("Fetch a public entry's content to stdout or a file").option("--out <path>", "Write content to a file instead of stdout");
-  collectionOption(publicationOption(read)).action(async (entryId, revisionId, options, command) => {
-    const ctx = await buildReadContentContext(command);
-    if (ctx.output.isJson && options.out === undefined) {
-      throw new UsageError("Reading content to stdout is not supported in --json mode; pass --out <path>.");
-    }
-    const id = await resolvePublication(ctx, options.publication);
-    const collection = resolveCollection(ctx, options.collection);
-    const numericEntryId = parseId(entryId, "entryId");
-    const entryData = await ctx.reader.getEntry(id, collection, numericEntryId, ctx.signal);
-    if (revisionId === undefined && entryData.revisions.length === 0) {
-      throw new UsageError(`Entry #${numericEntryId} has no revisions.`);
+  collectionOption(publicationOption(viaAggregatorOption(read))).action(async (entryId, revisionId, options, command) => {
+    await runEntryRead(await buildReadContentContext(command, {
+      viaAggregator: options.viaAggregator
+    }), entryId, revisionId, options);
+  });
+  registerEncryptedEntryCommands(entry);
+}
+
+// src/commands/file.ts
+import {
+  buildAllowlistSealId,
+  createEncryptedFile,
+  createPublicFile,
+  deleteFile,
+  reconcileFilesAccessibleBy,
+  reconcileFilesOwnedBy,
+  toAllowlistId as toAllowlistId2,
+  toBlobObjectId,
+  toEncryptedFileId,
+  toSuiAddress as toSuiAddress5,
+  toWalrusBlobId,
+  transferFileOwnership,
+  updateFileMetadata,
+  uploadEncryptedFileFromBytes,
+  uploadPublicFileFromBytes
+} from "@arcadiasystems/morse-sdk";
+import { SessionKey as SessionKey2 } from "@mysten/seal";
+
+// src/cli/events.ts
+var PAGE_LIMIT2 = 50;
+async function fetchEventStream(client, eventType, signal) {
+  const out = [];
+  let cursor;
+  for (;; ) {
+    const page = await client.queryEvents({
+      query: { MoveEventType: eventType },
+      limit: PAGE_LIMIT2,
+      order: "descending",
+      ...cursor === undefined ? {} : { cursor },
+      ...signal === undefined ? {} : { signal }
+    });
+    for (const event of page.data) {
+      out.push({
+        type: event.type,
+        parsedJson: event.parsedJson,
+        timestampMs: event.timestampMs
+      });
     }
-    const revisionIndex = revisionId === undefined ? entryData.revisions.length - 1 : parseId(revisionId, "revision");
-    const revision = entryData.revisions[revisionIndex];
-    if (revision === undefined) {
-      throw new UsageError(`Entry #${numericEntryId} has no revision at index ${revisionIndex}.`);
+    if (!page.hasNextPage || page.nextCursor === null || page.nextCursor === undefined) {
+      break;
     }
-    if (revision.encrypted) {
-      throw new UsageError(`Revision #${revisionIndex} of entry #${numericEntryId} is encrypted; use \`morse entry decrypt\`.`);
+    cursor = page.nextCursor;
+  }
+  return out;
+}
+async function fetchEventStreams(client, eventTypes, signal) {
+  const streams = await Promise.all(eventTypes.map((type) => fetchEventStream(client, type, signal)));
+  return streams.flat();
+}
+
+// src/format/hex.ts
+var HEX = /^[0-9a-fA-F]+$/;
+function encodeHex(bytes) {
+  let out = "0x";
+  for (const byte of bytes) {
+    out += byte.toString(16).padStart(2, "0");
+  }
+  return out;
+}
+function decodeHex(value) {
+  const body = value.startsWith("0x") ? value.slice(2) : value;
+  if (body.length === 0 || body.length % 2 !== 0 || !HEX.test(body)) {
+    throw new UsageError(`Invalid hex value: expected an even number of hex digits, got ${JSON.stringify(value)}.`);
+  }
+  const bytes = new Uint8Array(body.length / 2);
+  for (let i = 0;i < bytes.length; i += 1) {
+    bytes[i] = Number.parseInt(body.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+
+// src/commands/file.ts
+var SESSION_KEY_TTL_MIN2 = 10;
+var SEAL_NONCE_BYTES2 = 16;
+function uploadProgress(output) {
+  const labels = {
+    encrypting: "Encrypting...",
+    uploading: "Uploading to Walrus...",
+    submitting: "Submitting transaction...",
+    complete: ""
+  };
+  return (event) => {
+    const label = labels[event.phase];
+    if (label.length > 0) {
+      output.info(label);
     }
-    ctx.output.info("Fetching content from Walrus...");
-    const bytes = await ctx.walrusRead.readBlobRef(revision.blobRef, {
+  };
+}
+async function runFileGet(ctx, target) {
+  const result = await ctx.filesReader.getEncryptedFile(toEncryptedFileId(target), ctx.signal);
+  ctx.output.result(renderEncryptedFile(result), result);
+}
+async function runFileRegister(ctx, options) {
+  if (options.allowlist === undefined && options.public !== true) {
+    throw new UsageError("Pass --allowlist <id> to register an encrypted file, or --public for a world-readable one.");
+  }
+  const blobId = toWalrusBlobId(options.blobId);
+  const size = parseByteSize(options.size, "--size");
+  const blobObjectId = options.blobObjectId === undefined ? undefined : toBlobObjectId(options.blobObjectId);
+  if (options.allowlist !== undefined) {
+    const result2 = await createEncryptedFile(ctx.adapter, ctx.config, {
+      allowlistId: toAllowlistId2(options.allowlist),
+      blobId,
+      ...blobObjectId === undefined ? {} : { blobObjectId },
+      name: options.name,
+      contentType: options.contentType,
+      size,
       signal: ctx.signal
     });
-    if (options.out !== undefined) {
-      await writeFileContents(options.out, bytes);
-      ctx.output.result(`Wrote ${bytes.length} bytes to ${options.out}.`, {
-        entryId: numericEntryId,
-        revisionId: revisionIndex,
-        bytes: bytes.length,
-        contentType: revision.contentType,
-        out: options.out
-      });
-      return;
+    ctx.output.result(`Registered encrypted file ${result2.fileId}. (tx: ${result2.digest})`, result2);
+    return;
+  }
+  const result = await createPublicFile(ctx.adapter, ctx.config, {
+    blobId,
+    ...blobObjectId === undefined ? {} : { blobObjectId },
+    name: options.name,
+    contentType: options.contentType,
+    size,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Registered public file ${result.fileId}. (tx: ${result.digest})`, result);
+}
+async function runFileUpdate(ctx, target, options) {
+  const result = await updateFileMetadata(ctx.adapter, ctx.config, {
+    fileId: toEncryptedFileId(target),
+    name: options.name,
+    contentType: options.contentType,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Updated file ${shortId(target)} metadata. (tx: ${result.digest})`, result);
+}
+async function runFileTransferOwnership(ctx, target, newOwner, gopts) {
+  const fileId = toEncryptedFileId(target);
+  const to = toSuiAddress5(newOwner);
+  const proceed = await confirm(`Transfer metadata ownership of file ${shortId(fileId)} to ${to}? Decryption access is governed separately by the allowlist.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  const result = await transferFileOwnership(ctx.adapter, ctx.config, {
+    fileId,
+    newOwner: to,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Transferred file ownership to ${to}. (tx: ${result.digest})`, result);
+}
+async function runFileDelete(ctx, target, gopts) {
+  const fileId = toEncryptedFileId(target);
+  const proceed = await confirm(`Delete file metadata ${shortId(fileId)}? The Walrus blob is not deleted; it expires on its own lease.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  const result = await deleteFile(ctx.adapter, ctx.config, {
+    fileId,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Deleted file ${fileId}. (tx: ${result.digest})`, result);
+}
+async function runFileUpload(ctx, path, options) {
+  if (options.allowlist === undefined && options.public !== true) {
+    throw new UsageError("Pass --allowlist <id> to upload an encrypted file, or --public for a world-readable one.");
+  }
+  const epochs = parsePositiveInt(options.epochs ?? "3", "--epochs");
+  const bytes = await readContentBytes({ file: path });
+  const contentType = resolveContentType(options.contentType, path);
+  const upload = { epochs, deletable: true };
+  const onProgress = uploadProgress(ctx.output);
+  if (options.allowlist !== undefined) {
+    const allowlistId = toAllowlistId2(options.allowlist);
+    const sealId = buildAllowlistSealId(allowlistId, crypto.getRandomValues(new Uint8Array(SEAL_NONCE_BYTES2)));
+    const result2 = await uploadEncryptedFileFromBytes(ctx.adapter, ctx.config, {
+      walrus: ctx.walrus,
+      seal: ctx.seal,
+      allowlistId,
+      sealId,
+      plaintext: bytes,
+      name: options.name,
+      contentType,
+      upload,
+      signal: ctx.signal,
+      onProgress
+    });
+    const sealIdHex = encodeHex(sealId);
+    const human2 = [
+      `Uploaded encrypted file ${result2.fileId}`,
+      `  blobId: ${result2.blobId}`,
+      `  sealId: ${sealIdHex}`,
+      `  tx:     ${result2.digest}`,
+      "Save the seal id: decrypting later needs it plus allowlist membership."
+    ].join(`
+`);
+    ctx.output.result(human2, { ...result2, sealId: sealIdHex });
+    return;
+  }
+  const result = await uploadPublicFileFromBytes(ctx.adapter, ctx.config, {
+    walrus: ctx.walrus,
+    bytes,
+    name: options.name,
+    contentType,
+    upload,
+    signal: ctx.signal,
+    onProgress
+  });
+  const aggregator = ctx.config.walrusEndpoints.aggregator;
+  const viewUrl = aggregator.length > 0 ? `${aggregator}/v1/blobs/${result.blobId}` : undefined;
+  const human = viewUrl === undefined ? `Uploaded public file ${result.fileId}. (tx: ${result.digest})` : `Uploaded public file ${result.fileId}. (tx: ${result.digest})
+  view: ${viewUrl}`;
+  ctx.output.result(human, { ...result, viewUrl: viewUrl ?? null });
+}
+async function decryptFile(ctx, file, ciphertext, sealIdHex) {
+  if (sealIdHex === undefined) {
+    throw new UsageError("This file is encrypted; pass --seal-id <hex> (printed when the file was uploaded).");
+  }
+  if (file.allowlistId === null) {
+    throw new UsageError(`File ${file.id} is marked encrypted but carries no allowlist; it cannot be decrypted.`);
+  }
+  const sealId = decodeHex(sealIdHex);
+  const { keypair, address } = await ctx.unlockSigner();
+  ctx.output.info("Signing a SessionKey with the active account...");
+  const sessionKey = await SessionKey2.create({
+    address,
+    packageId: ctx.config.originalPackageId ?? ctx.config.packageId,
+    ttlMin: SESSION_KEY_TTL_MIN2,
+    signer: keypair,
+    suiClient: ctx.client
+  });
+  return ctx.seal.decryptUnderAllowlist(ciphertext, {
+    sealId,
+    allowlistId: file.allowlistId,
+    sessionKey
+  });
+}
+async function runFileDownload(ctx, target, options) {
+  if (ctx.output.isJson && options.out === undefined) {
+    throw new UsageError("Downloading content to stdout is not supported in --json mode; pass --out <path>.");
+  }
+  const file = await ctx.filesReader.getEncryptedFile(toEncryptedFileId(target), ctx.signal);
+  ctx.output.info("Fetching content from Walrus...");
+  const bytes = await ctx.walrusRead.readBlob(file.blobId, {
+    signal: ctx.signal
+  });
+  let content = bytes;
+  if (file.encrypted) {
+    content = await decryptFile(ctx, file, bytes, options.sealId);
+  }
+  if (options.out !== undefined) {
+    await writeFileContents(options.out, content);
+    ctx.output.result(`Wrote ${content.length} bytes to ${options.out}.`, {
+      fileId: file.id,
+      name: file.name,
+      contentType: file.contentType,
+      bytes: content.length,
+      out: options.out
+    });
+    return;
+  }
+  process.stdout.write(content);
+}
+async function runFileList(ctx, options) {
+  const limit = options.limit === undefined ? undefined : parseLimit(options.limit);
+  const address = options.address === undefined ? ctx.ownerAddress : toSuiAddress5(options.address);
+  if (address === undefined) {
+    throw new UsageError("No address given and no active account. Pass --address or import an account.");
+  }
+  const types = ctx.eventTypes;
+  let summaries;
+  if (options.accessible) {
+    ctx.output.info("Fetching membership and file events...");
+    const events = await fetchEventStreams(ctx.events, [
+      types.MemberAdded,
+      types.MemberRemoved,
+      types.AllowlistDeleted,
+      types.FileCreated,
+      types.FileDeleted
+    ], ctx.signal);
+    summaries = reconcileFilesAccessibleBy(events, address, types);
+  } else {
+    ctx.output.info("Fetching file events...");
+    const events = await fetchEventStreams(ctx.events, [types.FileCreated, types.FileOwnershipTransferred, types.FileDeleted], ctx.signal);
+    summaries = reconcileFilesOwnedBy(events, address, types);
+  }
+  const limited = limit === undefined ? summaries : summaries.slice(0, limit);
+  let items = limited;
+  if (options.hydrate) {
+    ctx.output.info(`Hydrating ${limited.length} file(s)...`);
+    const full = [];
+    for (const summary of limited) {
+      const record = await ctx.filesReader.getEncryptedFile(summary.id, ctx.signal);
+      full.push({ ...record, kind: "full" });
     }
-    process.stdout.write(bytes);
+    items = full;
+  }
+  ctx.output.result(renderFileList(items), items);
+}
+function registerFileCommands(program) {
+  const file = program.command("file").description("Upload, register, read, and manage files on Walrus");
+  const upload = file.command("upload <path>").description("Encrypt (or not), upload to Walrus, and register a file").requiredOption("-n, --name <name>", "File name").option("--public", "Upload a world-readable (unencrypted) file").option("--content-type <mime>", "MIME content type (inferred from the path if omitted)").option("--epochs <n>", "Walrus storage epochs", "3");
+  allowlistOption(upload).action(async (path, options, command) => {
+    await runFileUpload(await buildEncryptContext(command), path, options);
+  });
+  file.command("list").description("List files owned by (or accessible to) an address, via event indexing").option("--address <addr>", "Address to query (default: the active account)").option("--accessible", "List files you can decrypt via allowlist membership, not just owned").option("--hydrate", "Fetch full records (adds blobId; one read per file)").option("--limit <n>", "Cap the number of results").option("--indexer-url <url>", "Event source URL (default: the RPC; uses suix_queryEvents, a deprecated Sui endpoint)").action(async (options, command) => {
+    await runFileList(await buildFileListContext(command, {
+      indexerUrl: options.indexerUrl
+    }), options);
+  });
+  const download = file.command("download <file>").description("Download a file's content; decrypts in place when encrypted").option("--out <path>", "Write content to a file instead of stdout").option("--seal-id <hex>", "Seal id from upload (required to decrypt an encrypted file)");
+  viaAggregatorOption(download).action(async (target, options, command) => {
+    await runFileDownload(await buildFileDownloadContext(command, {
+      viaAggregator: options.viaAggregator
+    }), target, options);
+  });
+  file.command("get <file>").description("Fetch a file's on-chain metadata").action(async (target, _options, command) => {
+    await runFileGet(await buildFilesReadContext(command), target);
+  });
+  const register = file.command("register").description("Register on-chain metadata for a blob already on Walrus").requiredOption("--blob-id <id>", "Walrus content id").requiredOption("-n, --name <name>", "File name").requiredOption("--content-type <mime>", "MIME content type").requiredOption("--size <bytes>", "Plaintext byte length").option("--public", "Register a world-readable (unencrypted) file").option("--blob-object-id <id>", "On-chain Walrus Blob object id, if known");
+  allowlistOption(register).action(async (options, command) => {
+    await runFileRegister(await buildWriteContext(command), options);
+  });
+  file.command("update <file>").description("Update a file's name and content type (owner only)").requiredOption("-n, --name <name>", "New file name").requiredOption("--content-type <mime>", "New MIME content type").action(async (target, options, command) => {
+    await runFileUpdate(await buildWriteContext(command), target, options);
+  });
+  file.command("transfer-ownership <file> <newOwner>").description("Transfer a file's metadata-mutation right (not decrypt access)").action(async (target, newOwner, _options, command) => {
+    await runFileTransferOwnership(await buildWriteContext(command), target, newOwner, globalOptions(command));
+  });
+  file.command("delete <file>").description("Delete a file's metadata record (does not delete the blob)").action(async (target, _options, command) => {
+    await runFileDelete(await buildWriteContext(command), target, globalOptions(command));
   });
-  registerEncryptedEntryCommands(entry);
 }
 
 // src/commands/publication.ts
 import {
   createPublication,
   deletePublication,
-  toSuiAddress as toSuiAddress4,
+  toSuiAddress as toSuiAddress6,
   transferOwnership
 } from "@arcadiasystems/morse-sdk";
+async function runPublicationGet(ctx, target) {
+  const id = await resolvePublication(ctx, target);
+  const result = await ctx.reader.getPublication(id, ctx.signal);
+  ctx.output.result(renderPublication(result), result);
+}
+async function runPublicationList(ctx, address, options) {
+  const owner = address === undefined ? ctx.ownerAddress : toSuiAddress6(address);
+  if (owner === undefined) {
+    throw new UsageError("No address given and no active account. Pass an address or import an account.");
+  }
+  const page = await ctx.reader.listPublicationsOwnedBy(owner, {
+    signal: ctx.signal,
+    ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
+    ...options.cursor === undefined ? {} : { cursor: options.cursor }
+  });
+  if (page.nextCursor !== null) {
+    ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
+  }
+  if (options.idsOnly) {
+    ctx.output.result(renderPublicationList(page.results), {
+      results: page.results,
+      nextCursor: page.nextCursor
+    });
+    return;
+  }
+  const enriched = [];
+  for (const owned of page.results) {
+    const pub = await ctx.reader.getPublication(owned.publicationId, ctx.signal);
+    enriched.push({
+      slug: pub.slug,
+      name: pub.name,
+      publicationId: owned.publicationId,
+      ownerCapId: owned.ownerCapId
+    });
+  }
+  ctx.output.result(renderEnrichedPublicationList(enriched), {
+    results: enriched,
+    nextCursor: page.nextCursor
+  });
+}
+async function runPublicationCreate(ctx, options, gopts) {
+  ctx.output.info(`Creating "${options.name}"...`);
+  const result = await createPublication(ctx.adapter, ctx.config, {
+    name: options.name,
+    slug: options.slug,
+    signal: ctx.signal
+  });
+  await updateActiveProfile(gopts, {
+    publication: result.publicationId,
+    collection: undefined
+  });
+  const human = [
+    `Created "${options.name}" (${result.publicationId})`,
+    `  ownerCap:     ${result.ownerCapId}`,
+    `  publisherCap: ${result.publisherCapId}`,
+    `  tx:           ${result.digest}`,
+    "Selected as the active publication."
+  ].join(`
+`);
+  ctx.output.result(human, result);
+}
+async function runPublicationDelete(ctx, target, options, gopts) {
+  const id = await resolvePublication(ctx, target);
+  const proceed = await confirm(`Delete publication ${shortId(id)}? This cannot be undone.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  ctx.output.info("Resolving OwnerCap...");
+  const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
+  ctx.output.info("Deleting...");
+  const result = await deletePublication(ctx.reader, ctx.adapter, ctx.config, {
+    publicationId: id,
+    ownerCapId,
+    signal: ctx.signal
+  });
+  if (ctx.settings.publication === id) {
+    await updateActiveProfile(gopts, {
+      publication: undefined,
+      collection: undefined
+    });
+  }
+  ctx.output.result(`Deleted ${id}. (tx: ${result.digest})`, result);
+}
+async function runPublicationTransferOwnership(ctx, recipient, options, gopts) {
+  const id = await resolvePublication(ctx, options.publication);
+  const to = toSuiAddress6(recipient);
+  const proceed = await confirm(`Transfer ownership of ${shortId(id)} to ${to}? You will lose owner control.`, { assumeYes: Boolean(gopts.yes), signal: ctx.signal });
+  if (!proceed) {
+    cancelled();
+  }
+  ctx.output.info("Resolving OwnerCap...");
+  const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
+  const result = await transferOwnership(ctx.adapter, ctx.config, {
+    ownerCapId,
+    recipient: to,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Transferred ownership of ${id} to ${to}. (tx: ${result.digest})`, result);
+}
 function registerPublicationCommands(program) {
   const publication = program.command("publication").alias("pub").description("Work with publications");
   publication.command("get [publication]").description("Fetch a publication (slug or id; default: the active publication)").action(async (target, _options, command) => {
-    const ctx = await buildReadContext(command);
-    const id = await resolvePublication(ctx, target);
-    const result = await ctx.reader.getPublication(id, ctx.signal);
-    ctx.output.result(renderPublication(result), result);
+    await runPublicationGet(await buildReadContext(command), target);
   });
   publication.command("list [address]").description("List publications owned by an address (default: the active account)").option("--limit <n>", "Maximum results per page").option("--cursor <cursor>", "Continue from a previous page cursor").option("--ids-only", "Skip slug/name resolution (one RPC, no per-publication reads)").action(async (address, options, command) => {
-    const ctx = await buildReadContext(command);
-    const owner = address === undefined ? ctx.ownerAddress : toSuiAddress4(address);
-    if (owner === undefined) {
-      throw new UsageError("No address given and no active account. Pass an address or import an account.");
-    }
-    const page = await ctx.reader.listPublicationsOwnedBy(owner, {
-      signal: ctx.signal,
-      ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
-      ...options.cursor === undefined ? {} : { cursor: options.cursor }
-    });
-    if (page.nextCursor !== null) {
-      ctx.output.info(`More results: pass --cursor "${page.nextCursor}"`);
-    }
-    if (options.idsOnly) {
-      ctx.output.result(renderPublicationList(page.results), {
-        results: page.results,
-        nextCursor: page.nextCursor
-      });
-      return;
-    }
-    const enriched = [];
-    for (const owned of page.results) {
-      const pub = await ctx.reader.getPublication(owned.publicationId, ctx.signal);
-      enriched.push({
-        slug: pub.slug,
-        name: pub.name,
-        publicationId: owned.publicationId,
-        ownerCapId: owned.ownerCapId
-      });
-    }
-    ctx.output.result(renderEnrichedPublicationList(enriched), {
-      results: enriched,
-      nextCursor: page.nextCursor
-    });
+    await runPublicationList(await buildReadContext(command), address, options);
   });
   publication.command("create").description("Create a publication and select it as the active publication").requiredOption("-n, --name <name>", "Publication name").requiredOption("-s, --slug <slug>", "URL slug: lowercase alphanumeric and hyphens, 1-64 chars").action(async (options, command) => {
-    const ctx = await buildWriteContext(command);
-    ctx.output.info(`Creating "${options.name}"...`);
-    const result = await createPublication(ctx.adapter, ctx.config, {
-      name: options.name,
-      slug: options.slug,
-      signal: ctx.signal
-    });
-    await updateActiveProfile(globalOptions(command), {
-      publication: result.publicationId,
-      collection: undefined
-    });
-    const human = [
-      `Created "${options.name}" (${result.publicationId})`,
-      `  ownerCap:     ${result.ownerCapId}`,
-      `  publisherCap: ${result.publisherCapId}`,
-      `  tx:           ${result.digest}`,
-      "Selected as the active publication."
-    ].join(`
-`);
-    ctx.output.result(human, result);
+    await runPublicationCreate(await buildWriteContext(command), options, globalOptions(command));
   });
   publication.command("delete [publication]").description("Delete an empty publication (default: the active publication)").option("--owner-cap <id>", "OwnerCap ID (auto-resolved if omitted)").action(async (target, options, command) => {
-    const ctx = await buildWriteContext(command);
-    const id = await resolvePublication(ctx, target);
-    const proceed = await confirm(`Delete publication ${shortId(id)}? This cannot be undone.`, {
-      assumeYes: Boolean(globalOptions(command).yes),
-      signal: ctx.signal
-    });
-    if (!proceed) {
-      cancelled();
-    }
-    ctx.output.info("Resolving OwnerCap...");
-    const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
-    ctx.output.info("Deleting...");
-    const result = await deletePublication(ctx.reader, ctx.adapter, ctx.config, {
-      publicationId: id,
-      ownerCapId,
-      signal: ctx.signal
-    });
-    if (ctx.settings.publication === id) {
-      await updateActiveProfile(globalOptions(command), {
-        publication: undefined,
-        collection: undefined
-      });
-    }
-    ctx.output.result(`Deleted ${id}. (tx: ${result.digest})`, result);
+    await runPublicationDelete(await buildWriteContext(command), target, options, globalOptions(command));
   });
   const transfer = publication.command("transfer-ownership <recipient>").description("Transfer a publication's OwnerCap to another address");
   publicationOption(ownerCapOption(transfer)).action(async (recipient, options, command) => {
-    const ctx = await buildWriteContext(command);
-    const id = await resolvePublication(ctx, options.publication);
-    const to = toSuiAddress4(recipient);
-    const proceed = await confirm(`Transfer ownership of ${shortId(id)} to ${to}? You will lose owner control.`, { assumeYes: Boolean(globalOptions(command).yes), signal: ctx.signal });
-    if (!proceed) {
-      cancelled();
-    }
-    ctx.output.info("Resolving OwnerCap...");
-    const ownerCapId = await resolveOwnerCap(ctx.reader, ctx.address, id, options.ownerCap, ctx.signal);
-    const result = await transferOwnership(ctx.adapter, ctx.config, {
-      ownerCapId,
-      recipient: to,
-      signal: ctx.signal
-    });
-    ctx.output.result(`Transferred ownership of ${id} to ${to}. (tx: ${result.digest})`, result);
+    await runPublicationTransferOwnership(await buildWriteContext(command), recipient, options, globalOptions(command));
   });
 }
 
@@ -1801,14 +2489,12 @@ import {
 function revisionOptions(command) {
   return collectionOption(publicationOption(publisherCapOption(contentOptions(command))));
 }
-async function resolveTarget(command, options) {
-  const ctx = await buildContentContext(command);
+async function resolveTarget(ctx, options) {
   const publicationId = await resolvePublication(ctx, options.publication);
   const collection = resolveCollection(ctx, options.collection);
-  return { ctx, publicationId, collection };
+  return { publicationId, collection };
 }
-async function prepareContent(target, options) {
-  const { ctx, publicationId } = target;
+async function prepareContent(ctx, publicationId, options) {
   const epochs = parsePositiveInt(options.epochs, "--epochs");
   const bytes = await readContentBytes(options);
   const contentType = resolveContentType(options.contentType, options.stdin ? undefined : options.file);
@@ -1821,113 +2507,124 @@ async function prepareContent(target, options) {
   ctx.output.info(`Blob uploaded (${upload.blobObjectId}). Submitting transaction...`);
   return { blobObjectId: upload.blobObjectId, contentType, publisherCapId };
 }
+async function runRevisionPublishDirect(ctx, entryId, options) {
+  const { publicationId, collection } = await resolveTarget(ctx, options);
+  const numericEntryId = parseId(entryId, "entryId");
+  const prepared = await prepareContent(ctx, publicationId, options);
+  const result = await publishDirect(ctx.adapter, ctx.config, {
+    publicationId,
+    publisherCapId: prepared.publisherCapId,
+    collectionName: collection,
+    entryId: numericEntryId,
+    blobObjectId: prepared.blobObjectId,
+    contentType: prepared.contentType,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Published revision #${result.revisionId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+}
+async function runRevisionAppendDraft(ctx, entryId, options) {
+  const { publicationId, collection } = await resolveTarget(ctx, options);
+  const numericEntryId = parseId(entryId, "entryId");
+  const prepared = await prepareContent(ctx, publicationId, options);
+  const result = await appendDraftRevision(ctx.adapter, ctx.config, {
+    publicationId,
+    publisherCapId: prepared.publisherCapId,
+    collectionName: collection,
+    entryId: numericEntryId,
+    blobObjectId: prepared.blobObjectId,
+    contentType: prepared.contentType,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Appended draft revision #${result.revisionId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+}
+async function runRevisionPublishFromDraft(ctx, entryId, draftRevisionId, options) {
+  const { publicationId, collection } = await resolveTarget(ctx, options);
+  const numericEntryId = parseId(entryId, "entryId");
+  const draftId = parseId(draftRevisionId, "draftRevisionId");
+  const prepared = await prepareContent(ctx, publicationId, options);
+  const result = await publishFromDraft(ctx.adapter, ctx.config, {
+    publicationId,
+    publisherCapId: prepared.publisherCapId,
+    collectionName: collection,
+    entryId: numericEntryId,
+    draftRevisionId: draftId,
+    blobObjectId: prepared.blobObjectId,
+    contentType: prepared.contentType,
+    signal: ctx.signal
+  });
+  ctx.output.result(`Published revision #${result.revisionId} from draft #${draftId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+}
 function registerRevisionCommands(program) {
   const revision = program.command("revision").description("Append or publish revisions on an entry");
   revisionOptions(revision.command("publish-direct <entryId>").description("Upload content and append it as a public revision")).action(async (entryId, options, command) => {
-    const target = await resolveTarget(command, options);
-    const numericEntryId = parseId(entryId, "entryId");
-    const prepared = await prepareContent(target, options);
-    const result = await publishDirect(target.ctx.adapter, target.ctx.config, {
-      publicationId: target.publicationId,
-      publisherCapId: prepared.publisherCapId,
-      collectionName: target.collection,
-      entryId: numericEntryId,
-      blobObjectId: prepared.blobObjectId,
-      contentType: prepared.contentType,
-      signal: target.ctx.signal
-    });
-    target.ctx.output.result(`Published revision #${result.revisionId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+    await runRevisionPublishDirect(await buildContentContext(command), entryId, options);
   });
   revisionOptions(revision.command("append-draft <entryId>").description("Upload content and append it as a draft revision")).action(async (entryId, options, command) => {
-    const target = await resolveTarget(command, options);
-    const numericEntryId = parseId(entryId, "entryId");
-    const prepared = await prepareContent(target, options);
-    const result = await appendDraftRevision(target.ctx.adapter, target.ctx.config, {
-      publicationId: target.publicationId,
-      publisherCapId: prepared.publisherCapId,
-      collectionName: target.collection,
-      entryId: numericEntryId,
-      blobObjectId: prepared.blobObjectId,
-      contentType: prepared.contentType,
-      signal: target.ctx.signal
-    });
-    target.ctx.output.result(`Appended draft revision #${result.revisionId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+    await runRevisionAppendDraft(await buildContentContext(command), entryId, options);
   });
   revisionOptions(revision.command("publish-from-draft <entryId> <draftRevisionId>").description("Upload content and publish it as a new revision, referencing a draft")).action(async (entryId, draftRevisionId, options, command) => {
-    const target = await resolveTarget(command, options);
-    const numericEntryId = parseId(entryId, "entryId");
-    const draftId = parseId(draftRevisionId, "draftRevisionId");
-    const prepared = await prepareContent(target, options);
-    const result = await publishFromDraft(target.ctx.adapter, target.ctx.config, {
-      publicationId: target.publicationId,
-      publisherCapId: prepared.publisherCapId,
-      collectionName: target.collection,
-      entryId: numericEntryId,
-      draftRevisionId: draftId,
-      blobObjectId: prepared.blobObjectId,
-      contentType: prepared.contentType,
-      signal: target.ctx.signal
-    });
-    target.ctx.output.result(`Published revision #${result.revisionId} from draft #${draftId} on entry #${numericEntryId}. (tx: ${result.digest})`, result);
+    await runRevisionPublishFromDraft(await buildContentContext(command), entryId, draftRevisionId, options);
   });
 }
 
 // src/commands/use.ts
+async function runUse(output, gopts, publication, collection, options, makeContext) {
+  if (options.clear) {
+    const profile2 = await updateActiveProfile(gopts, {
+      publication: undefined,
+      collection: undefined
+    });
+    output.result(`Cleared the active publication and collection (profile "${profile2}").`, { profile: profile2, publication: null, collection: null });
+    return;
+  }
+  if (publication === undefined) {
+    throw new UsageError("Provide a publication (slug or id), or pass --clear.");
+  }
+  const ctx = await makeContext();
+  const publicationId = await resolvePublication(ctx, publication);
+  let collectionName;
+  if (collection !== undefined) {
+    const pub = await ctx.reader.getPublication(publicationId, ctx.signal);
+    if (!pub.collections.some((c) => c.name === collection)) {
+      throw new UsageError(`Publication ${publicationId} has no collection "${collection}".`);
+    }
+    collectionName = collection;
+  }
+  const profile = await updateActiveProfile(gopts, {
+    publication: publicationId,
+    collection: collectionName
+  });
+  const human = collectionName === undefined ? `Active publication set to ${publicationId} (profile "${profile}").` : `Active publication set to ${publicationId}, collection "${collectionName}" (profile "${profile}").`;
+  output.result(human, {
+    profile,
+    publication: publicationId,
+    collection: collectionName ?? null
+  });
+}
+function runStatus(output, settings) {
+  const account = accountAddress(settings.account);
+  const human = [
+    `profile:     ${settings.profileName}`,
+    `network:     ${settings.network}`,
+    `account:     ${account ?? "(none)"}`,
+    `publication: ${settings.publication ?? "(none)"}`,
+    `collection:  ${settings.collection ?? "(none)"}`
+  ].join(`
+`);
+  output.result(human, {
+    profile: settings.profileName,
+    network: settings.network,
+    account: account ?? null,
+    publication: settings.publication ?? null,
+    collection: settings.collection ?? null
+  });
+}
 function registerContextCommands(program) {
   program.command("use [publication] [collection]").description("Set the active publication (slug or id) and optional collection. Omitting the collection clears any active collection.").option("--clear", "Clear the active publication and collection").action(async (publication, collection, options, command) => {
-    const opts = globalOptions(command);
-    const output = outputFor(command);
-    if (options.clear) {
-      const profile2 = await updateActiveProfile(opts, {
-        publication: undefined,
-        collection: undefined
-      });
-      output.result(`Cleared the active publication and collection (profile "${profile2}").`, { profile: profile2, publication: null, collection: null });
-      return;
-    }
-    if (publication === undefined) {
-      throw new UsageError("Provide a publication (slug or id), or pass --clear.");
-    }
-    const ctx = await buildReadContext(command);
-    const publicationId = await resolvePublication(ctx, publication);
-    let collectionName;
-    if (collection !== undefined) {
-      const pub = await ctx.reader.getPublication(publicationId, ctx.signal);
-      if (!pub.collections.some((c) => c.name === collection)) {
-        throw new UsageError(`Publication ${publicationId} has no collection "${collection}".`);
-      }
-      collectionName = collection;
-    }
-    const profile = await updateActiveProfile(opts, {
-      publication: publicationId,
-      collection: collectionName
-    });
-    const human = collectionName === undefined ? `Active publication set to ${publicationId} (profile "${profile}").` : `Active publication set to ${publicationId}, collection "${collectionName}" (profile "${profile}").`;
-    output.result(human, {
-      profile,
-      publication: publicationId,
-      collection: collectionName ?? null
-    });
+    await runUse(outputFor(command), globalOptions(command), publication, collection, options, () => buildReadContext(command));
   });
   program.command("status").description("Show the active profile, network, account, publication, and collection").action(async (_options, command) => {
-    const output = outputFor(command);
-    const settings = resolveSettings(globalOptions(command), await loadConfig());
-    const account = accountAddress(settings.account);
-    const human = [
-      `profile:     ${settings.profileName}`,
-      `network:     ${settings.network}`,
-      `account:     ${account ?? "(none)"}`,
-      `publication: ${settings.publication ?? "(none)"}`,
-      `collection:  ${settings.collection ?? "(none)"}`
-    ].join(`
-`);
-    output.result(human, {
-      profile: settings.profileName,
-      network: settings.network,
-      account: account ?? null,
-      publication: settings.publication ?? null,
-      collection: settings.collection ?? null
-    });
+    runStatus(outputFor(command), resolveSettings(globalOptions(command), await loadConfig()));
   });
 }
 
@@ -1941,6 +2638,8 @@ function registerCommands(program) {
   registerEntryCommands(program);
   registerRevisionCommands(program);
   registerCapCommands(program);
+  registerAllowlistCommands(program);
+  registerFileCommands(program);
 }
 
 // src/index.ts