@tinycloud/cli 1.2.0-beta.1 → 1.2.0-beta.11

package/dist/index.js

@@ -8,6 +8,114 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/lib/replication-registry.ts
+function stopForSignal(signal) {
+  void closeReplication().finally(() => {
+    process.exit(signal === "SIGINT" ? 130 : 143);
+  });
+}
+function installSignalHandlers() {
+  if (state.installedSignalHandlers) return;
+  state.installedSignalHandlers = true;
+  state.sigintHandler = () => stopForSignal("SIGINT");
+  state.sigtermHandler = () => stopForSignal("SIGTERM");
+  process.once("SIGINT", state.sigintHandler);
+  process.once("SIGTERM", state.sigtermHandler);
+}
+function removeSignalHandlers() {
+  if (!state.installedSignalHandlers) return;
+  state.installedSignalHandlers = false;
+  if (state.sigintHandler) process.removeListener("SIGINT", state.sigintHandler);
+  if (state.sigtermHandler) process.removeListener("SIGTERM", state.sigtermHandler);
+  state.sigintHandler = void 0;
+  state.sigtermHandler = void 0;
+}
+function registerReplication(profile, control) {
+  state.controls.set(profile, control);
+  state.allControls.add(control);
+  state.generation += 1;
+  installSignalHandlers();
+}
+function replicationForProfile(profile) {
+  return state.controls.get(profile);
+}
+function registeredReplications() {
+  return state.controls;
+}
+function closeReplication(schedule = scheduleTimeout) {
+  if (state.closing) return state.closing;
+  removeSignalHandlers();
+  let resolveClosing;
+  let rejectClosing;
+  const closing = new Promise((resolve2, reject) => {
+    resolveClosing = resolve2;
+    rejectClosing = reject;
+  });
+  state.closing = closing;
+  void (async () => {
+    let timeout;
+    const deadline = new Promise((resolve2) => {
+      timeout = schedule(() => resolve2(true), CLOSE_TIMEOUT_MS);
+    });
+    let timedOut = false;
+    const abandonQueuedControls = () => {
+      for (const control of state.allControls) {
+        void Promise.resolve().then(() => control.close()).catch(() => void 0);
+      }
+      state.controls.clear();
+      state.allControls.clear();
+    };
+    try {
+      while (!timedOut) {
+        while (state.allControls.size > 0) {
+          const generation = state.generation;
+          const pending = [...state.allControls];
+          state.controls.clear();
+          state.allControls.clear();
+          const drained = Promise.allSettled(pending.map((control) => Promise.resolve().then(() => control.close()))).then(() => false);
+          timedOut ||= await Promise.race([drained, deadline]);
+          if (timedOut) {
+            abandonQueuedControls();
+            break;
+          }
+          if (state.generation === generation && state.allControls.size === 0) break;
+        }
+        if (timedOut) break;
+        const turn = new Promise((resolve2) => setImmediate(() => resolve2(false)));
+        timedOut ||= await Promise.race([turn, deadline]);
+        if (timedOut) abandonQueuedControls();
+        else if (state.allControls.size === 0) break;
+      }
+      state.closing = void 0;
+      if (state.allControls.size === 0) removeSignalHandlers();
+      resolveClosing(timedOut);
+    } catch (error) {
+      state.closing = void 0;
+      if (state.allControls.size === 0) removeSignalHandlers();
+      rejectClosing(error);
+    } finally {
+      clearTimeout(timeout);
+    }
+  })();
+  return closing;
+}
+var registryKey, globalState, state, CLOSE_TIMEOUT_MS, scheduleTimeout;
+var init_replication_registry = __esm({
+  "src/lib/replication-registry.ts"() {
+    "use strict";
+    registryKey = /* @__PURE__ */ Symbol.for("@tinycloud/cli/replication-registry");
+    globalState = globalThis;
+    state = globalState[registryKey] ??= {
+      controls: /* @__PURE__ */ new Map(),
+      allControls: /* @__PURE__ */ new Set(),
+      installedSignalHandlers: false,
+      generation: 0
+    };
+    CLOSE_TIMEOUT_MS = 3e3;
+    scheduleTimeout = (callback, delayMs) => setTimeout(callback, delayMs);
+  }
+});
+
 // src/config/constants.ts
 import {
   profilesPath,
@@ -33,8 +141,12 @@ var init_constants = __esm({
       PERMISSION_DENIED: 5,
       NETWORK_ERROR: 6,
       NODE_ERROR: 7,
+      /** `tc secrets wait` only: the deadline passed while a secret was still missing. */
+      PENDING: 8,
       /** A write was refused because the owner's TinyCloud storage is full. */
-      STORAGE_FULL: 10
+      STORAGE_FULL: 10,
+      /** Interrupted by SIGINT/SIGTERM (`CANCELLED`). */
+      CANCELLED: 130
     };
   }
 });
@@ -119,7 +231,7 @@ function warningLine(warnings) {
   return `${subject} not used (${which}). Approve access again when a command needs it; remove the old grant with tc auth grants remove <cid>.`;
 }
 function outputError(code3, message, hint, details = {}) {
-  const { meta, warnings = [] } = details;
+  const { meta, warnings = [], setup, recovery, progress } = details;
   if (!shouldOutputJson()) {
     process.stderr.write(
       `${theme.error("\u2717")} ${theme.label(code3)}: ${message}
@@ -138,6 +250,9 @@ function outputError(code3, message, hint, details = {}) {
       error: { code: code3, message }
     };
     if (hint) payload.error.hint = hint;
+    if (recovery) payload.error.recovery = recovery;
+    if (setup) payload.error.setup = setup;
+    if (progress) payload.error.progress = progress;
     if (meta) payload.error.meta = meta;
     if (warnings.length > 0) payload.error.warnings = warnings;
     process.stderr.write(JSON.stringify(payload, null, 2) + "\n");
@@ -267,6 +382,13 @@ var init_storage = __esm({
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
 import { ProfileDeletedError, ProfileLockTimeoutError } from "@tinycloud/operations/state";
+import { isSafeRecovery } from "@tinycloud/operations/recovery";
+import {
+  buildSecretRequestUrl,
+  isSafeRequestAccessRecovery,
+  isValidSecretName,
+  SECRET_REQUEST_MAX_NAMES
+} from "@tinycloud/operations/secret-request";
 import { authorizationVerdictOf, parseCapabilityResource, SERVICE_LONG_TO_SHORT, validatedCapabilityOf } from "@tinycloud/sdk-core";
 function setActiveProfileName(name) {
   activeProfileName = name;
@@ -342,11 +464,64 @@ function handleError(error) {
     meta.resource = capability.resource;
     meta.requiredAction = capability.requiredAction;
   }
+  const deniedNames = cliError.metadata?.deniedNames;
+  const recovery = safeCliRecovery(cliError.metadata?.recovery, {
+    deniedNames: Array.isArray(deniedNames) && deniedNames.every((name) => typeof name === "string") ? deniedNames : []
+  });
+  const setup = cliError.code === "NOT_FOUND" || cliError.code === "PERMISSION_DENIED" ? safeCliSetup(cliError.metadata?.setup) : void 0;
+  const progress = cliError.code === "NETWORK_ERROR" || cliError.code === "CANCELLED" ? safeCliProgress(cliError.metadata?.progress) : void 0;
   outputError(cliError.code, cliError.message, hint, {
+    ...recovery ? { recovery } : {},
+    ...setup ? { setup } : {},
+    ...progress ? { progress } : {},
     ...Object.keys(meta).length ? { meta } : {},
     warnings: mergeWarnings(drainWarnings(), operationWarnings(cliError.metadata?.warnings))
   });
-  process.exit(cliError.exitCode);
+  if (registeredReplications().size === 0) return process.exit(cliError.exitCode);
+  return closeReplication().then(() => process.exit(cliError.exitCode));
+}
+function safeCliRecovery(value, context) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || !("action" in value)) return void 0;
+  const action = value.action;
+  switch (action) {
+    case "sign_in":
+    case "complete_migration":
+      return isSafeRecovery(value, action) ? { ...value } : void 0;
+    case "request_access":
+      return isSafeRequestAccessRecovery(value, context.deniedNames) ? { ...value, names: [...value.names] } : void 0;
+    default:
+      return void 0;
+  }
+}
+function safeCliSetup(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const setup = { ...value };
+  if (!Object.keys(setup).every((key) => SETUP_KEYS[key] === true)) return void 0;
+  const { url, names, scope, owner, action } = setup;
+  if (action !== "add_secret" || typeof url !== "string" || typeof owner !== "string") return void 0;
+  if (!Array.isArray(names) || !names.every((name) => typeof name === "string")) return void 0;
+  if (scope !== void 0 && typeof scope !== "string") return void 0;
+  try {
+    const link2 = buildSecretRequestUrl({ owner, names, ...scope !== void 0 ? { scope } : {} });
+    if (link2.url !== url || link2.owner !== owner || link2.names.length !== names.length) return void 0;
+  } catch {
+    return void 0;
+  }
+  return { url, names: [...names], ...scope !== void 0 ? { scope } : {}, owner, action };
+}
+function safeNameList(value) {
+  if (!Array.isArray(value) || value.length > SECRET_REQUEST_MAX_NAMES) return void 0;
+  if (!value.every((name) => typeof name === "string" && isValidSecretName(name))) return void 0;
+  if (new Set(value).size !== value.length) return void 0;
+  return [...value];
+}
+function safeCliProgress(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  if (!("present" in value) || !("pending" in value) || Object.keys(value).length !== 2) return void 0;
+  const present = safeNameList(value.present);
+  const pending = safeNameList(value.pending);
+  if (!present || !pending || present.some((name) => pending.includes(name))) return void 0;
+  return { present, pending };
 }
 function buildAuthHint(error) {
   const capability = validatedCapabilityOf({ meta: error.metadata });
@@ -409,10 +584,11 @@ function buildNetworkHint() {
   lines.push(`Or override per-command with --host or TC_HOST.`);
   return lines.join("\n");
 }
-var activeProfileName, CLIError;
+var activeProfileName, CLIError, SETUP_KEYS;
 var init_errors = __esm({
   "src/output/errors.ts"() {
     "use strict";
+    init_replication_registry();
     init_constants();
     init_formatter();
     init_storage();
@@ -428,6 +604,7 @@ var init_errors = __esm({
       }
       status;
     };
+    SETUP_KEYS = { url: true, names: true, scope: true, owner: true, action: true };
   }
 });
 
@@ -900,11 +1077,11 @@ var init_md = __esm({
         if (len % 4)
           throw new Error("_sha2: outputLen should be aligned to 32bit");
         const outLen = len / 4;
-        const state = this.get();
-        if (outLen > state.length)
+        const state2 = this.get();
+        if (outLen > state2.length)
           throw new Error("_sha2: outputLen bigger than state");
         for (let i = 0; i < outLen; i++)
-          oview.setUint32(4 * i, state[i], isLE2);
+          oview.setUint32(4 * i, state2[i], isLE2);
       }
       digest() {
         const { buffer, outputLen } = this;
@@ -5464,6 +5641,8 @@ import {
   buildPermissionRequestArtifact,
   isPermissionRequestArtifact
 } from "@tinycloud/operations/artifacts";
+import { isLocalOwnerProfile } from "@tinycloud/operations/profile";
+import { resolveSecretsOwner } from "@tinycloud/operations/secret-request";
 import {
   additionalDelegationsPath as sharedAdditionalDelegationsPath,
   authRequestsPath as sharedAuthRequestsPath,
@@ -5501,14 +5680,17 @@ var init_permissions = __esm({
 });
 
 // src/auth/session-expired.ts
+import { signInRecovery } from "@tinycloud/operations/recovery";
 function signInAgainHint(profileName, posture) {
-  if (posture === "local-owner-key") {
-    return `Sign in again with: tc --profile ${profileName} auth login --method local`;
-  }
-  if (posture === "delegate-session") {
-    return `Have the owner approve a new scoped login: tc --profile ${profileName} auth login --method openkey --paste --manifest <manifest.json>. Pass the owner's code on stdin, newline-terminated.`;
+  const delegate = posture === "delegate-session";
+  const { command } = signInRecovery(
+    profileName,
+    delegate ? "delegate-session" : posture === "local-owner-key" ? "local-owner-key" : "owner-openkey"
+  );
+  if (command === void 0) {
+    return delegate ? `Have the owner approve a new scoped login for profile ${JSON.stringify(profileName)} with tc auth login --method openkey --paste --manifest <manifest.json>.` : `Sign in again to profile ${JSON.stringify(profileName)} with tc auth login.`;
   }
-  return `Sign in again with: tc --profile ${profileName} auth login --method openkey`;
+  return delegate ? `Have the owner approve a new scoped login: ${command}. Pass the owner's code on stdin, newline-terminated.` : `Sign in again with: ${command}`;
 }
 function sessionExpiredError(profileName, posture) {
   return new CLIError(
@@ -5543,1019 +5725,643 @@ var init_delegation_expiry = __esm({
   }
 });
 
-// src/lib/sdk.ts
-var sdk_exports = {};
-__export(sdk_exports, {
-  bootstrapDelegatedSession: () => bootstrapDelegatedSession,
-  createSDKInstance: () => createSDKInstance,
-  ensureAuthenticated: () => ensureAuthenticated,
-  jwkHasPrivateParameter: () => jwkHasPrivateParameter,
-  restoreProfileSessionNode: () => restoreProfileSessionNode,
-  selectSignerJwk: () => selectSignerJwk,
-  storedSessionVerifiesLocally: () => storedSessionVerifiesLocally
-});
-import { TinyCloudNode, signedCompactUcanExpiry } from "@tinycloud/node-sdk";
-function jwkHasPrivateParameter(jwk) {
-  if (!jwk || typeof jwk !== "object") return false;
-  const d = jwk.d;
-  return typeof d === "string" && d.length > 0;
-}
-function selectSignerJwk(sessionJwk, key) {
-  if (jwkHasPrivateParameter(sessionJwk)) {
-    return sessionJwk;
-  }
-  return key ?? void 0;
-}
-function signerJwkForProfile(profileName, sessionJwk, key) {
-  const jwk = selectSignerJwk(sessionJwk, key);
-  if (jwkHasPrivateParameter(jwk)) {
-    return jwk;
-  }
-  throw new CLIError(
-    "AUTH_REQUIRED",
-    `Profile "${profileName}" cannot restore its session because its private key material is missing.`,
-    ExitCode.AUTH_REQUIRED,
-    {
-      hint: `Sign in again with: tc --profile ${profileName} auth login --method openkey`
-    }
-  );
-}
-function signedLifetimePassed(delegation) {
-  const authorization = delegation.delegationHeader?.Authorization;
-  const expiry = typeof authorization === "string" ? signedCompactUcanExpiry(authorization) : void 0;
-  return expiry !== void 0 && expiry.getTime() <= Date.now();
-}
-async function restoreProfileSession(node, profileName, profile, sessionData) {
+// src/lib/replication-log.ts
+import { appendFileSync, chmodSync, mkdirSync, renameSync, statSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+function appendReplicationEvent(root, event) {
+  mkdirSync(root, { recursive: true, mode: DIR_MODE });
+  chmodSync(root, DIR_MODE);
+  const path = join4(root, "events.jsonl");
+  let size = 0;
   try {
-    await node.restoreSession(sessionData);
+    size = statSync(path).size;
   } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "AUTH_EXPIRED") {
-      throw sessionExpiredError(profileName, profile === null ? void 0 : resolveProfilePosture(profile));
-    }
-    throw error;
+    if (error.code !== "ENOENT") throw error;
   }
-}
-function persistedSessionData(profileName, profile, session, key) {
-  return {
-    delegationHeader: session.delegationHeader,
-    delegationCid: session.delegationCid,
-    spaceId: session.spaceId,
-    jwk: signerJwkForProfile(profileName, session.jwk, key),
-    verificationMethod: session.verificationMethod ?? profile.sessionDid ?? profile.did,
-    address: session.address,
-    chainId: session.chainId,
-    siwe: session.siwe,
-    signature: session.signature
+  const line = `${JSON.stringify(event)}
+`;
+  if (size + Buffer.byteLength(line) > MAX_LOG_BYTES) {
+    const rotated = join4(root, "events.jsonl.1");
+    try {
+      renameSync(path, rotated);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    writeFileSync(path, line, { mode: LOG_MODE });
+  } else {
+    appendFileSync(path, line, { mode: LOG_MODE });
+  }
+  chmodSync(path, LOG_MODE);
+}
+function replicationLogPath(profileRoot) {
+  return join4(profileRoot, "replication", "events.jsonl");
+}
+function createReplicationEventSink(profileRoot, options) {
+  const pinnedNotices = /* @__PURE__ */ new Set();
+  const missingGrantWarnings = /* @__PURE__ */ new Set();
+  return (event) => {
+    appendProfileReplicationEvent(profileRoot, event);
+    if (event.type === "replication.state" && event.state === "grant_missing") {
+      const prefix = event.replica ?? event.space ?? "configured prefix";
+      const key = `${event.space ?? ""}\0${event.replica ?? ""}`;
+      if (!missingGrantWarnings.has(key)) {
+        missingGrantWarnings.add(key);
+        process.stderr.write(`[replication] Warning: no usable kv/get+sync grant for ${prefix}; reads use the network (${event.code ?? "grant_missing"}).
+`);
+      }
+    }
+    if (options.debug) {
+      if (event.type === "replication.read") {
+        const detail = event.source === "replica" ? "replica hit" : `${event.source} ${event.reason}`;
+        const syncStatus = event.syncedBeforeRead === void 0 ? "" : ` syncedBeforeRead:${event.syncedBeforeRead}`;
+        const syncError = event.syncError === void 0 ? "" : ` syncError:${event.syncError}`;
+        process.stderr.write(`[replication] ${event.op} ${event.key} \u2190 ${detail} ${event.latencyMs}ms${syncStatus}${syncError}${event.stalenessMs === null ? "" : ` (synced ${Math.round(event.stalenessMs / 1e3)}s ago)`}
+`);
+      } else if (event.type === "replication.write") {
+        process.stderr.write(`[replication] ${event.op} ${event.keys.join(",")} ${event.outcome}${event.code ? ` ${event.code}` : ""}
+`);
+      } else if (event.type === "replication.sync") {
+        const pending = event.pendingCleared === void 0 ? "" : ` pendingCleared:${event.pendingCleared}`;
+        process.stderr.write(`[replication] sync ${event.replica} ${event.outcome}${event.code ? ` ${event.code}` : ""}${pending}
+`);
+      }
+    }
+    if (event.type === "replication.read" && (event.pendingState === "in_flight" || event.pendingState === "ambiguous") && !options.quiet && !pinnedNotices.has(event.key)) {
+      pinnedNotices.add(event.key);
+      process.stderr.write(`[replication] ${event.key} reads from the network: an earlier write's outcome is unknown (${event.pendingState}${event.code ? `, ${event.code}` : ""}). Review: tc replica report
+`);
+    }
   };
 }
-async function restoreProfileSessionNode(ctx) {
-  const profile = await ProfileManager.getProfile(ctx.profile);
-  const session = await ProfileManager.getSession(ctx.profile);
-  if (!session) return { unavailable: "session_missing" };
-  if (typeof session.delegationCid !== "string" || typeof session.spaceId !== "string" || session.delegationHeader === null || typeof session.delegationHeader !== "object" || !("Authorization" in session.delegationHeader) || typeof session.delegationHeader.Authorization !== "string") {
-    return { unavailable: "session_invalid" };
-  }
-  if (typeof session.expiresAt === "string" && Date.parse(session.expiresAt) <= Date.now()) {
-    return { unavailable: "session_expired" };
-  }
-  const key = await ProfileManager.getKey(ctx.profile);
-  try {
-    const node = new TinyCloudNode({
-      host: ctx.host,
-      ...profile.authMethod === "local" && profile.privateKey ? { privateKey: profile.privateKey } : {}
-    });
-    await restoreProfileSession(node, ctx.profile, profile, persistedSessionData(ctx.profile, profile, session, key));
-    return { node };
-  } catch (error) {
-    if (error instanceof CLIError && error.metadata?.reason === "session_expired") {
-      return { unavailable: "session_expired" };
-    }
-    return { unavailable: "session_invalid" };
-  }
+function appendProfileReplicationEvent(profileRoot, event) {
+  appendReplicationEvent(dirname2(replicationLogPath(profileRoot)), event);
 }
-async function storedSessionVerifiesLocally(profileName) {
-  const profile = await ProfileManager.getProfile(profileName).catch(() => null);
-  if (profile === null) return true;
-  const local = profile.authMethod === "local" && typeof profile.privateKey === "string";
-  try {
-    const session = await ProfileManager.getSession(profileName);
-    if (!session || typeof session.delegationCid !== "string" || typeof session.spaceId !== "string" || session.delegationHeader === null || typeof session.delegationHeader !== "object" || !("Authorization" in session.delegationHeader) || typeof session.delegationHeader.Authorization !== "string") return true;
-    const key = await ProfileManager.getKey(profileName);
-    const node = new TinyCloudNode({
-      host: profile.host ?? DEFAULT_HOST,
-      ...local ? { privateKey: profile.privateKey } : {}
-    });
-    await restoreProfileSession(node, profileName, profile, persistedSessionData(profileName, profile, session, key));
-    return true;
-  } catch {
-    return false;
+var MAX_LOG_BYTES, LOG_MODE, DIR_MODE;
+var init_replication_log = __esm({
+  "src/lib/replication-log.ts"() {
+    "use strict";
+    MAX_LOG_BYTES = 5 * 1024 * 1024;
+    LOG_MODE = 384;
+    DIR_MODE = 448;
   }
+});
+
+// ../../node_modules/@noble/hashes/esm/_blake.js
+function G1s(a, b, c, d, x) {
+  a = a + b + x | 0;
+  d = rotr(d ^ a, 16);
+  c = c + d | 0;
+  b = rotr(b ^ c, 12);
+  return { a, b, c, d };
 }
-async function createSDKInstance(ctx, options) {
-  const profile = options?.privateKey ? await ProfileManager.getProfile(ctx.profile).catch(() => null) : await ProfileManager.getProfile(ctx.profile);
-  const session = await ProfileManager.getSession(ctx.profile);
-  const key = await ProfileManager.getKey(ctx.profile);
-  const effectivePrivateKey = options?.privateKey ?? profile?.privateKey;
-  if (!key && !effectivePrivateKey && !(profile?.authMethod === "openkey" && session !== null)) {
-    throw new CLIError(
-      "AUTH_REQUIRED",
-      `No key found for profile "${ctx.profile}". Run \`tc --profile ${ctx.profile} auth rotate\` to create a new key and sign in.`,
-      ExitCode.AUTH_REQUIRED
-    );
-  }
-  if (profile?.authMethod === "local" && effectivePrivateKey) {
-    const node2 = new TinyCloudNode({
-      host: ctx.host,
-      privateKey: effectivePrivateKey
-    });
-    const restoredOwnSession = Boolean(session && session.delegationHeader && session.delegationCid && session.spaceId);
-    if (restoredOwnSession) {
-      await restoreProfileSession(node2, ctx.profile, profile, persistedSessionData(ctx.profile, profile, session, key));
-    } else {
-      await node2.signIn();
-    }
-    if (restoredOwnSession) {
-      recordWarnings(await replayAdditionalDelegations(node2, ctx.profile, {
-        host: ctx.host,
-        ownerSpace: profile.spaceId,
-        migrate: options?.privateKey === void 0
-      }));
-    }
-    return node2;
+function G2s(a, b, c, d, x) {
+  a = a + b + x | 0;
+  d = rotr(d ^ a, 8);
+  c = c + d | 0;
+  b = rotr(b ^ c, 7);
+  return { a, b, c, d };
+}
+var init_blake = __esm({
+  "../../node_modules/@noble/hashes/esm/_blake.js"() {
+    "use strict";
+    init_utils();
   }
-  const node = new TinyCloudNode({
-    host: ctx.host,
-    privateKey: options?.privateKey
-  });
-  if (options?.privateKey) {
-    await node.signIn();
-  } else if (session && session.delegationHeader && session.delegationCid && session.spaceId) {
-    await restoreProfileSession(node, ctx.profile, profile, persistedSessionData(ctx.profile, profile, session, key));
-    recordWarnings(await replayAdditionalDelegations(node, ctx.profile, {
-      host: ctx.host,
-      ownerSpace: profile?.spaceId,
-      migrate: true
-    }));
+});
+
+// ../../node_modules/@noble/hashes/esm/blake2.js
+function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+  let j = 0;
+  for (let i = 0; i < rounds; i++) {
+    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
   }
-  return node;
+  return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
 }
-async function bootstrapDelegatedSession(ctx, delegation) {
-  const written = await ProfileManager.withLock(ctx.profile, async () => {
-    const previousProfile = await ProfileManager.getProfile(ctx.profile);
-    if (resolveProfilePosture(previousProfile) !== "delegate-session") {
-      throw new CLIError(
-        "AUTH_REQUIRED",
-        `Profile "${ctx.profile}" is not a delegate-session profile.`,
-        ExitCode.AUTH_REQUIRED
-      );
-    }
-    const sessionDid = previousProfile.sessionDid ?? previousProfile.did;
-    if (delegation.delegateDID.split("#", 1)[0] !== sessionDid.split("#", 1)[0]) {
-      throw new CLIError(
-        "DELEGATION_AUDIENCE_MISMATCH",
-        `Delegation targets ${delegation.delegateDID}, but profile "${ctx.profile}" uses ${sessionDid}.`,
-        ExitCode.PERMISSION_DENIED
-      );
-    }
-    if (await ProfileManager.getSession(ctx.profile) !== null) {
-      throw new CLIError(
-        "PROFILE_CHANGED_DURING_IMPORT",
-        `Profile "${ctx.profile}" gained a session (another login or import) after this import checked it. Nothing was saved; run the import again.`,
-        ExitCode.ERROR
-      );
-    }
-    if (signedLifetimePassed(delegation)) throw delegationExpiredError();
-    const jwk = signerJwkForProfile(ctx.profile, void 0, await ProfileManager.getKey(ctx.profile));
-    const session = {
-      delegationHeader: delegation.delegationHeader,
-      delegationCid: delegation.cid,
-      spaceId: delegation.spaceId,
-      jwk,
-      verificationMethod: sessionDid
+var BLAKE2;
+var init_blake2 = __esm({
+  "../../node_modules/@noble/hashes/esm/blake2.js"() {
+    "use strict";
+    init_blake();
+    init_utils();
+    BLAKE2 = class extends Hash {
+      constructor(blockLen, outputLen) {
+        super();
+        this.finished = false;
+        this.destroyed = false;
+        this.length = 0;
+        this.pos = 0;
+        anumber(blockLen);
+        anumber(outputLen);
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.buffer = new Uint8Array(blockLen);
+        this.buffer32 = u32(this.buffer);
+      }
+      update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(data);
+        const { blockLen, buffer, buffer32 } = this;
+        const len = data.length;
+        const offset = data.byteOffset;
+        const buf = data.buffer;
+        for (let pos = 0; pos < len; ) {
+          if (this.pos === blockLen) {
+            swap32IfBE(buffer32);
+            this.compress(buffer32, 0, false);
+            swap32IfBE(buffer32);
+            this.pos = 0;
+          }
+          const take = Math.min(blockLen - this.pos, len - pos);
+          const dataOffset = offset + pos;
+          if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+            const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+            swap32IfBE(data32);
+            for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+              this.length += blockLen;
+              this.compress(data32, pos32, false);
+            }
+            swap32IfBE(data32);
+            continue;
+          }
+          buffer.set(data.subarray(pos, pos + take), this.pos);
+          this.pos += take;
+          this.length += take;
+          pos += take;
+        }
+        return this;
+      }
+      digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        const { pos, buffer32 } = this;
+        this.finished = true;
+        clean(this.buffer.subarray(pos));
+        swap32IfBE(buffer32);
+        this.compress(buffer32, 0, true);
+        swap32IfBE(buffer32);
+        const out32 = u32(out);
+        this.get().forEach((v, i) => out32[i] = swap8IfBE(v));
+      }
+      digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+      }
+      _cloneInto(to) {
+        const { buffer, length: length4, finished, destroyed, outputLen, pos } = this;
+        to || (to = new this.constructor({ dkLen: outputLen }));
+        to.set(...this.get());
+        to.buffer.set(buffer);
+        to.destroyed = destroyed;
+        to.finished = finished;
+        to.length = length4;
+        to.pos = pos;
+        to.outputLen = outputLen;
+        return to;
+      }
+      clone() {
+        return this._cloneInto();
+      }
     };
-    const profile = { ...previousProfile, sessionDid, spaceId: delegation.spaceId };
-    try {
-      await ProfileManager.setSession(ctx.profile, session);
-      await ProfileManager.setProfile(ctx.profile, profile);
-    } catch (error) {
-      throw annotate(error, await restoreBeforeBootstrap(ctx.profile, previousProfile));
-    }
-    return { previousProfile, profile, session };
-  });
-  const abandon = async (cause) => {
-    const reported = cause instanceof CLIError && cause.code === "AUTH_REQUIRED" && signedLifetimePassed(delegation) ? delegationExpiredError() : cause;
-    const note = await ProfileManager.withLock(ctx.profile, async () => {
-      const profile = await ProfileManager.getProfile(ctx.profile).catch((error) => {
-        if (error instanceof CLIError && error.code === "PROFILE_NOT_FOUND") return null;
-        throw error;
-      });
-      const session = await ProfileManager.getSession(ctx.profile);
-      if (profile === null || BOOTSTRAP_PROFILE_FIELDS.some((field) => profile[field] !== written.profile[field]) || JSON.stringify(session) !== JSON.stringify(written.session)) {
-        return `Profile "${ctx.profile}" changed while the import was pending (another login, logout or profile update), so its newer state was kept and the provisional session was not rolled back.`;
+  }
+});
+
+// ../../node_modules/@noble/hashes/esm/blake3.js
+var B3_Flags, B3_IV, B3_SIGMA, BLAKE3, blake3;
+var init_blake3 = __esm({
+  "../../node_modules/@noble/hashes/esm/blake3.js"() {
+    "use strict";
+    init_md();
+    init_u64();
+    init_blake2();
+    init_utils();
+    B3_Flags = {
+      CHUNK_START: 1,
+      CHUNK_END: 2,
+      PARENT: 4,
+      ROOT: 8,
+      KEYED_HASH: 16,
+      DERIVE_KEY_CONTEXT: 32,
+      DERIVE_KEY_MATERIAL: 64
+    };
+    B3_IV = SHA256_IV.slice();
+    B3_SIGMA = /* @__PURE__ */ (() => {
+      const Id = Array.from({ length: 16 }, (_, i) => i);
+      const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
+      const res = [];
+      for (let i = 0, v = Id; i < 7; i++, v = permute(v))
+        res.push(...v);
+      return Uint8Array.from(res);
+    })();
+    BLAKE3 = class _BLAKE3 extends BLAKE2 {
+      constructor(opts = {}, flags = 0) {
+        super(64, opts.dkLen === void 0 ? 32 : opts.dkLen);
+        this.chunkPos = 0;
+        this.chunksDone = 0;
+        this.flags = 0 | 0;
+        this.stack = [];
+        this.posOut = 0;
+        this.bufferOut32 = new Uint32Array(16);
+        this.chunkOut = 0;
+        this.enableXOF = true;
+        const { key, context } = opts;
+        const hasContext = context !== void 0;
+        if (key !== void 0) {
+          if (hasContext)
+            throw new Error('Only "key" or "context" can be specified at same time');
+          const k = toBytes(key).slice();
+          abytes(k, 32);
+          this.IV = u32(k);
+          swap32IfBE(this.IV);
+          this.flags = flags | B3_Flags.KEYED_HASH;
+        } else if (hasContext) {
+          const ctx = toBytes(context);
+          const contextKey = new _BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT).update(ctx).digest();
+          this.IV = u32(contextKey);
+          swap32IfBE(this.IV);
+          this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
+        } else {
+          this.IV = B3_IV.slice();
+          this.flags = flags;
+        }
+        this.state = this.IV.slice();
+        this.bufferOut = u8(this.bufferOut32);
       }
-      return restoreBeforeBootstrap(ctx.profile, written.previousProfile);
-    }, { timeoutMs: PROFILE_COMMIT_LOCK_TIMEOUT_MS }).catch((error) => (
-      // The lock or a read failed: the import's error stays the one reported.
-      `Rolling back the provisional session of profile "${ctx.profile}" could not run (${failureName(error)}); check \`tc --profile ${ctx.profile} context\`.`
-    ));
-    throw annotate(reported, note);
-  };
-  let node;
-  try {
-    node = await createSDKInstance(ctx);
-  } catch (error) {
-    return abandon(error);
+      // Unused
+      get() {
+        return [];
+      }
+      set() {
+      }
+      b2Compress(counter, flags, buf, bufPos = 0) {
+        const { state: s, pos } = this;
+        const { h, l } = fromBig(BigInt(counter), true);
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags);
+        s[0] = v0 ^ v8;
+        s[1] = v1 ^ v9;
+        s[2] = v2 ^ v10;
+        s[3] = v3 ^ v11;
+        s[4] = v4 ^ v12;
+        s[5] = v5 ^ v13;
+        s[6] = v6 ^ v14;
+        s[7] = v7 ^ v15;
+      }
+      compress(buf, bufPos = 0, isLast = false) {
+        let flags = this.flags;
+        if (!this.chunkPos)
+          flags |= B3_Flags.CHUNK_START;
+        if (this.chunkPos === 15 || isLast)
+          flags |= B3_Flags.CHUNK_END;
+        if (!isLast)
+          this.pos = this.blockLen;
+        this.b2Compress(this.chunksDone, flags, buf, bufPos);
+        this.chunkPos += 1;
+        if (this.chunkPos === 16 || isLast) {
+          let chunk = this.state;
+          this.state = this.IV.slice();
+          for (let last, chunks = this.chunksDone + 1; isLast || !(chunks & 1); chunks >>= 1) {
+            if (!(last = this.stack.pop()))
+              break;
+            this.buffer32.set(last, 0);
+            this.buffer32.set(chunk, 8);
+            this.pos = this.blockLen;
+            this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
+            chunk = this.state;
+            this.state = this.IV.slice();
+          }
+          this.chunksDone++;
+          this.chunkPos = 0;
+          this.stack.push(chunk);
+        }
+        this.pos = 0;
+      }
+      _cloneInto(to) {
+        to = super._cloneInto(to);
+        const { IV, flags, state: state2, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
+        to.state.set(state2.slice());
+        to.stack = stack.map((i) => Uint32Array.from(i));
+        to.IV.set(IV);
+        to.flags = flags;
+        to.chunkPos = chunkPos;
+        to.chunksDone = chunksDone;
+        to.posOut = posOut;
+        to.chunkOut = chunkOut;
+        to.enableXOF = this.enableXOF;
+        to.bufferOut32.set(this.bufferOut32);
+        return to;
+      }
+      destroy() {
+        this.destroyed = true;
+        clean(this.state, this.buffer32, this.IV, this.bufferOut32);
+        clean(...this.stack);
+      }
+      // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)
+      b2CompressOut() {
+        const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
+        const { h, l } = fromBig(BigInt(this.chunkOut++));
+        swap32IfBE(buffer32);
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags);
+        out32[0] = v0 ^ v8;
+        out32[1] = v1 ^ v9;
+        out32[2] = v2 ^ v10;
+        out32[3] = v3 ^ v11;
+        out32[4] = v4 ^ v12;
+        out32[5] = v5 ^ v13;
+        out32[6] = v6 ^ v14;
+        out32[7] = v7 ^ v15;
+        out32[8] = s[0] ^ v8;
+        out32[9] = s[1] ^ v9;
+        out32[10] = s[2] ^ v10;
+        out32[11] = s[3] ^ v11;
+        out32[12] = s[4] ^ v12;
+        out32[13] = s[5] ^ v13;
+        out32[14] = s[6] ^ v14;
+        out32[15] = s[7] ^ v15;
+        swap32IfBE(buffer32);
+        swap32IfBE(out32);
+        this.posOut = 0;
+      }
+      finish() {
+        if (this.finished)
+          return;
+        this.finished = true;
+        clean(this.buffer.subarray(this.pos));
+        let flags = this.flags | B3_Flags.ROOT;
+        if (this.stack.length) {
+          flags |= B3_Flags.PARENT;
+          swap32IfBE(this.buffer32);
+          this.compress(this.buffer32, 0, true);
+          swap32IfBE(this.buffer32);
+          this.chunksDone = 0;
+          this.pos = this.blockLen;
+        } else {
+          flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
+        }
+        this.flags = flags;
+        this.b2CompressOut();
+      }
+      writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const { blockLen, bufferOut } = this;
+        for (let pos = 0, len = out.length; pos < len; ) {
+          if (this.posOut >= blockLen)
+            this.b2CompressOut();
+          const take = Math.min(blockLen - this.posOut, len - pos);
+          out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+          this.posOut += take;
+          pos += take;
+        }
+        return out;
+      }
+      xofInto(out) {
+        if (!this.enableXOF)
+          throw new Error("XOF is not possible after digest call");
+        return this.writeInto(out);
+      }
+      xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+      }
+      digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+          throw new Error("digest() was already called");
+        this.enableXOF = false;
+        this.writeInto(out);
+        this.destroy();
+        return out;
+      }
+      digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+      }
+    };
+    blake3 = /* @__PURE__ */ createXOFer((opts) => new BLAKE3(opts));
   }
-  return { node, abandon };
+});
+
+// ../../node_modules/@noble/curves/esm/utils.js
+function _abool2(value, title = "") {
+  if (typeof value !== "boolean") {
+    const prefix = title && `"${title}"`;
+    throw new Error(prefix + "expected boolean, got type=" + typeof value);
+  }
+  return value;
 }
-async function restoreBeforeBootstrap(profileName, previousProfile) {
-  const failures = [];
-  for (const write of [
-    () => ProfileManager.clearSession(profileName),
-    () => ProfileManager.updateProfile(profileName, (current) => {
-      const restored = { ...current };
-      for (const field of BOOTSTRAP_PROFILE_FIELDS) {
-        if (previousProfile[field] === void 0) delete restored[field];
-        else restored[field] = previousProfile[field];
-      }
-      return restored;
-    })
-  ]) {
-    await write().catch((error) => {
-      failures.push(failureName(error));
-    });
+function _abytes2(value, length4, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length4 !== void 0;
+  if (!bytes || needsLen && len !== length4) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length4}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
   }
-  if (failures.length === 0) return void 0;
-  return `Rolling back the provisional session of profile "${profileName}" failed too (${failures.join("; ")}); check \`tc --profile ${profileName} context\`.`;
+  return value;
 }
-function failureName(error) {
-  if (error instanceof SyntaxError) return "a profile file is not valid JSON";
-  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") return error.code;
-  return error instanceof Error ? error.name : "unknown error";
+function hexToNumber(hex3) {
+  if (typeof hex3 !== "string")
+    throw new Error("hex string expected, got " + typeof hex3);
+  return hex3 === "" ? _0n : BigInt("0x" + hex3);
 }
-function annotate(error, note) {
-  if (note === void 0) return error;
-  const cause = wrapError(error);
-  return new CLIError(cause.code, `${cause.message} ${note}`, cause.exitCode, cause.metadata);
+function bytesToNumberBE(bytes) {
+  return hexToNumber(bytesToHex(bytes));
 }
-async function ensureAuthenticated(ctx, options) {
-  if (options?.privateKey) {
-    return createSDKInstance(ctx, options);
-  }
-  const profile = await ProfileManager.getProfile(ctx.profile).catch(() => null);
-  if (profile?.authMethod === "local" && profile.privateKey) {
-    return createSDKInstance(ctx);
-  }
-  const session = await ProfileManager.getSession(ctx.profile);
-  if (!session) {
-    throw new CLIError(
-      "AUTH_REQUIRED",
-      `Not authenticated. Run \`tc auth login\` or \`tc init\` first.`,
-      ExitCode.AUTH_REQUIRED
-    );
-  }
-  return createSDKInstance(ctx, options);
+function bytesToNumberLE(bytes) {
+  abytes(bytes);
+  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
 }
-var BOOTSTRAP_PROFILE_FIELDS;
-var init_sdk = __esm({
-  "src/lib/sdk.ts"() {
-    "use strict";
-    init_profiles();
-    init_types();
-    init_errors();
-    init_constants();
-    init_permissions();
-    init_session_expired();
-    init_warnings();
-    init_delegation_expiry();
-    BOOTSTRAP_PROFILE_FIELDS = ["sessionDid", "spaceId"];
+function numberToBytesBE(n, len) {
+  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+}
+function numberToBytesLE(n, len) {
+  return numberToBytesBE(n, len).reverse();
+}
+function ensureBytes(title, hex3, expectedLength) {
+  let res;
+  if (typeof hex3 === "string") {
+    try {
+      res = hexToBytes(hex3);
+    } catch (e) {
+      throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
+    }
+  } else if (isBytes(hex3)) {
+    res = Uint8Array.from(hex3);
+  } else {
+    throw new Error(title + " must be hex string or Uint8Array");
   }
-});
-
-// src/lib/host.ts
-var host_exports = {};
-__export(host_exports, {
-  completeDeferredLocalDiscovery: () => completeDeferredLocalDiscovery,
-  discoverLocalNodeHost: () => discoverLocalNodeHost,
-  isRootAuthority: () => isRootAuthority,
-  ownerDidFromSpaceUri: () => ownerDidFromSpaceUri,
-  profileLocalNodeIdentityStore: () => profileLocalNodeIdentityStore,
-  resolveHostSpace: () => resolveHostSpace,
-  spaceNameFromUri: () => spaceNameFromUri,
-  unhostedSpaceError: () => unhostedSpaceError
-});
-import {
-  discoverLocalTinyCloudNode
-} from "@tinycloud/sdk-core";
-function profileLocalNodeIdentityStore(profileName) {
-  return {
-    get: async (url) => {
-      const profile = await ProfileManager.getProfile(profileName).catch(
-        () => null
-      );
-      return profile?.pinnedLocalNodeDids?.[url];
-    },
-    set: async (url, nodeDid) => {
-      if (!await ProfileManager.profileExists(profileName)) return;
-      await ProfileManager.updateProfile(profileName, (profile) => ({
-        ...profile,
-        pinnedLocalNodeDids: {
-          ...profile.pinnedLocalNodeDids,
-          [url]: nodeDid
-        }
-      }));
-    }
-  };
+  const len = res.length;
+  if (typeof expectedLength === "number" && len !== expectedLength)
+    throw new Error(title + " of length " + expectedLength + " expected, got " + len);
+  return res;
 }
-async function discoverLocalNodeHost(profileName, options) {
-  const profile = await ProfileManager.getProfile(profileName).catch(() => null);
-  if (profile?.autoDiscoverLocalNode === false) return { host: null, deferred: false };
-  if (!profile?.localNodeUrl && !profile?.localLinkName) return { host: null, deferred: false };
-  if (options.awaitStoredSession) {
-    const { storedSessionVerifiesLocally: storedSessionVerifiesLocally2 } = await Promise.resolve().then(() => (init_sdk(), sdk_exports));
-    if (!await storedSessionVerifiesLocally2(profileName)) return { host: null, deferred: true };
-  }
-  const discovered = await discoverLocalTinyCloudNode({
-    localNodeUrl: profile?.localNodeUrl,
-    localLinkName: profile?.localLinkName,
-    expectedNodeDid: profile?.expectedNodeDid,
-    identityStore: profileLocalNodeIdentityStore(profileName)
-  });
-  return { host: discovered?.url ?? null, deferred: false };
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
 }
-async function completeDeferredLocalDiscovery(ctx) {
-  const deferred = ctx.localDiscovery;
-  if (deferred === void 0) return;
-  delete ctx.localDiscovery;
-  if (ctx.host !== deferred.deferredFrom) return;
-  const discovered = await discoverLocalNodeHost(ctx.profile, { awaitStoredSession: false });
-  if (discovered.host !== null) ctx.host = discovered.host;
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
 }
-function canonicalizeAddress2(address) {
-  const trimmed = address.trim();
-  return trimmed.startsWith("0x") ? `0x${trimmed.slice(2).toLowerCase()}` : trimmed.toLowerCase();
+function inRange(n, min, max) {
+  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
 }
-async function resolveLocalAddress(profile, profileName) {
-  const session = await ProfileManager.getSession(profileName);
-  const sessAddr = session?.address;
-  if (typeof sessAddr === "string" && sessAddr.length > 0) {
-    return canonicalizeAddress2(sessAddr);
+function aInRange(title, n, min, max) {
+  if (!inRange(n, min, max))
+    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
+}
+function bitLen(n) {
+  let len;
+  for (len = 0; n > _0n; n >>= _1n, len += 1)
+    ;
+  return len;
+}
+function _validateObject(object3, fields, optFields = {}) {
+  if (!object3 || typeof object3 !== "object")
+    throw new Error("expected valid options object");
+  function checkField(fieldName, expectedType, isOpt) {
+    const val = object3[fieldName];
+    if (isOpt && val === void 0)
+      return;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
   }
-  if (profile.address) return canonicalizeAddress2(profile.address);
-  if (profile.ownerDid) {
-    const match = profile.ownerDid.match(/^did:pkh:eip155:\d+:(0x[a-fA-F0-9]{40})$/);
-    if (match) return canonicalizeAddress2(match[1]);
+  Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
+  Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
+}
+function memoized(fn) {
+  const map = /* @__PURE__ */ new WeakMap();
+  return (arg, ...args) => {
+    const val = map.get(arg);
+    if (val !== void 0)
+      return val;
+    const computed = fn(arg, ...args);
+    map.set(arg, computed);
+    return computed;
+  };
+}
+var _0n, _1n, isPosBig, bitMask, notImplemented;
+var init_utils2 = __esm({
+  "../../node_modules/@noble/curves/esm/utils.js"() {
+    "use strict";
+    init_utils();
+    init_utils();
+    _0n = /* @__PURE__ */ BigInt(0);
+    _1n = /* @__PURE__ */ BigInt(1);
+    isPosBig = (n) => typeof n === "bigint" && _0n <= n;
+    bitMask = (n) => (_1n << BigInt(n)) - _1n;
+    notImplemented = () => {
+      throw new Error("not implemented");
+    };
   }
-  return null;
+});
+
+// ../../node_modules/@noble/curves/esm/abstract/modular.js
+function mod(a, b) {
+  const result = a % b;
+  return result >= _0n2 ? result : b + result;
 }
-function ownerAddressFromSpaceUri(spaceUri) {
-  const match = spaceUri.match(/^tinycloud:pkh:eip155:\d+:(0x[a-fA-F0-9]{40}):/);
-  return match ? canonicalizeAddress2(match[1]) : null;
+function pow2(x, power, modulo) {
+  let res = x;
+  while (power-- > _0n2) {
+    res *= res;
+    res %= modulo;
+  }
+  return res;
 }
-function ownerDidFromSpaceUri(spaceUri) {
-  const match = spaceUri.match(/^tinycloud:pkh:eip155:(\d+):(0x[a-fA-F0-9]{40}):/);
-  if (!match) return null;
-  return `did:pkh:eip155:${match[1]}:${canonicalizeAddress2(match[2])}`;
+function invert(number, modulo) {
+  if (number === _0n2)
+    throw new Error("invert: expected non-zero number");
+  if (modulo <= _0n2)
+    throw new Error("invert: expected positive modulus, got " + modulo);
+  let a = mod(number, modulo);
+  let b = modulo;
+  let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
+  while (a !== _0n2) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    const n = y - v * q;
+    b = a, a = r, x = u, y = v, u = m, v = n;
+  }
+  const gcd = b;
+  if (gcd !== _1n2)
+    throw new Error("invert: does not exist");
+  return mod(x, modulo);
 }
-async function isRootAuthority(spaceUri, profileName) {
-  const profile = await ProfileManager.getProfile(profileName);
-  if (resolveProfilePosture(profile) === "delegate-session") return false;
-  const ownerAddr = ownerAddressFromSpaceUri(spaceUri);
-  if (!ownerAddr) return false;
-  const selfAddr = await resolveLocalAddress(profile, profileName);
-  return selfAddr !== null && selfAddr === ownerAddr;
+function assertIsSquare(Fp2, root, n) {
+  if (!Fp2.eql(Fp2.sqr(root), n))
+    throw new Error("Cannot find square root");
 }
-function spaceNameFromUri(spaceUri) {
-  return spaceUri.slice(spaceUri.lastIndexOf(":") + 1);
+function sqrt3mod4(Fp2, n) {
+  const p1div4 = (Fp2.ORDER + _1n2) / _4n;
+  const root = Fp2.pow(n, p1div4);
+  assertIsSquare(Fp2, root, n);
+  return root;
 }
-async function unhostedSpaceError(error, spaceUri, profileName) {
-  if (!spaceUri) return null;
-  const status = error.meta?.status;
-  const isUnhosted = status === 404 && /space not found/i.test(error.message);
-  if (!isUnhosted) return null;
-  const spaceName = spaceNameFromUri(spaceUri);
-  const owner = await isRootAuthority(spaceUri, profileName);
-  const hint = owner ? [
-    "You are the owner. Host it once:",
-    `  tc space host ${spaceName}`,
-    "Then retry."
-  ].join("\n") : [
-    "You are a delegate and CANNOT host this space \u2014 only its owner can.",
-    "Emit a host request:",
-    `  tc space host-request ${spaceName} --emit ./host-request.json`,
-    "Send it to the owner; they run `tc space host` and confirm. Then retry."
-  ].join("\n");
-  const message = owner ? `Space '${spaceName}' (${spaceUri}) is not hosted.` : `Space '${spaceName}' (owner ${ownerDidFromSpaceUri(spaceUri) ?? spaceUri}) is not hosted.`;
-  return new CLIError("SPACE_NOT_HOSTED", message, ExitCode.ERROR, { hint });
+function sqrt5mod8(Fp2, n) {
+  const p5div8 = (Fp2.ORDER - _5n) / _8n;
+  const n2 = Fp2.mul(n, _2n);
+  const v = Fp2.pow(n2, p5div8);
+  const nv = Fp2.mul(n, v);
+  const i = Fp2.mul(Fp2.mul(nv, _2n), v);
+  const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
+  assertIsSquare(Fp2, root, n);
+  return root;
 }
-async function resolveHostSpace(name, profileName) {
-  const resolved = await resolveSpaceUri(name, profileName);
-  if (!resolved) {
-    throw new Error(`Could not resolve a space for "${name}".`);
-  }
-  return resolved;
+function sqrt9mod16(P) {
+  const Fp_ = Field(P);
+  const tn = tonelliShanks(P);
+  const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
+  const c2 = tn(Fp_, c1);
+  const c3 = tn(Fp_, Fp_.neg(c1));
+  const c4 = (P + _7n) / _16n;
+  return (Fp2, n) => {
+    let tv1 = Fp2.pow(n, c4);
+    let tv2 = Fp2.mul(tv1, c1);
+    const tv3 = Fp2.mul(tv1, c2);
+    const tv4 = Fp2.mul(tv1, c3);
+    const e1 = Fp2.eql(Fp2.sqr(tv2), n);
+    const e2 = Fp2.eql(Fp2.sqr(tv3), n);
+    tv1 = Fp2.cmov(tv1, tv2, e1);
+    tv2 = Fp2.cmov(tv4, tv3, e2);
+    const e3 = Fp2.eql(Fp2.sqr(tv2), n);
+    const root = Fp2.cmov(tv1, tv2, e3);
+    assertIsSquare(Fp2, root, n);
+    return root;
+  };
 }
-var init_host = __esm({
-  "src/lib/host.ts"() {
-    "use strict";
-    init_profiles();
-    init_constants();
-    init_types();
-    init_errors();
-    init_space();
-  }
-});
-
-// src/config/profiles.ts
-import { chmod as chmod2, lstat, readdir as readdir2, rm as rm2, rmdir } from "fs/promises";
-import { join as join4 } from "path";
-import {
-  profilePath,
-  readSession,
-  recordProfileDeletion,
-  refuseWriteToDeletedProfile as refuseWriteToDeletedProfile2,
-  removeSession,
-  withProfileLock as withProfileLock2,
-  writeSession
-} from "@tinycloud/operations/state";
-var ProfileManager;
-var init_profiles = __esm({
-  "src/config/profiles.ts"() {
-    "use strict";
-    init_constants();
-    init_storage2();
-    init_errors();
-    ProfileManager = class _ProfileManager {
-      // ── Initialization ──────────────────────────────────────────────────
-      /**
-       * Runs `action` holding the profile's store lock (shared with operations
-       * and MCP). Reentrant, so the writers below can be called inside it; hold
-       * it around a whole read-modify-write, not just each write.
-       */
-      static async withLock(name, action, options) {
-        return withProfileLock2(name, action, options);
-      }
-      /**
-       * Read-modify-write of profile.json under the profile lock, so concurrent
-       * updates (another command, a login commit) are never erased.
-       */
-      static async updateProfile(name, update) {
-        return _ProfileManager.withLock(name, async () => {
-          const next = update(await _ProfileManager.getProfile(name));
-          await _ProfileManager.setProfile(name, next);
-          return next;
-        });
-      }
-      /**
-       * Creates ~/.tinycloud/ and ~/.tinycloud/profiles/ if they don't exist and
-       * (re)sets both to 0700: older releases created them 0775.
-       */
-      static async ensureConfigDir() {
-        for (const directory of [CONFIG_DIR, PROFILES_DIR]) {
-          await ensureDir(directory);
-          await chmod2(directory, PRIVATE_DIR_MODE);
-        }
-      }
-      /** Owner-only profile directory (0700), created or tightened before any write into it. */
-      static async ensureProfileDir(name) {
-        await _ProfileManager.ensureConfigDir();
-        const profileDir = join4(PROFILES_DIR, name);
-        await ensureDir(profileDir);
-        await chmod2(profileDir, PRIVATE_DIR_MODE);
-        return profileDir;
-      }
-      // ── Global config ───────────────────────────────────────────────────
-      /**
-       * Reads config.json. Returns a default config if the file is missing.
-       */
-      static async getConfig() {
-        const config = await readJson(CONFIG_FILE);
-        if (!config) {
-          return { defaultProfile: DEFAULT_PROFILE, version: 1 };
-        }
-        return config;
-      }
-      /**
-       * Writes the global config to config.json.
-       */
-      static async setConfig(config) {
-        await _ProfileManager.ensureConfigDir();
-        await writeJson(CONFIG_FILE, config);
-      }
-      // ── Profile CRUD ────────────────────────────────────────────────────
-      /**
-       * Returns the profile config for the given name.
-       * Throws CLIError if the profile doesn't exist.
-       */
-      static async getProfile(name) {
-        const profilePath2 = join4(PROFILES_DIR, name, "profile.json");
-        const profile = await readJson(profilePath2);
-        if (!profile) {
-          throw new CLIError(
-            "PROFILE_NOT_FOUND",
-            `Profile "${name}" does not exist. Create it with \`tc init --name ${name}\`.`
-          );
-        }
-        return profile;
-      }
-      /**
-       * Saves a profile config under the profile lock, creating the profile
-       * directory if needed. Use `updateProfile` to change an existing profile.
-       */
-      static async setProfile(name, data) {
-        await _ProfileManager.withLock(name, async () => {
-          await writeJson(join4(await _ProfileManager.ensureProfileDir(name), "profile.json"), data);
-        });
-      }
-      /** Removes profile.json under the profile lock (rollback of a profile a failed login created). */
-      static async removeProfileConfig(name) {
-        await _ProfileManager.withLock(name, () => rm2(join4(PROFILES_DIR, name, "profile.json"), { force: true }));
-      }
-      /**
-       * Returns true if a profile directory exists.
-       */
-      static async profileExists(name) {
-        return fileExists(join4(PROFILES_DIR, name, "profile.json"));
-      }
-      /**
-       * Returns an array of profile directory names.
-       */
-      static async listProfiles() {
-        return listDirs(PROFILES_DIR);
-      }
-      /**
-       * Deletes a profile. Its key, session, settings, stores and cache are
-       * removed while holding the profile lock, so another writer's critical
-       * section never sees them vanish midway: session and key first, settings
-       * last, so a crash midway never leaves a session or key without its
-       * profile. The deletion is then recorded, so a store write that waited for
-       * the lock meanwhile refuses rather than recreating a profile with only a
-       * session in it. `.lock` itself is left to the lock's release; the
-       * then-empty directory is removed afterwards unless another writer took
-       * the lock (or wrote) meanwhile. A profile directory that is a symlink is
-       * unlinked, its target left alone.
-       * Throws if the name is not one path segment or names the default profile.
-       */
-      static async deleteProfile(name) {
-        let profileDir;
-        try {
-          profileDir = profilePath(name);
-        } catch {
-          throw new CLIError(
-            "INVALID_PROFILE_NAME",
-            `Invalid profile name "${name}": a profile name is one path segment (no "/", "\\", "." or "..").`,
-            ExitCode.USAGE_ERROR
-          );
-        }
-        const config = await _ProfileManager.getConfig();
-        if (config.defaultProfile === name) {
-          throw new CLIError(
-            "PROFILE_DELETE_DEFAULT",
-            `Cannot delete the default profile "${name}". Change the default first with \`tc profile default <other>\`.`
-          );
-        }
-        const kind = await lstat(profileDir).then((stats) => stats.isSymbolicLink() ? "link" : "present", (error) => {
-          if (error.code === "ENOENT") return "missing";
-          throw error;
-        });
-        if (kind === "missing") return;
-        if (kind === "link") {
-          await rm2(profileDir, { force: true });
-          return;
-        }
-        await _ProfileManager.withLock(name, async () => {
-          for (const file of ["session.json", "key.json"]) await rm2(join4(profileDir, file), { force: true });
-          for (const entry of await readdir2(profileDir)) {
-            if (entry !== ".lock" && entry !== "profile.json") await rm2(join4(profileDir, entry), { recursive: true, force: true });
-          }
-          await rm2(join4(profileDir, "profile.json"), { force: true });
-          await recordProfileDeletion(name);
-        });
-        await rmdir(profileDir).catch((error) => {
-          if (error.code !== "ENOENT" && error.code !== "ENOTEMPTY" && error.code !== "EEXIST") throw error;
-        });
-      }
-      // ── Key management ──────────────────────────────────────────────────
-      /**
-       * Returns the parsed JWK for a profile, or null if no key exists.
-       */
-      static async getKey(name) {
-        return readJson(join4(PROFILES_DIR, name, "key.json"));
-      }
-      /**
-       * Saves a JWK key under the profile lock (0600, in an owner-only profile
-       * directory). Refused (PROFILE_NOT_FOUND) if the profile was deleted while
-       * this waited for the lock, rather than leaving a key-only profile.
-       */
-      static async setKey(name, jwk) {
-        await _ProfileManager.withLock(name, async () => {
-          await refuseWriteToDeletedProfile2(name);
-          await writeJson(join4(await _ProfileManager.ensureProfileDir(name), "key.json"), jwk);
-        });
-      }
-      /** Removes key.json under the profile lock (rollback of a key a failed login created). */
-      static async removeKey(name) {
-        await _ProfileManager.withLock(name, () => rm2(join4(PROFILES_DIR, name, "key.json"), { force: true }));
-      }
-      // ── Session management ──────────────────────────────────────────────
-      /**
-       * Returns the parsed session for a profile, or null if none exists.
-       */
-      static async getSession(name) {
-        return readSession(name);
-      }
-      /**
-       * Saves session data for a profile.
-       */
-      static async setSession(name, session) {
-        await writeSession(name, session);
-      }
-      /**
-       * Removes the session file for a profile.
-       */
-      static async clearSession(name) {
-        await removeSession(name);
-      }
-      // ── Cache management ────────────────────────────────────────────────
-      /**
-       * Returns the profile's cache directory (share history lives here),
-       * created or tightened to 0700.
-       */
-      static async getCacheDir(name) {
-        const cacheDir = join4(await _ProfileManager.ensureProfileDir(name), "cache");
-        await ensureDir(cacheDir);
-        await chmod2(cacheDir, PRIVATE_DIR_MODE);
-        return cacheDir;
-      }
-      // ── Resolution helpers ──────────────────────────────────────────────
-      /**
-       * Resolves the full CLI context from flags, env vars, and config.
-       *
-       * Profile resolution: options.profile > TC_PROFILE env > config.defaultProfile > "default"
-       * Host resolution:    options.host    > TC_HOST env    > discovered local node > profile.host > DEFAULT_HOST
-       *
-       * Local-node discovery (TC-106) only runs when no explicit host was given
-       * (`--host` / `TC_HOST`); it probes configured or registered local nodes and,
-       * after DID verification against the profile's pinned identity, prefers one
-       * over the stored/default host. For session-using commands, it verifies the
-       * stored session locally before probing. Loopback requires an explicit
-       * `localNodeUrl`; disable discovery with `autoDiscoverLocalNode: false`.
-       */
-      static async resolveContext(options, settings = {}) {
-        const config = await _ProfileManager.getConfig();
-        const profile = options.profile ?? process.env.TC_PROFILE ?? config.defaultProfile ?? DEFAULT_PROFILE;
-        let profileHost;
-        try {
-          const profileConfig = await _ProfileManager.getProfile(profile);
-          profileHost = profileConfig.host;
-        } catch {
-        }
-        const explicitHost = options.host ?? process.env.TC_HOST;
-        let host = explicitHost ?? profileHost ?? DEFAULT_HOST;
-        let localDiscovery;
-        if (explicitHost === void 0) {
-          const { discoverLocalNodeHost: discoverLocalNodeHost2 } = await Promise.resolve().then(() => (init_host(), host_exports));
-          const explicitKey = Boolean(options.privateKey || process.env.TC_PRIVATE_KEY);
-          const discovered = await discoverLocalNodeHost2(profile, {
-            awaitStoredSession: settings.storedSession !== "unused" && !explicitKey
-          });
-          if (discovered.host !== null) host = discovered.host;
-          if (discovered.deferred) localDiscovery = { deferredFrom: host };
-        }
-        setActiveProfileName(profile);
-        return {
-          profile,
-          host,
-          verbose: options.verbose ?? false,
-          noCache: options.noCache ?? false,
-          quiet: options.quiet ?? false,
-          ...localDiscovery === void 0 ? {} : { localDiscovery }
-        };
-      }
-    };
-  }
-});
-
-// src/index.ts
-init_errors();
-import { readFileSync as readFileSync2 } from "fs";
-import { Command } from "commander";
-
-// src/output/banner.ts
-init_formatter();
-
-// src/output/taglines.ts
-var HOLIDAY_TAGLINES = [
-  { month: 1, day: 1, range: 1, tagline: "New year, new keys, same cloud." },
-  { month: 2, day: 14, tagline: "We love your data as much as you do." },
-  { month: 3, day: 14, tagline: "3.14159 reasons to encrypt everything." },
-  { month: 5, day: 4, tagline: "May the fourth be with your keys." },
-  { month: 10, day: 31, tagline: "Nothing scarier than plaintext secrets." },
-  { month: 12, day: 25, range: 2, tagline: "Unwrap your data, not your keys." },
-  { month: 12, day: 31, tagline: "Encrypt your resolutions." }
-];
-var TAGLINES = [
-  // Professional
-  "Your data, your keys, your cloud.",
-  "Self-sovereign storage for the modern web.",
-  "The cloud you actually own.",
-  "Encrypted by default, decentralized by design.",
-  "Where your data answers only to you.",
-  "End-to-end encrypted. No exceptions.",
-  "Like S3 but you hold the keys.",
-  "Privacy isn't a feature. It's the architecture.",
-  "Sovereign storage, zero knowledge.",
-  "Your .env is safe here \u2014 we use real cryptography.",
-  // Playful / nerdy
-  "UCAN do anything.",
-  "Keys generated, delegations granted, data liberated.",
-  "Decentralized storage, centralized vibes.",
-  "Trust nobody, delegate everything.",
-  "sudo make me a sandwich, encrypted.",
-  "Have you tried turning your keys off and on again?",
-  "All your base are belong to you.",
-  "In UCAN we trust.",
-  "0 knowledge, 100% confidence.",
-  "Keeping secrets since 2024."
-];
-function getHolidayTagline() {
-  const now = /* @__PURE__ */ new Date();
-  const month = now.getMonth() + 1;
-  const day = now.getDate();
-  for (const h of HOLIDAY_TAGLINES) {
-    const range = h.range ?? 0;
-    if (h.month === month && Math.abs(day - h.day) <= range) {
-      return h.tagline;
-    }
-  }
-  return null;
-}
-function pickTagline() {
-  const holiday = getHolidayTagline();
-  if (holiday) return holiday;
-  return TAGLINES[Math.floor(Math.random() * TAGLINES.length)];
-}
-
-// src/output/banner.ts
-init_theme();
-import { execSync } from "child_process";
-var bannerEmitted = false;
-function resolveCommitHash() {
-  try {
-    return execSync("git rev-parse --short HEAD", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim() || null;
-  } catch {
-    return null;
-  }
-}
-function formatBannerLine(version2) {
-  const commit = resolveCommitHash();
-  const tagline = pickTagline();
-  const versionPart = `tc v${version2}`;
-  const commitPart = commit ? ` (${commit})` : "";
-  const separator = " \u2014 ";
-  if (!isInteractive()) {
-    return `${versionPart}${commitPart}${separator}${tagline}`;
-  }
-  return [
-    theme.brand("\u2601\uFE0F  tc"),
-    " ",
-    theme.muted(`v${version2}`),
-    commit ? theme.dim(` (${commit})`) : "",
-    theme.dim(separator),
-    theme.primary(tagline)
-  ].join("");
-}
-function emitBanner(version2) {
-  if (bannerEmitted) return;
-  if (shouldOutputJson()) return;
-  if (process.env.TC_HIDE_BANNER === "1") return;
-  bannerEmitted = true;
-  process.stderr.write(formatBannerLine(version2) + "\n\n");
-}
-
-// src/index.ts
-init_theme();
-init_formatter();
-init_profiles();
-
-// ../share-sdk/dist/index.js
-init_sha2();
-
-// ../../node_modules/@noble/curves/esm/ed25519.js
-init_sha2();
-init_utils();
-
-// ../../node_modules/@noble/curves/esm/utils.js
-init_utils();
-init_utils();
-var _0n = /* @__PURE__ */ BigInt(0);
-var _1n = /* @__PURE__ */ BigInt(1);
-function _abool2(value, title = "") {
-  if (typeof value !== "boolean") {
-    const prefix = title && `"${title}"`;
-    throw new Error(prefix + "expected boolean, got type=" + typeof value);
-  }
-  return value;
-}
-function _abytes2(value, length4, title = "") {
-  const bytes = isBytes(value);
-  const len = value?.length;
-  const needsLen = length4 !== void 0;
-  if (!bytes || needsLen && len !== length4) {
-    const prefix = title && `"${title}" `;
-    const ofLen = needsLen ? ` of length ${length4}` : "";
-    const got = bytes ? `length=${len}` : `type=${typeof value}`;
-    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
-  }
-  return value;
-}
-function hexToNumber(hex3) {
-  if (typeof hex3 !== "string")
-    throw new Error("hex string expected, got " + typeof hex3);
-  return hex3 === "" ? _0n : BigInt("0x" + hex3);
-}
-function bytesToNumberBE(bytes) {
-  return hexToNumber(bytesToHex(bytes));
-}
-function bytesToNumberLE(bytes) {
-  abytes(bytes);
-  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
-}
-function numberToBytesBE(n, len) {
-  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
-}
-function numberToBytesLE(n, len) {
-  return numberToBytesBE(n, len).reverse();
-}
-function ensureBytes(title, hex3, expectedLength) {
-  let res;
-  if (typeof hex3 === "string") {
-    try {
-      res = hexToBytes(hex3);
-    } catch (e) {
-      throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
-    }
-  } else if (isBytes(hex3)) {
-    res = Uint8Array.from(hex3);
-  } else {
-    throw new Error(title + " must be hex string or Uint8Array");
-  }
-  const len = res.length;
-  if (typeof expectedLength === "number" && len !== expectedLength)
-    throw new Error(title + " of length " + expectedLength + " expected, got " + len);
-  return res;
-}
-function equalBytes(a, b) {
-  if (a.length !== b.length)
-    return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++)
-    diff |= a[i] ^ b[i];
-  return diff === 0;
-}
-function copyBytes(bytes) {
-  return Uint8Array.from(bytes);
-}
-var isPosBig = (n) => typeof n === "bigint" && _0n <= n;
-function inRange(n, min, max) {
-  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
-}
-function aInRange(title, n, min, max) {
-  if (!inRange(n, min, max))
-    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
-}
-function bitLen(n) {
-  let len;
-  for (len = 0; n > _0n; n >>= _1n, len += 1)
-    ;
-  return len;
-}
-var bitMask = (n) => (_1n << BigInt(n)) - _1n;
-function _validateObject(object3, fields, optFields = {}) {
-  if (!object3 || typeof object3 !== "object")
-    throw new Error("expected valid options object");
-  function checkField(fieldName, expectedType, isOpt) {
-    const val = object3[fieldName];
-    if (isOpt && val === void 0)
-      return;
-    const current = typeof val;
-    if (current !== expectedType || val === null)
-      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
-  }
-  Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
-  Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
-}
-var notImplemented = () => {
-  throw new Error("not implemented");
-};
-function memoized(fn) {
-  const map = /* @__PURE__ */ new WeakMap();
-  return (arg, ...args) => {
-    const val = map.get(arg);
-    if (val !== void 0)
-      return val;
-    const computed = fn(arg, ...args);
-    map.set(arg, computed);
-    return computed;
-  };
-}
-
-// ../../node_modules/@noble/curves/esm/abstract/modular.js
-var _0n2 = BigInt(0);
-var _1n2 = BigInt(1);
-var _2n = /* @__PURE__ */ BigInt(2);
-var _3n = /* @__PURE__ */ BigInt(3);
-var _4n = /* @__PURE__ */ BigInt(4);
-var _5n = /* @__PURE__ */ BigInt(5);
-var _7n = /* @__PURE__ */ BigInt(7);
-var _8n = /* @__PURE__ */ BigInt(8);
-var _9n = /* @__PURE__ */ BigInt(9);
-var _16n = /* @__PURE__ */ BigInt(16);
-function mod(a, b) {
-  const result = a % b;
-  return result >= _0n2 ? result : b + result;
-}
-function pow2(x, power, modulo) {
-  let res = x;
-  while (power-- > _0n2) {
-    res *= res;
-    res %= modulo;
-  }
-  return res;
-}
-function invert(number, modulo) {
-  if (number === _0n2)
-    throw new Error("invert: expected non-zero number");
-  if (modulo <= _0n2)
-    throw new Error("invert: expected positive modulus, got " + modulo);
-  let a = mod(number, modulo);
-  let b = modulo;
-  let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
-  while (a !== _0n2) {
-    const q = b / a;
-    const r = b % a;
-    const m = x - u * q;
-    const n = y - v * q;
-    b = a, a = r, x = u, y = v, u = m, v = n;
-  }
-  const gcd = b;
-  if (gcd !== _1n2)
-    throw new Error("invert: does not exist");
-  return mod(x, modulo);
-}
-function assertIsSquare(Fp2, root, n) {
-  if (!Fp2.eql(Fp2.sqr(root), n))
-    throw new Error("Cannot find square root");
-}
-function sqrt3mod4(Fp2, n) {
-  const p1div4 = (Fp2.ORDER + _1n2) / _4n;
-  const root = Fp2.pow(n, p1div4);
-  assertIsSquare(Fp2, root, n);
-  return root;
-}
-function sqrt5mod8(Fp2, n) {
-  const p5div8 = (Fp2.ORDER - _5n) / _8n;
-  const n2 = Fp2.mul(n, _2n);
-  const v = Fp2.pow(n2, p5div8);
-  const nv = Fp2.mul(n, v);
-  const i = Fp2.mul(Fp2.mul(nv, _2n), v);
-  const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
-  assertIsSquare(Fp2, root, n);
-  return root;
-}
-function sqrt9mod16(P) {
-  const Fp_ = Field(P);
-  const tn = tonelliShanks(P);
-  const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
-  const c2 = tn(Fp_, c1);
-  const c3 = tn(Fp_, Fp_.neg(c1));
-  const c4 = (P + _7n) / _16n;
-  return (Fp2, n) => {
-    let tv1 = Fp2.pow(n, c4);
-    let tv2 = Fp2.mul(tv1, c1);
-    const tv3 = Fp2.mul(tv1, c2);
-    const tv4 = Fp2.mul(tv1, c3);
-    const e1 = Fp2.eql(Fp2.sqr(tv2), n);
-    const e2 = Fp2.eql(Fp2.sqr(tv3), n);
-    tv1 = Fp2.cmov(tv1, tv2, e1);
-    tv2 = Fp2.cmov(tv4, tv3, e2);
-    const e3 = Fp2.eql(Fp2.sqr(tv2), n);
-    const root = Fp2.cmov(tv1, tv2, e3);
-    assertIsSquare(Fp2, root, n);
-    return root;
-  };
-}
-function tonelliShanks(P) {
-  if (P < _3n)
-    throw new Error("sqrt is not defined for small field");
-  let Q = P - _1n2;
-  let S = 0;
-  while (Q % _2n === _0n2) {
-    Q /= _2n;
-    S++;
+function tonelliShanks(P) {
+  if (P < _3n)
+    throw new Error("sqrt is not defined for small field");
+  let Q = P - _1n2;
+  let S = 0;
+  while (Q % _2n === _0n2) {
+    Q /= _2n;
+    S++;
   }
   let Z = _2n;
   const _Fp = Field(P);
@@ -6606,26 +6412,6 @@ function FpSqrt(P) {
     return sqrt9mod16(P);
   return tonelliShanks(P);
 }
-var isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n2) === _1n2;
-var FIELD_FIELDS = [
-  "create",
-  "isValid",
-  "is0",
-  "neg",
-  "inv",
-  "sqrt",
-  "sqr",
-  "eql",
-  "add",
-  "sub",
-  "mul",
-  "pow",
-  "div",
-  "addN",
-  "subN",
-  "mulN",
-  "sqrN"
-];
 function validateField(field) {
   const initial = {
     ORDER: "bigint",
@@ -6788,10 +6574,45 @@ function Field(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
   });
   return Object.freeze(f);
 }
+var _0n2, _1n2, _2n, _3n, _4n, _5n, _7n, _8n, _9n, _16n, isNegativeLE, FIELD_FIELDS;
+var init_modular = __esm({
+  "../../node_modules/@noble/curves/esm/abstract/modular.js"() {
+    "use strict";
+    init_utils2();
+    _0n2 = BigInt(0);
+    _1n2 = BigInt(1);
+    _2n = /* @__PURE__ */ BigInt(2);
+    _3n = /* @__PURE__ */ BigInt(3);
+    _4n = /* @__PURE__ */ BigInt(4);
+    _5n = /* @__PURE__ */ BigInt(5);
+    _7n = /* @__PURE__ */ BigInt(7);
+    _8n = /* @__PURE__ */ BigInt(8);
+    _9n = /* @__PURE__ */ BigInt(9);
+    _16n = /* @__PURE__ */ BigInt(16);
+    isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n2) === _1n2;
+    FIELD_FIELDS = [
+      "create",
+      "isValid",
+      "is0",
+      "neg",
+      "inv",
+      "sqrt",
+      "sqr",
+      "eql",
+      "add",
+      "sub",
+      "mul",
+      "pow",
+      "div",
+      "addN",
+      "subN",
+      "mulN",
+      "sqrN"
+    ];
+  }
+});
 
 // ../../node_modules/@noble/curves/esm/abstract/curve.js
-var _0n3 = BigInt(0);
-var _1n3 = BigInt(1);
 function negateCt(condition, item) {
   const neg = item.negate();
   return condition ? neg : item;
@@ -6845,8 +6666,6 @@ function validateMSMScalars(scalars, field) {
       throw new Error("invalid scalar at index " + i);
   });
 }
-var pointPrecomputes = /* @__PURE__ */ new WeakMap();
-var pointWindowSizes = /* @__PURE__ */ new WeakMap();
 function getW(P) {
   return pointWindowSizes.get(P) || 1;
 }
@@ -6854,133 +6673,6 @@ function assert0(n) {
   if (n !== _0n3)
     throw new Error("invalid wNAF");
 }
-var wNAF = class {
-  // Parametrized with a given Point class (not individual point)
-  constructor(Point, bits) {
-    this.BASE = Point.BASE;
-    this.ZERO = Point.ZERO;
-    this.Fn = Point.Fn;
-    this.bits = bits;
-  }
-  // non-const time multiplication ladder
-  _unsafeLadder(elm, n, p = this.ZERO) {
-    let d = elm;
-    while (n > _0n3) {
-      if (n & _1n3)
-        p = p.add(d);
-      d = d.double();
-      n >>= _1n3;
-    }
-    return p;
-  }
-  /**
-   * Creates a wNAF precomputation window. Used for caching.
-   * Default window size is set by `utils.precompute()` and is equal to 8.
-   * Number of precomputed points depends on the curve size:
-   * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
-   * - 𝑊 is the window size
-   * - 𝑛 is the bitlength of the curve order.
-   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
-   * @param point Point instance
-   * @param W window size
-   * @returns precomputed point tables flattened to a single array
-   */
-  precomputeWindow(point, W) {
-    const { windows, windowSize } = calcWOpts(W, this.bits);
-    const points = [];
-    let p = point;
-    let base4 = p;
-    for (let window = 0; window < windows; window++) {
-      base4 = p;
-      points.push(base4);
-      for (let i = 1; i < windowSize; i++) {
-        base4 = base4.add(p);
-        points.push(base4);
-      }
-      p = base4.double();
-    }
-    return points;
-  }
-  /**
-   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
-   * More compact implementation:
-   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
-   * @returns real and fake (for const-time) points
-   */
-  wNAF(W, precomputes, n) {
-    if (!this.Fn.isValid(n))
-      throw new Error("invalid scalar");
-    let p = this.ZERO;
-    let f = this.BASE;
-    const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
-      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
-      n = nextN;
-      if (isZero) {
-        f = f.add(negateCt(isNegF, precomputes[offsetF]));
-      } else {
-        p = p.add(negateCt(isNeg, precomputes[offset]));
-      }
-    }
-    assert0(n);
-    return { p, f };
-  }
-  /**
-   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
-   * @param acc accumulator point to add result of multiplication
-   * @returns point
-   */
-  wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
-    const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
-      if (n === _0n3)
-        break;
-      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
-      n = nextN;
-      if (isZero) {
-        continue;
-      } else {
-        const item = precomputes[offset];
-        acc = acc.add(isNeg ? item.negate() : item);
-      }
-    }
-    assert0(n);
-    return acc;
-  }
-  getPrecomputes(W, point, transform) {
-    let comp = pointPrecomputes.get(point);
-    if (!comp) {
-      comp = this.precomputeWindow(point, W);
-      if (W !== 1) {
-        if (typeof transform === "function")
-          comp = transform(comp);
-        pointPrecomputes.set(point, comp);
-      }
-    }
-    return comp;
-  }
-  cached(point, scalar, transform) {
-    const W = getW(point);
-    return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
-  }
-  unsafe(point, scalar, transform, prev) {
-    const W = getW(point);
-    if (W === 1)
-      return this._unsafeLadder(point, scalar, prev);
-    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
-  }
-  // We calculate precomputes for elliptic curve point multiplication
-  // using windowed method. This specifies window size and
-  // stores precomputed values. Usually only base point would be precomputed.
-  createCache(P, W) {
-    validateW(W, this.bits);
-    pointWindowSizes.set(P, W);
-    pointPrecomputes.delete(P);
-  }
-  hasCache(elm) {
-    return getW(elm) !== 1;
-  }
-};
 function pippenger(c, fieldN, points, scalars) {
   validateMSMPoints(points, c);
   validateMSMScalars(scalars, fieldN);
@@ -7051,12 +6743,147 @@ function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
   CURVE = Object.freeze(Object.assign({}, CURVE));
   return { CURVE, Fp: Fp2, Fn: Fn2 };
 }
+var _0n3, _1n3, pointPrecomputes, pointWindowSizes, wNAF;
+var init_curve = __esm({
+  "../../node_modules/@noble/curves/esm/abstract/curve.js"() {
+    "use strict";
+    init_utils2();
+    init_modular();
+    _0n3 = BigInt(0);
+    _1n3 = BigInt(1);
+    pointPrecomputes = /* @__PURE__ */ new WeakMap();
+    pointWindowSizes = /* @__PURE__ */ new WeakMap();
+    wNAF = class {
+      // Parametrized with a given Point class (not individual point)
+      constructor(Point, bits) {
+        this.BASE = Point.BASE;
+        this.ZERO = Point.ZERO;
+        this.Fn = Point.Fn;
+        this.bits = bits;
+      }
+      // non-const time multiplication ladder
+      _unsafeLadder(elm, n, p = this.ZERO) {
+        let d = elm;
+        while (n > _0n3) {
+          if (n & _1n3)
+            p = p.add(d);
+          d = d.double();
+          n >>= _1n3;
+        }
+        return p;
+      }
+      /**
+       * Creates a wNAF precomputation window. Used for caching.
+       * Default window size is set by `utils.precompute()` and is equal to 8.
+       * Number of precomputed points depends on the curve size:
+       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+       * - 𝑊 is the window size
+       * - 𝑛 is the bitlength of the curve order.
+       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+       * @param point Point instance
+       * @param W window size
+       * @returns precomputed point tables flattened to a single array
+       */
+      precomputeWindow(point, W) {
+        const { windows, windowSize } = calcWOpts(W, this.bits);
+        const points = [];
+        let p = point;
+        let base4 = p;
+        for (let window = 0; window < windows; window++) {
+          base4 = p;
+          points.push(base4);
+          for (let i = 1; i < windowSize; i++) {
+            base4 = base4.add(p);
+            points.push(base4);
+          }
+          p = base4.double();
+        }
+        return points;
+      }
+      /**
+       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+       * More compact implementation:
+       * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+       * @returns real and fake (for const-time) points
+       */
+      wNAF(W, precomputes, n) {
+        if (!this.Fn.isValid(n))
+          throw new Error("invalid scalar");
+        let p = this.ZERO;
+        let f = this.BASE;
+        const wo = calcWOpts(W, this.bits);
+        for (let window = 0; window < wo.windows; window++) {
+          const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
+          n = nextN;
+          if (isZero) {
+            f = f.add(negateCt(isNegF, precomputes[offsetF]));
+          } else {
+            p = p.add(negateCt(isNeg, precomputes[offset]));
+          }
+        }
+        assert0(n);
+        return { p, f };
+      }
+      /**
+       * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+       * @param acc accumulator point to add result of multiplication
+       * @returns point
+       */
+      wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
+        const wo = calcWOpts(W, this.bits);
+        for (let window = 0; window < wo.windows; window++) {
+          if (n === _0n3)
+            break;
+          const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
+          n = nextN;
+          if (isZero) {
+            continue;
+          } else {
+            const item = precomputes[offset];
+            acc = acc.add(isNeg ? item.negate() : item);
+          }
+        }
+        assert0(n);
+        return acc;
+      }
+      getPrecomputes(W, point, transform) {
+        let comp = pointPrecomputes.get(point);
+        if (!comp) {
+          comp = this.precomputeWindow(point, W);
+          if (W !== 1) {
+            if (typeof transform === "function")
+              comp = transform(comp);
+            pointPrecomputes.set(point, comp);
+          }
+        }
+        return comp;
+      }
+      cached(point, scalar, transform) {
+        const W = getW(point);
+        return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+      }
+      unsafe(point, scalar, transform, prev) {
+        const W = getW(point);
+        if (W === 1)
+          return this._unsafeLadder(point, scalar, prev);
+        return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+      }
+      // We calculate precomputes for elliptic curve point multiplication
+      // using windowed method. This specifies window size and
+      // stores precomputed values. Usually only base point would be precomputed.
+      createCache(P, W) {
+        validateW(W, this.bits);
+        pointWindowSizes.set(P, W);
+        pointPrecomputes.delete(P);
+      }
+      hasCache(elm) {
+        return getW(elm) !== 1;
+      }
+    };
+  }
+});
 
 // ../../node_modules/@noble/curves/esm/abstract/edwards.js
-var _0n4 = BigInt(0);
-var _1n4 = BigInt(1);
-var _2n2 = BigInt(2);
-var _8n2 = BigInt(8);
 function isEdValidXY(Fp2, CURVE, x, y) {
   const x2 = Fp2.sqr(x);
   const y2 = Fp2.sqr(y);
@@ -7340,828 +7167,1513 @@ function edwards(params, extraOpts = {}) {
   Point.BASE.precompute(8);
   return Point;
 }
-var PrimeEdwardsPoint = class {
-  constructor(ep) {
-    this.ep = ep;
-  }
-  // Static methods that must be implemented by subclasses
-  static fromBytes(_bytes) {
-    notImplemented();
-  }
-  static fromHex(_hex) {
-    notImplemented();
-  }
-  get x() {
-    return this.toAffine().x;
-  }
-  get y() {
-    return this.toAffine().y;
-  }
-  // Common implementations
-  clearCofactor() {
-    return this;
-  }
-  assertValidity() {
-    this.ep.assertValidity();
-  }
-  toAffine(invertedZ) {
-    return this.ep.toAffine(invertedZ);
-  }
-  toHex() {
-    return bytesToHex(this.toBytes());
-  }
-  toString() {
-    return this.toHex();
-  }
-  isTorsionFree() {
-    return true;
-  }
-  isSmallOrder() {
-    return false;
+function eddsa(Point, cHash, eddsaOpts = {}) {
+  if (typeof cHash !== "function")
+    throw new Error('"hash" function param is required');
+  _validateObject(eddsaOpts, {}, {
+    adjustScalarBytes: "function",
+    randomBytes: "function",
+    domain: "function",
+    prehash: "function",
+    mapToCurve: "function"
+  });
+  const { prehash } = eddsaOpts;
+  const { BASE, Fp: Fp2, Fn: Fn2 } = Point;
+  const randomBytes3 = eddsaOpts.randomBytes || randomBytes;
+  const adjustScalarBytes2 = eddsaOpts.adjustScalarBytes || ((bytes) => bytes);
+  const domain = eddsaOpts.domain || ((data, ctx, phflag) => {
+    _abool2(phflag, "phflag");
+    if (ctx.length || phflag)
+      throw new Error("Contexts/pre-hash are not supported");
+    return data;
+  });
+  function modN_LE(hash) {
+    return Fn2.create(bytesToNumberLE(hash));
+  }
+  function getPrivateScalar(key) {
+    const len = lengths.secretKey;
+    key = ensureBytes("private key", key, len);
+    const hashed = ensureBytes("hashed private key", cHash(key), 2 * len);
+    const head = adjustScalarBytes2(hashed.slice(0, len));
+    const prefix = hashed.slice(len, 2 * len);
+    const scalar = modN_LE(head);
+    return { head, prefix, scalar };
+  }
+  function getExtendedPublicKey(secretKey) {
+    const { head, prefix, scalar } = getPrivateScalar(secretKey);
+    const point = BASE.multiply(scalar);
+    const pointBytes = point.toBytes();
+    return { head, prefix, scalar, point, pointBytes };
+  }
+  function getPublicKey(secretKey) {
+    return getExtendedPublicKey(secretKey).pointBytes;
+  }
+  function hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
+    const msg = concatBytes(...msgs);
+    return modN_LE(cHash(domain(msg, ensureBytes("context", context), !!prehash)));
+  }
+  function sign(msg, secretKey, options = {}) {
+    msg = ensureBytes("message", msg);
+    if (prehash)
+      msg = prehash(msg);
+    const { prefix, scalar, pointBytes } = getExtendedPublicKey(secretKey);
+    const r = hashDomainToScalar(options.context, prefix, msg);
+    const R = BASE.multiply(r).toBytes();
+    const k = hashDomainToScalar(options.context, R, pointBytes, msg);
+    const s = Fn2.create(r + k * scalar);
+    if (!Fn2.isValid(s))
+      throw new Error("sign failed: invalid s");
+    const rs = concatBytes(R, Fn2.toBytes(s));
+    return _abytes2(rs, lengths.signature, "result");
+  }
+  const verifyOpts = { zip215: true };
+  function verify(sig, msg, publicKey, options = verifyOpts) {
+    const { context, zip215 } = options;
+    const len = lengths.signature;
+    sig = ensureBytes("signature", sig, len);
+    msg = ensureBytes("message", msg);
+    publicKey = ensureBytes("publicKey", publicKey, lengths.publicKey);
+    if (zip215 !== void 0)
+      _abool2(zip215, "zip215");
+    if (prehash)
+      msg = prehash(msg);
+    const mid = len / 2;
+    const r = sig.subarray(0, mid);
+    const s = bytesToNumberLE(sig.subarray(mid, len));
+    let A, R, SB;
+    try {
+      A = Point.fromBytes(publicKey, zip215);
+      R = Point.fromBytes(r, zip215);
+      SB = BASE.multiplyUnsafe(s);
+    } catch (error) {
+      return false;
+    }
+    if (!zip215 && A.isSmallOrder())
+      return false;
+    const k = hashDomainToScalar(context, R.toBytes(), A.toBytes(), msg);
+    const RkA = R.add(A.multiplyUnsafe(k));
+    return RkA.subtract(SB).clearCofactor().is0();
+  }
+  const _size = Fp2.BYTES;
+  const lengths = {
+    secretKey: _size,
+    publicKey: _size,
+    signature: 2 * _size,
+    seed: _size
+  };
+  function randomSecretKey(seed = randomBytes3(lengths.seed)) {
+    return _abytes2(seed, lengths.seed, "seed");
+  }
+  function keygen(seed) {
+    const secretKey = utils.randomSecretKey(seed);
+    return { secretKey, publicKey: getPublicKey(secretKey) };
+  }
+  function isValidSecretKey(key) {
+    return isBytes(key) && key.length === Fn2.BYTES;
+  }
+  function isValidPublicKey(key, zip215) {
+    try {
+      return !!Point.fromBytes(key, zip215);
+    } catch (error) {
+      return false;
+    }
+  }
+  const utils = {
+    getExtendedPublicKey,
+    randomSecretKey,
+    isValidSecretKey,
+    isValidPublicKey,
+    /**
+     * Converts ed public key to x public key. Uses formula:
+     * - ed25519:
+     *   - `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`
+     *   - `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`
+     * - ed448:
+     *   - `(u, v) = ((y-1)/(y+1), sqrt(156324)*u/x)`
+     *   - `(x, y) = (sqrt(156324)*u/v, (1+u)/(1-u))`
+     */
+    toMontgomery(publicKey) {
+      const { y } = Point.fromBytes(publicKey);
+      const size = lengths.publicKey;
+      const is25519 = size === 32;
+      if (!is25519 && size !== 57)
+        throw new Error("only defined for 25519 and 448");
+      const u = is25519 ? Fp2.div(_1n4 + y, _1n4 - y) : Fp2.div(y - _1n4, y + _1n4);
+      return Fp2.toBytes(u);
+    },
+    toMontgomerySecret(secretKey) {
+      const size = lengths.secretKey;
+      _abytes2(secretKey, size);
+      const hashed = cHash(secretKey.subarray(0, size));
+      return adjustScalarBytes2(hashed).subarray(0, size);
+    },
+    /** @deprecated */
+    randomPrivateKey: randomSecretKey,
+    /** @deprecated */
+    precompute(windowSize = 8, point = Point.BASE) {
+      return point.precompute(windowSize, false);
+    }
+  };
+  return Object.freeze({
+    keygen,
+    getPublicKey,
+    sign,
+    verify,
+    utils,
+    Point,
+    lengths
+  });
+}
+function _eddsa_legacy_opts_to_new(c) {
+  const CURVE = {
+    a: c.a,
+    d: c.d,
+    p: c.Fp.ORDER,
+    n: c.n,
+    h: c.h,
+    Gx: c.Gx,
+    Gy: c.Gy
+  };
+  const Fp2 = c.Fp;
+  const Fn2 = Field(CURVE.n, c.nBitLength, true);
+  const curveOpts = { Fp: Fp2, Fn: Fn2, uvRatio: c.uvRatio };
+  const eddsaOpts = {
+    randomBytes: c.randomBytes,
+    adjustScalarBytes: c.adjustScalarBytes,
+    domain: c.domain,
+    prehash: c.prehash,
+    mapToCurve: c.mapToCurve
+  };
+  return { CURVE, curveOpts, hash: c.hash, eddsaOpts };
+}
+function _eddsa_new_output_to_legacy(c, eddsa2) {
+  const Point = eddsa2.Point;
+  const legacy = Object.assign({}, eddsa2, {
+    ExtendedPoint: Point,
+    CURVE: c,
+    nBitLength: Point.Fn.BITS,
+    nByteLength: Point.Fn.BYTES
+  });
+  return legacy;
+}
+function twistedEdwards(c) {
+  const { CURVE, curveOpts, hash, eddsaOpts } = _eddsa_legacy_opts_to_new(c);
+  const Point = edwards(CURVE, curveOpts);
+  const EDDSA = eddsa(Point, hash, eddsaOpts);
+  return _eddsa_new_output_to_legacy(c, EDDSA);
+}
+var _0n4, _1n4, _2n2, _8n2, PrimeEdwardsPoint;
+var init_edwards = __esm({
+  "../../node_modules/@noble/curves/esm/abstract/edwards.js"() {
+    "use strict";
+    init_utils2();
+    init_curve();
+    init_modular();
+    _0n4 = BigInt(0);
+    _1n4 = BigInt(1);
+    _2n2 = BigInt(2);
+    _8n2 = BigInt(8);
+    PrimeEdwardsPoint = class {
+      constructor(ep) {
+        this.ep = ep;
+      }
+      // Static methods that must be implemented by subclasses
+      static fromBytes(_bytes) {
+        notImplemented();
+      }
+      static fromHex(_hex) {
+        notImplemented();
+      }
+      get x() {
+        return this.toAffine().x;
+      }
+      get y() {
+        return this.toAffine().y;
+      }
+      // Common implementations
+      clearCofactor() {
+        return this;
+      }
+      assertValidity() {
+        this.ep.assertValidity();
+      }
+      toAffine(invertedZ) {
+        return this.ep.toAffine(invertedZ);
+      }
+      toHex() {
+        return bytesToHex(this.toBytes());
+      }
+      toString() {
+        return this.toHex();
+      }
+      isTorsionFree() {
+        return true;
+      }
+      isSmallOrder() {
+        return false;
+      }
+      add(other) {
+        this.assertSame(other);
+        return this.init(this.ep.add(other.ep));
+      }
+      subtract(other) {
+        this.assertSame(other);
+        return this.init(this.ep.subtract(other.ep));
+      }
+      multiply(scalar) {
+        return this.init(this.ep.multiply(scalar));
+      }
+      multiplyUnsafe(scalar) {
+        return this.init(this.ep.multiplyUnsafe(scalar));
+      }
+      double() {
+        return this.init(this.ep.double());
+      }
+      negate() {
+        return this.init(this.ep.negate());
+      }
+      precompute(windowSize, isLazy) {
+        return this.init(this.ep.precompute(windowSize, isLazy));
+      }
+      /** @deprecated use `toBytes` */
+      toRawBytes() {
+        return this.toBytes();
+      }
+    };
   }
-  add(other) {
-    this.assertSame(other);
-    return this.init(this.ep.add(other.ep));
+});
+
+// ../../node_modules/@noble/curves/esm/ed25519.js
+function ed25519_pow_2_252_3(x) {
+  const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
+  const P = ed25519_CURVE_p;
+  const x2 = x * x % P;
+  const b2 = x2 * x % P;
+  const b4 = pow2(b2, _2n3, P) * b2 % P;
+  const b5 = pow2(b4, _1n5, P) * x % P;
+  const b10 = pow2(b5, _5n2, P) * b5 % P;
+  const b20 = pow2(b10, _10n, P) * b10 % P;
+  const b40 = pow2(b20, _20n, P) * b20 % P;
+  const b80 = pow2(b40, _40n, P) * b40 % P;
+  const b160 = pow2(b80, _80n, P) * b80 % P;
+  const b240 = pow2(b160, _80n, P) * b80 % P;
+  const b250 = pow2(b240, _10n, P) * b10 % P;
+  const pow_p_5_8 = pow2(b250, _2n3, P) * x % P;
+  return { pow_p_5_8, b2 };
+}
+function adjustScalarBytes(bytes) {
+  bytes[0] &= 248;
+  bytes[31] &= 127;
+  bytes[31] |= 64;
+  return bytes;
+}
+function uvRatio(u, v) {
+  const P = ed25519_CURVE_p;
+  const v3 = mod(v * v * v, P);
+  const v7 = mod(v3 * v3 * v, P);
+  const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
+  let x = mod(u * v3 * pow, P);
+  const vx2 = mod(v * x * x, P);
+  const root1 = x;
+  const root2 = mod(x * ED25519_SQRT_M1, P);
+  const useRoot1 = vx2 === u;
+  const useRoot2 = vx2 === mod(-u, P);
+  const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P);
+  if (useRoot1)
+    x = root1;
+  if (useRoot2 || noRoot)
+    x = root2;
+  if (isNegativeLE(x, P))
+    x = mod(-x, P);
+  return { isValid: useRoot1 || useRoot2, value: x };
+}
+function calcElligatorRistrettoMap(r0) {
+  const { d } = ed25519_CURVE;
+  const P = ed25519_CURVE_p;
+  const mod2 = (n) => Fp.create(n);
+  const r = mod2(SQRT_M1 * r0 * r0);
+  const Ns = mod2((r + _1n5) * ONE_MINUS_D_SQ);
+  let c = BigInt(-1);
+  const D = mod2((c - d * r) * mod2(r + d));
+  let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D);
+  let s_ = mod2(s * r0);
+  if (!isNegativeLE(s_, P))
+    s_ = mod2(-s_);
+  if (!Ns_D_is_sq)
+    s = s_;
+  if (!Ns_D_is_sq)
+    c = r;
+  const Nt = mod2(c * (r - _1n5) * D_MINUS_ONE_SQ - D);
+  const s2 = s * s;
+  const W0 = mod2((s + s) * D);
+  const W1 = mod2(Nt * SQRT_AD_MINUS_ONE);
+  const W2 = mod2(_1n5 - s2);
+  const W3 = mod2(_1n5 + s2);
+  return new ed25519.Point(mod2(W0 * W3), mod2(W2 * W1), mod2(W1 * W3), mod2(W0 * W2));
+}
+function ristretto255_map(bytes) {
+  abytes(bytes, 64);
+  const r1 = bytes255ToNumberLE(bytes.subarray(0, 32));
+  const R1 = calcElligatorRistrettoMap(r1);
+  const r2 = bytes255ToNumberLE(bytes.subarray(32, 64));
+  const R2 = calcElligatorRistrettoMap(r2);
+  return new _RistrettoPoint(R1.add(R2));
+}
+var _0n5, _1n5, _2n3, _3n2, _5n2, _8n3, ed25519_CURVE_p, ed25519_CURVE, ED25519_SQRT_M1, Fp, Fn, ed25519Defaults, ed25519, SQRT_M1, SQRT_AD_MINUS_ONE, INVSQRT_A_MINUS_D, ONE_MINUS_D_SQ, D_MINUS_ONE_SQ, invertSqrt, MAX_255B, bytes255ToNumberLE, _RistrettoPoint;
+var init_ed25519 = __esm({
+  "../../node_modules/@noble/curves/esm/ed25519.js"() {
+    "use strict";
+    init_sha2();
+    init_utils();
+    init_curve();
+    init_edwards();
+    init_modular();
+    init_utils2();
+    _0n5 = /* @__PURE__ */ BigInt(0);
+    _1n5 = BigInt(1);
+    _2n3 = BigInt(2);
+    _3n2 = BigInt(3);
+    _5n2 = BigInt(5);
+    _8n3 = BigInt(8);
+    ed25519_CURVE_p = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
+    ed25519_CURVE = /* @__PURE__ */ (() => ({
+      p: ed25519_CURVE_p,
+      n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),
+      h: _8n3,
+      a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),
+      d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),
+      Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),
+      Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")
+    }))();
+    ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
+    Fp = /* @__PURE__ */ (() => Field(ed25519_CURVE.p, { isLE: true }))();
+    Fn = /* @__PURE__ */ (() => Field(ed25519_CURVE.n, { isLE: true }))();
+    ed25519Defaults = /* @__PURE__ */ (() => ({
+      ...ed25519_CURVE,
+      Fp,
+      hash: sha512,
+      adjustScalarBytes,
+      // dom2
+      // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
+      // Constant-time, u/√v
+      uvRatio
+    }))();
+    ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();
+    SQRT_M1 = ED25519_SQRT_M1;
+    SQRT_AD_MINUS_ONE = /* @__PURE__ */ BigInt("25063068953384623474111414158702152701244531502492656460079210482610430750235");
+    INVSQRT_A_MINUS_D = /* @__PURE__ */ BigInt("54469307008909316920995813868745141605393597292927456921205312896311721017578");
+    ONE_MINUS_D_SQ = /* @__PURE__ */ BigInt("1159843021668779879193775521855586647937357759715417654439879720876111806838");
+    D_MINUS_ONE_SQ = /* @__PURE__ */ BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952");
+    invertSqrt = (number) => uvRatio(_1n5, number);
+    MAX_255B = /* @__PURE__ */ BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+    bytes255ToNumberLE = (bytes) => ed25519.Point.Fp.create(bytesToNumberLE(bytes) & MAX_255B);
+    _RistrettoPoint = class __RistrettoPoint extends PrimeEdwardsPoint {
+      constructor(ep) {
+        super(ep);
+      }
+      static fromAffine(ap) {
+        return new __RistrettoPoint(ed25519.Point.fromAffine(ap));
+      }
+      assertSame(other) {
+        if (!(other instanceof __RistrettoPoint))
+          throw new Error("RistrettoPoint expected");
+      }
+      init(ep) {
+        return new __RistrettoPoint(ep);
+      }
+      /** @deprecated use `import { ristretto255_hasher } from '@noble/curves/ed25519.js';` */
+      static hashToCurve(hex3) {
+        return ristretto255_map(ensureBytes("ristrettoHash", hex3, 64));
+      }
+      static fromBytes(bytes) {
+        abytes(bytes, 32);
+        const { a, d } = ed25519_CURVE;
+        const P = ed25519_CURVE_p;
+        const mod2 = (n) => Fp.create(n);
+        const s = bytes255ToNumberLE(bytes);
+        if (!equalBytes(Fp.toBytes(s), bytes) || isNegativeLE(s, P))
+          throw new Error("invalid ristretto255 encoding 1");
+        const s2 = mod2(s * s);
+        const u1 = mod2(_1n5 + a * s2);
+        const u2 = mod2(_1n5 - a * s2);
+        const u1_2 = mod2(u1 * u1);
+        const u2_2 = mod2(u2 * u2);
+        const v = mod2(a * d * u1_2 - u2_2);
+        const { isValid: isValid3, value: I } = invertSqrt(mod2(v * u2_2));
+        const Dx = mod2(I * u2);
+        const Dy = mod2(I * Dx * v);
+        let x = mod2((s + s) * Dx);
+        if (isNegativeLE(x, P))
+          x = mod2(-x);
+        const y = mod2(u1 * Dy);
+        const t = mod2(x * y);
+        if (!isValid3 || isNegativeLE(t, P) || y === _0n5)
+          throw new Error("invalid ristretto255 encoding 2");
+        return new __RistrettoPoint(new ed25519.Point(x, y, _1n5, t));
+      }
+      /**
+       * Converts ristretto-encoded string to ristretto point.
+       * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-decode).
+       * @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding
+       */
+      static fromHex(hex3) {
+        return __RistrettoPoint.fromBytes(ensureBytes("ristrettoHex", hex3, 32));
+      }
+      static msm(points, scalars) {
+        return pippenger(__RistrettoPoint, ed25519.Point.Fn, points, scalars);
+      }
+      /**
+       * Encodes ristretto point to Uint8Array.
+       * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-encode).
+       */
+      toBytes() {
+        let { X, Y, Z, T } = this.ep;
+        const P = ed25519_CURVE_p;
+        const mod2 = (n) => Fp.create(n);
+        const u1 = mod2(mod2(Z + Y) * mod2(Z - Y));
+        const u2 = mod2(X * Y);
+        const u2sq = mod2(u2 * u2);
+        const { value: invsqrt } = invertSqrt(mod2(u1 * u2sq));
+        const D1 = mod2(invsqrt * u1);
+        const D2 = mod2(invsqrt * u2);
+        const zInv = mod2(D1 * D2 * T);
+        let D;
+        if (isNegativeLE(T * zInv, P)) {
+          let _x = mod2(Y * SQRT_M1);
+          let _y = mod2(X * SQRT_M1);
+          X = _x;
+          Y = _y;
+          D = mod2(D1 * INVSQRT_A_MINUS_D);
+        } else {
+          D = D2;
+        }
+        if (isNegativeLE(X * zInv, P))
+          Y = mod2(-Y);
+        let s = mod2((Z - Y) * D);
+        if (isNegativeLE(s, P))
+          s = mod2(-s);
+        return Fp.toBytes(s);
+      }
+      /**
+       * Compares two Ristretto points.
+       * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-equals).
+       */
+      equals(other) {
+        this.assertSame(other);
+        const { X: X1, Y: Y1 } = this.ep;
+        const { X: X2, Y: Y2 } = other.ep;
+        const mod2 = (n) => Fp.create(n);
+        const one = mod2(X1 * Y2) === mod2(Y1 * X2);
+        const two = mod2(Y1 * Y2) === mod2(X1 * X2);
+        return one || two;
+      }
+      is0() {
+        return this.equals(__RistrettoPoint.ZERO);
+      }
+    };
+    _RistrettoPoint.BASE = /* @__PURE__ */ (() => new _RistrettoPoint(ed25519.Point.BASE))();
+    _RistrettoPoint.ZERO = /* @__PURE__ */ (() => new _RistrettoPoint(ed25519.Point.ZERO))();
+    _RistrettoPoint.Fp = /* @__PURE__ */ (() => Fp)();
+    _RistrettoPoint.Fn = /* @__PURE__ */ (() => Fn)();
   }
-  subtract(other) {
-    this.assertSame(other);
-    return this.init(this.ep.subtract(other.ep));
+});
+
+// ../replica/dist/index.js
+function assertFolderPrefix(prefix) {
+  const validFolder = typeof prefix === "string" && prefix.length > 0 && !prefix.startsWith("/") && !prefix.includes("//") && prefix.endsWith("/");
+  if (prefix !== "/" && !validFolder) {
+    const folderHint = typeof prefix === "string" ? prefix.replace(/^\/+/, "").replace(/\/+$/, "") : "";
+    const suggestion = folderHint.length > 0 && !folderHint.includes("//") ? ` Use ${JSON.stringify(`${folderHint}/`)}.` : ' Use "/" or a slash-terminated folder path such as "notes/".';
+    throw new TypeError(`Replication prefix must be "/" or a non-empty slash-terminated folder path without empty segments.${suggestion}`);
   }
-  multiply(scalar) {
-    return this.init(this.ep.multiply(scalar));
+}
+function assertFolderPrefix2(prefix) {
+  try {
+    assertFolderPrefix(prefix);
+  } catch {
+    const folderHint = typeof prefix === "string" ? prefix.replace(/^\/+/, "").replace(/\/+$/, "") : "";
+    const suggestion = prefix === "" ? 'use "/" for the whole space' : folderHint.length > 0 && !folderHint.includes("//") ? `use ${JSON.stringify(`${folderHint}/`)}` : 'use "/" for the whole space or a folder path such as "notes/"';
+    throw new ReplicaError(
+      ReplicaErrorCode.INVALID_ARGUMENT,
+      `Replication prefix ${JSON.stringify(prefix)} must be "/" or a non-empty folder path ending in / without empty segments; ${suggestion}. Run \`tc replica reset --replica <name> --purge\` and recreate it with the folder prefix.`
+    );
   }
-  multiplyUnsafe(scalar) {
-    return this.init(this.ep.multiplyUnsafe(scalar));
+}
+var ReplicaErrorCode, REPLICA_ERROR, ReplicaError, PENDING_REFUSALS, encoder;
+var init_dist = __esm({
+  "../replica/dist/index.js"() {
+    "use strict";
+    ReplicaErrorCode = {
+      /** Another process holds the sync lease. */
+      BUSY: "REPLICA_BUSY",
+      /** No replica with this name exists. */
+      NOT_FOUND: "REPLICA_NOT_FOUND",
+      /** The replica exists but its stored configuration differs from the request. */
+      CONFIG_MISMATCH: "REPLICA_CONFIG_MISMATCH",
+      /** The runtime has no supported durable store (e.g. Node < 22.13). */
+      RUNTIME_UNSUPPORTED: "RUNTIME_UNSUPPORTED",
+      /** A required open() argument is missing or malformed (e.g. `principal`). */
+      INVALID_ARGUMENT: "REPLICA_INVALID_ARGUMENT",
+      /** The local store failed (I/O, corruption, schema). */
+      STORAGE_ERROR: "STORAGE_ERROR",
+      /** The local disk is full. */
+      STORAGE_FULL: "STORAGE_FULL",
+      /** The key is outside the replica's prefix. */
+      NOT_COVERED: "NOT_COVERED",
+      /** Syncing the secrets space or the vault namespace needs an explicit opt-in. */
+      SECRETS_OPT_IN_REQUIRED: "SECRETS_OPT_IN_REQUIRED",
+      /** No grant is installed, or none covers the requested scope. */
+      GRANT_MISSING: "GRANT_MISSING",
+      /** The grant bytes are not a verifiable UCAN, or its signature is wrong. */
+      GRANT_INVALID: "GRANT_INVALID",
+      /** SIWE/CACAO and other non-UCAN grants cannot be used for a replica. */
+      GRANT_FORMAT_UNSUPPORTED: "GRANT_FORMAT_UNSUPPORTED",
+      /** The grant was issued to a different device. */
+      GRANT_AUDIENCE_MISMATCH: "GRANT_AUDIENCE_MISMATCH",
+      /** The grant lacks `tinycloud.kv/sync` or `tinycloud.kv/get` on the prefix. */
+      GRANT_NOT_COVERING: "GRANT_NOT_COVERING",
+      GRANT_NOT_YET_VALID: "GRANT_NOT_YET_VALID",
+      GRANT_EXPIRED: "GRANT_EXPIRED",
+      /** The configured node does not advertise whole-space KV sync support. */
+      REPLICATION_ROOT_UNSUPPORTED: "REPLICATION_ROOT_UNSUPPORTED",
+      GRANT_REVOKED: "GRANT_REVOKED",
+      /** The node refused the invocation for a reason other than revocation. */
+      GRANT_UNAUTHORIZED: "GRANT_UNAUTHORIZED",
+      /** The node refused the retention grant. */
+      RETENTION_GRANT_REFUSED: "RETENTION_GRANT_REFUSED",
+      /** The node could not be reached. */
+      NETWORK_ERROR: "NETWORK_ERROR",
+      /** The node answered with an unexpected status. */
+      NODE_ERROR: "NODE_ERROR",
+      /** The node's answer violates the wire contract. */
+      PROTOCOL_ERROR: "PROTOCOL_ERROR",
+      /** The node asked for a fresh bootstrap (410). Handled inside sync. */
+      RESET_REQUIRED: "RESET_REQUIRED",
+      /** The feed now comes from a different node than the one pinned. */
+      SOURCE_CHANGED: "SOURCE_CHANGED",
+      /** The feed delivered a key outside the replica's prefix. */
+      SCOPE_VIOLATION: "SCOPE_VIOLATION",
+      /** Fetched bytes do not hash to the ETag the node attested for them. */
+      CONTENT_MISMATCH: "CONTENT_MISMATCH",
+      /** A stored blob no longer hashes to its name. */
+      INTEGRITY_ERROR: "INTEGRITY_ERROR",
+      /** The replica handle was closed; in-flight calls settle with this code. */
+      CLOSED: "REPLICA_CLOSED"
+    };
+    REPLICA_ERROR = /* @__PURE__ */ Symbol.for("tinycloud.replica.error");
+    ReplicaError = class extends Error {
+      [REPLICA_ERROR] = true;
+      code;
+      detail;
+      constructor(code3, message, detail, options) {
+        super(message, options);
+        this.name = "ReplicaError";
+        this.code = code3;
+        if (detail !== void 0) this.detail = detail;
+      }
+    };
+    PENDING_REFUSALS = /* @__PURE__ */ new Set([
+      ReplicaErrorCode.GRANT_UNAUTHORIZED,
+      ReplicaErrorCode.GRANT_EXPIRED,
+      ReplicaErrorCode.GRANT_NOT_YET_VALID
+    ]);
+    encoder = new TextEncoder();
   }
-  double() {
-    return this.init(this.ep.double());
+});
+
+// src/lib/replication-config.ts
+import { join as join5 } from "path";
+import { profilePath, withProfileLock as withProfileLock2 } from "@tinycloud/operations/state";
+import { sqliteReplicaStorage } from "@tinycloud/node-sdk";
+function createCliReplicationConfig(profile, settings, output, enabled) {
+  if (!enabled || !settings || settings.prefixes.length === 0) return void 0;
+  for (const prefix of settings.prefixes) {
+    try {
+      assertFolderPrefix2(prefix);
+    } catch (error) {
+      const trimmed = prefix.replace(/^\/+/, "").replace(/\/+$/, "");
+      const replacement = trimmed.length > 0 && !trimmed.includes("//") ? `${trimmed}/` : "/";
+      throw new CLIError(
+        "INVALID_REPLICATION_PREFIX",
+        error instanceof Error ? error.message : String(error),
+        ExitCode.USAGE_ERROR,
+        { hint: `Replace the saved replication prefix with \`tc auth login --replication-prefix ${replacement}\`; purging a replica alone does not change this profile setting.` }
+      );
+    }
   }
-  negate() {
-    return this.init(this.ep.negate());
+  const root = profilePath(profile);
+  return {
+    enabled: true,
+    prefixes: settings.prefixes,
+    allowSecrets: settings.allowSecrets === true,
+    mode: "foreground",
+    verify: process.env.TC_REPLICATION_VERIFY === "1",
+    maxStalenessMs: Number(process.env.TC_REPLICATION_MAX_STALENESS_MS ?? 6e4),
+    staleSyncTimeoutMs: Number(process.env.TC_REPLICATION_SYNC_TIMEOUT_MS ?? 1e4),
+    storage: sqliteReplicaStorage({
+      dir: join5(root, "replication"),
+      guard: (section) => withProfileLock2(profile, section, { requireProfile: true, timeoutMs: 35e3 })
+    }),
+    onEvent: createReplicationEventSink(root, output)
+  };
+}
+var init_replication_config = __esm({
+  "src/lib/replication-config.ts"() {
+    "use strict";
+    init_replication_log();
+    init_dist();
+    init_errors();
+    init_constants();
   }
-  precompute(windowSize, isLazy) {
-    return this.init(this.ep.precompute(windowSize, isLazy));
+});
+
+// src/lib/sdk.ts
+var sdk_exports = {};
+__export(sdk_exports, {
+  bootstrapDelegatedSession: () => bootstrapDelegatedSession,
+  closeReplication: () => closeReplication,
+  createSDKInstance: () => createSDKInstance,
+  ensureAuthenticated: () => ensureAuthenticated,
+  jwkHasPrivateParameter: () => jwkHasPrivateParameter,
+  registerReplication: () => registerReplication,
+  registeredReplications: () => registeredReplications,
+  replicationForProfile: () => replicationForProfile,
+  restoreProfileSessionNode: () => restoreProfileSessionNode,
+  selectSignerJwk: () => selectSignerJwk,
+  storedSessionVerifiesLocally: () => storedSessionVerifiesLocally
+});
+import { TinyCloudNode, signedCompactUcanExpiry } from "@tinycloud/node-sdk";
+function jwkHasPrivateParameter(jwk) {
+  if (!jwk || typeof jwk !== "object") return false;
+  const d = jwk.d;
+  return typeof d === "string" && d.length > 0;
+}
+function selectSignerJwk(sessionJwk, key) {
+  if (jwkHasPrivateParameter(sessionJwk)) {
+    return sessionJwk;
   }
-  /** @deprecated use `toBytes` */
-  toRawBytes() {
-    return this.toBytes();
+  return key ?? void 0;
+}
+function signerJwkForProfile(profileName, sessionJwk, key) {
+  const jwk = selectSignerJwk(sessionJwk, key);
+  if (jwkHasPrivateParameter(jwk)) {
+    return jwk;
   }
-};
-function eddsa(Point, cHash, eddsaOpts = {}) {
-  if (typeof cHash !== "function")
-    throw new Error('"hash" function param is required');
-  _validateObject(eddsaOpts, {}, {
-    adjustScalarBytes: "function",
-    randomBytes: "function",
-    domain: "function",
-    prehash: "function",
-    mapToCurve: "function"
-  });
-  const { prehash } = eddsaOpts;
-  const { BASE, Fp: Fp2, Fn: Fn2 } = Point;
-  const randomBytes3 = eddsaOpts.randomBytes || randomBytes;
-  const adjustScalarBytes2 = eddsaOpts.adjustScalarBytes || ((bytes) => bytes);
-  const domain = eddsaOpts.domain || ((data, ctx, phflag) => {
-    _abool2(phflag, "phflag");
-    if (ctx.length || phflag)
-      throw new Error("Contexts/pre-hash are not supported");
-    return data;
-  });
-  function modN_LE(hash) {
-    return Fn2.create(bytesToNumberLE(hash));
+  throw new CLIError(
+    "AUTH_REQUIRED",
+    `Profile "${profileName}" cannot restore its session because its private key material is missing.`,
+    ExitCode.AUTH_REQUIRED,
+    {
+      hint: `Sign in again with: tc --profile ${profileName} auth login --method openkey`
+    }
+  );
+}
+function signedLifetimePassed(delegation) {
+  const authorization = delegation.delegationHeader?.Authorization;
+  const expiry = typeof authorization === "string" ? signedCompactUcanExpiry(authorization) : void 0;
+  return expiry !== void 0 && expiry.getTime() <= Date.now();
+}
+async function restoreProfileSession(node, profileName, profile, sessionData) {
+  try {
+    await node.restoreSession(sessionData);
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "AUTH_EXPIRED") {
+      throw sessionExpiredError(profileName, profile === null ? void 0 : resolveProfilePosture(profile));
+    }
+    throw error;
   }
-  function getPrivateScalar(key) {
-    const len = lengths.secretKey;
-    key = ensureBytes("private key", key, len);
-    const hashed = ensureBytes("hashed private key", cHash(key), 2 * len);
-    const head = adjustScalarBytes2(hashed.slice(0, len));
-    const prefix = hashed.slice(len, 2 * len);
-    const scalar = modN_LE(head);
-    return { head, prefix, scalar };
+}
+function persistedSessionData(profileName, profile, session, key) {
+  return {
+    delegationHeader: session.delegationHeader,
+    delegationCid: session.delegationCid,
+    spaceId: session.spaceId,
+    jwk: signerJwkForProfile(profileName, session.jwk, key),
+    verificationMethod: session.verificationMethod ?? profile.sessionDid ?? profile.did,
+    address: session.address,
+    chainId: session.chainId,
+    siwe: session.siwe,
+    signature: session.signature
+  };
+}
+async function restoreProfileSessionNode(ctx) {
+  const profile = await ProfileManager.getProfile(ctx.profile);
+  const session = await ProfileManager.getSession(ctx.profile);
+  if (!session) return { unavailable: "session_missing" };
+  if (typeof session.delegationCid !== "string" || typeof session.spaceId !== "string" || session.delegationHeader === null || typeof session.delegationHeader !== "object" || !("Authorization" in session.delegationHeader) || typeof session.delegationHeader.Authorization !== "string") {
+    return { unavailable: "session_invalid" };
   }
-  function getExtendedPublicKey(secretKey) {
-    const { head, prefix, scalar } = getPrivateScalar(secretKey);
-    const point = BASE.multiply(scalar);
-    const pointBytes = point.toBytes();
-    return { head, prefix, scalar, point, pointBytes };
+  if (typeof session.expiresAt === "string" && Date.parse(session.expiresAt) <= Date.now()) {
+    return { unavailable: "session_expired" };
   }
-  function getPublicKey(secretKey) {
-    return getExtendedPublicKey(secretKey).pointBytes;
+  const key = await ProfileManager.getKey(ctx.profile);
+  try {
+    const node = new TinyCloudNode({
+      host: ctx.host,
+      ...profile.authMethod === "local" && profile.privateKey ? { privateKey: profile.privateKey } : {}
+    });
+    await restoreProfileSession(node, ctx.profile, profile, persistedSessionData(ctx.profile, profile, session, key));
+    return { node };
+  } catch (error) {
+    if (error instanceof CLIError && error.metadata?.reason === "session_expired") {
+      return { unavailable: "session_expired" };
+    }
+    return { unavailable: "session_invalid" };
   }
-  function hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
-    const msg = concatBytes(...msgs);
-    return modN_LE(cHash(domain(msg, ensureBytes("context", context), !!prehash)));
+}
+async function storedSessionVerifiesLocally(profileName) {
+  const profile = await ProfileManager.getProfile(profileName).catch(() => null);
+  if (profile === null) return true;
+  const local = profile.authMethod === "local" && typeof profile.privateKey === "string";
+  try {
+    const session = await ProfileManager.getSession(profileName);
+    if (!session || typeof session.delegationCid !== "string" || typeof session.spaceId !== "string" || session.delegationHeader === null || typeof session.delegationHeader !== "object" || !("Authorization" in session.delegationHeader) || typeof session.delegationHeader.Authorization !== "string") return true;
+    const key = await ProfileManager.getKey(profileName);
+    const node = new TinyCloudNode({
+      host: profile.host ?? DEFAULT_HOST,
+      ...local ? { privateKey: profile.privateKey } : {}
+    });
+    await restoreProfileSession(node, profileName, profile, persistedSessionData(profileName, profile, session, key));
+    return true;
+  } catch {
+    return false;
   }
-  function sign(msg, secretKey, options = {}) {
-    msg = ensureBytes("message", msg);
-    if (prehash)
-      msg = prehash(msg);
-    const { prefix, scalar, pointBytes } = getExtendedPublicKey(secretKey);
-    const r = hashDomainToScalar(options.context, prefix, msg);
-    const R = BASE.multiply(r).toBytes();
-    const k = hashDomainToScalar(options.context, R, pointBytes, msg);
-    const s = Fn2.create(r + k * scalar);
-    if (!Fn2.isValid(s))
-      throw new Error("sign failed: invalid s");
-    const rs = concatBytes(R, Fn2.toBytes(s));
-    return _abytes2(rs, lengths.signature, "result");
+}
+async function createSDKInstance(ctx, options) {
+  const profile = options?.privateKey ? await ProfileManager.getProfile(ctx.profile).catch(() => null) : await ProfileManager.getProfile(ctx.profile);
+  const session = await ProfileManager.getSession(ctx.profile);
+  const key = await ProfileManager.getKey(ctx.profile);
+  const effectivePrivateKey = options?.privateKey ?? profile?.privateKey;
+  if (!key && !effectivePrivateKey && !(profile?.authMethod === "openkey" && session !== null)) {
+    throw new CLIError(
+      "AUTH_REQUIRED",
+      `No key found for profile "${ctx.profile}". Run \`tc --profile ${ctx.profile} auth rotate\` to create a new key and sign in.`,
+      ExitCode.AUTH_REQUIRED
+    );
   }
-  const verifyOpts = { zip215: true };
-  function verify(sig, msg, publicKey, options = verifyOpts) {
-    const { context, zip215 } = options;
-    const len = lengths.signature;
-    sig = ensureBytes("signature", sig, len);
-    msg = ensureBytes("message", msg);
-    publicKey = ensureBytes("publicKey", publicKey, lengths.publicKey);
-    if (zip215 !== void 0)
-      _abool2(zip215, "zip215");
-    if (prehash)
-      msg = prehash(msg);
-    const mid = len / 2;
-    const r = sig.subarray(0, mid);
-    const s = bytesToNumberLE(sig.subarray(mid, len));
-    let A, R, SB;
-    try {
-      A = Point.fromBytes(publicKey, zip215);
-      R = Point.fromBytes(r, zip215);
-      SB = BASE.multiplyUnsafe(s);
-    } catch (error) {
-      return false;
+  if (profile?.authMethod === "local" && effectivePrivateKey) {
+    const replication2 = createCliReplicationConfig(
+      ctx.profile,
+      profile?.replication,
+      { debug: ctx.replicationDebug, quiet: ctx.quiet },
+      ctx.replication
+    );
+    if (ctx.replication && !replication2) {
+      process.stderr.write("[replication] Enabled, but this profile has no configured prefixes; reads use the network.\n");
     }
-    if (!zip215 && A.isSmallOrder())
-      return false;
-    const k = hashDomainToScalar(context, R.toBytes(), A.toBytes(), msg);
-    const RkA = R.add(A.multiplyUnsafe(k));
-    return RkA.subtract(SB).clearCofactor().is0();
-  }
-  const _size = Fp2.BYTES;
-  const lengths = {
-    secretKey: _size,
-    publicKey: _size,
-    signature: 2 * _size,
-    seed: _size
-  };
-  function randomSecretKey(seed = randomBytes3(lengths.seed)) {
-    return _abytes2(seed, lengths.seed, "seed");
+    const node2 = new TinyCloudNode({
+      host: ctx.host,
+      privateKey: effectivePrivateKey,
+      ...replication2 ? { replication: replication2 } : {}
+    });
+    if (node2.replication) registerReplication(ctx.profile, node2.replication);
+    const restoredOwnSession = Boolean(session && session.delegationHeader && session.delegationCid && session.spaceId);
+    if (restoredOwnSession) {
+      await restoreProfileSession(node2, ctx.profile, profile, persistedSessionData(ctx.profile, profile, session, key));
+    } else {
+      await node2.signIn();
+    }
+    if (restoredOwnSession) {
+      recordWarnings(await replayAdditionalDelegations(node2, ctx.profile, {
+        host: ctx.host,
+        ownerSpace: profile.spaceId,
+        migrate: options?.privateKey === void 0
+      }));
+    }
+    return node2;
   }
-  function keygen(seed) {
-    const secretKey = utils.randomSecretKey(seed);
-    return { secretKey, publicKey: getPublicKey(secretKey) };
+  const replication = createCliReplicationConfig(
+    ctx.profile,
+    profile?.replication,
+    { debug: ctx.replicationDebug, quiet: ctx.quiet },
+    ctx.replication
+  );
+  if (ctx.replication && !replication) {
+    process.stderr.write("[replication] Enabled, but this profile has no configured prefixes; reads use the network.\n");
   }
-  function isValidSecretKey(key) {
-    return isBytes(key) && key.length === Fn2.BYTES;
+  const node = new TinyCloudNode({
+    host: ctx.host,
+    privateKey: options?.privateKey,
+    ...replication ? { replication } : {}
+  });
+  if (node.replication) registerReplication(ctx.profile, node.replication);
+  if (options?.privateKey) {
+    await node.signIn();
+  } else if (session && session.delegationHeader && session.delegationCid && session.spaceId) {
+    await restoreProfileSession(node, ctx.profile, profile, persistedSessionData(ctx.profile, profile, session, key));
+    recordWarnings(await replayAdditionalDelegations(node, ctx.profile, {
+      host: ctx.host,
+      ownerSpace: profile?.spaceId,
+      migrate: true
+    }));
   }
-  function isValidPublicKey(key, zip215) {
-    try {
-      return !!Point.fromBytes(key, zip215);
-    } catch (error) {
-      return false;
+  return node;
+}
+async function bootstrapDelegatedSession(ctx, delegation) {
+  const written = await ProfileManager.withLock(ctx.profile, async () => {
+    const previousProfile = await ProfileManager.getProfile(ctx.profile);
+    if (resolveProfilePosture(previousProfile) !== "delegate-session") {
+      throw new CLIError(
+        "AUTH_REQUIRED",
+        `Profile "${ctx.profile}" is not a delegate-session profile.`,
+        ExitCode.AUTH_REQUIRED
+      );
     }
-  }
-  const utils = {
-    getExtendedPublicKey,
-    randomSecretKey,
-    isValidSecretKey,
-    isValidPublicKey,
-    /**
-     * Converts ed public key to x public key. Uses formula:
-     * - ed25519:
-     *   - `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`
-     *   - `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`
-     * - ed448:
-     *   - `(u, v) = ((y-1)/(y+1), sqrt(156324)*u/x)`
-     *   - `(x, y) = (sqrt(156324)*u/v, (1+u)/(1-u))`
-     */
-    toMontgomery(publicKey) {
-      const { y } = Point.fromBytes(publicKey);
-      const size = lengths.publicKey;
-      const is25519 = size === 32;
-      if (!is25519 && size !== 57)
-        throw new Error("only defined for 25519 and 448");
-      const u = is25519 ? Fp2.div(_1n4 + y, _1n4 - y) : Fp2.div(y - _1n4, y + _1n4);
-      return Fp2.toBytes(u);
-    },
-    toMontgomerySecret(secretKey) {
-      const size = lengths.secretKey;
-      _abytes2(secretKey, size);
-      const hashed = cHash(secretKey.subarray(0, size));
-      return adjustScalarBytes2(hashed).subarray(0, size);
-    },
-    /** @deprecated */
-    randomPrivateKey: randomSecretKey,
-    /** @deprecated */
-    precompute(windowSize = 8, point = Point.BASE) {
-      return point.precompute(windowSize, false);
+    const sessionDid = previousProfile.sessionDid ?? previousProfile.did;
+    if (delegation.delegateDID.split("#", 1)[0] !== sessionDid.split("#", 1)[0]) {
+      throw new CLIError(
+        "DELEGATION_AUDIENCE_MISMATCH",
+        `Delegation targets ${delegation.delegateDID}, but profile "${ctx.profile}" uses ${sessionDid}.`,
+        ExitCode.PERMISSION_DENIED
+      );
+    }
+    if (await ProfileManager.getSession(ctx.profile) !== null) {
+      throw new CLIError(
+        "PROFILE_CHANGED_DURING_IMPORT",
+        `Profile "${ctx.profile}" gained a session (another login or import) after this import checked it. Nothing was saved; run the import again.`,
+        ExitCode.ERROR
+      );
+    }
+    if (signedLifetimePassed(delegation)) throw delegationExpiredError();
+    const jwk = signerJwkForProfile(ctx.profile, void 0, await ProfileManager.getKey(ctx.profile));
+    const session = {
+      delegationHeader: delegation.delegationHeader,
+      delegationCid: delegation.cid,
+      spaceId: delegation.spaceId,
+      jwk,
+      verificationMethod: sessionDid
+    };
+    const profile = { ...previousProfile, sessionDid, spaceId: delegation.spaceId };
+    try {
+      await ProfileManager.setSession(ctx.profile, session);
+      await ProfileManager.setProfile(ctx.profile, profile);
+    } catch (error) {
+      throw annotate(error, await restoreBeforeBootstrap(ctx.profile, previousProfile));
     }
-  };
-  return Object.freeze({
-    keygen,
-    getPublicKey,
-    sign,
-    verify,
-    utils,
-    Point,
-    lengths
+    return { previousProfile, profile, session };
   });
-}
-function _eddsa_legacy_opts_to_new(c) {
-  const CURVE = {
-    a: c.a,
-    d: c.d,
-    p: c.Fp.ORDER,
-    n: c.n,
-    h: c.h,
-    Gx: c.Gx,
-    Gy: c.Gy
-  };
-  const Fp2 = c.Fp;
-  const Fn2 = Field(CURVE.n, c.nBitLength, true);
-  const curveOpts = { Fp: Fp2, Fn: Fn2, uvRatio: c.uvRatio };
-  const eddsaOpts = {
-    randomBytes: c.randomBytes,
-    adjustScalarBytes: c.adjustScalarBytes,
-    domain: c.domain,
-    prehash: c.prehash,
-    mapToCurve: c.mapToCurve
+  const abandon = async (cause) => {
+    const reported = cause instanceof CLIError && cause.code === "AUTH_REQUIRED" && signedLifetimePassed(delegation) ? delegationExpiredError() : cause;
+    const note = await ProfileManager.withLock(ctx.profile, async () => {
+      const profile = await ProfileManager.getProfile(ctx.profile).catch((error) => {
+        if (error instanceof CLIError && error.code === "PROFILE_NOT_FOUND") return null;
+        throw error;
+      });
+      const session = await ProfileManager.getSession(ctx.profile);
+      if (profile === null || BOOTSTRAP_PROFILE_FIELDS.some((field) => profile[field] !== written.profile[field]) || JSON.stringify(session) !== JSON.stringify(written.session)) {
+        return `Profile "${ctx.profile}" changed while the import was pending (another login, logout or profile update), so its newer state was kept and the provisional session was not rolled back.`;
+      }
+      return restoreBeforeBootstrap(ctx.profile, written.previousProfile);
+    }, { timeoutMs: PROFILE_COMMIT_LOCK_TIMEOUT_MS }).catch((error) => (
+      // The lock or a read failed: the import's error stays the one reported.
+      `Rolling back the provisional session of profile "${ctx.profile}" could not run (${failureName(error)}); check \`tc --profile ${ctx.profile} context\`.`
+    ));
+    throw annotate(reported, note);
   };
-  return { CURVE, curveOpts, hash: c.hash, eddsaOpts };
+  let node;
+  try {
+    node = await createSDKInstance(ctx);
+  } catch (error) {
+    return abandon(error);
+  }
+  return { node, abandon };
 }
-function _eddsa_new_output_to_legacy(c, eddsa2) {
-  const Point = eddsa2.Point;
-  const legacy = Object.assign({}, eddsa2, {
-    ExtendedPoint: Point,
-    CURVE: c,
-    nBitLength: Point.Fn.BITS,
-    nByteLength: Point.Fn.BYTES
-  });
-  return legacy;
+async function restoreBeforeBootstrap(profileName, previousProfile) {
+  const failures = [];
+  for (const write of [
+    () => ProfileManager.clearSession(profileName),
+    () => ProfileManager.updateProfile(profileName, (current) => {
+      const restored = { ...current };
+      for (const field of BOOTSTRAP_PROFILE_FIELDS) {
+        if (previousProfile[field] === void 0) delete restored[field];
+        else restored[field] = previousProfile[field];
+      }
+      return restored;
+    })
+  ]) {
+    await write().catch((error) => {
+      failures.push(failureName(error));
+    });
+  }
+  if (failures.length === 0) return void 0;
+  return `Rolling back the provisional session of profile "${profileName}" failed too (${failures.join("; ")}); check \`tc --profile ${profileName} context\`.`;
 }
-function twistedEdwards(c) {
-  const { CURVE, curveOpts, hash, eddsaOpts } = _eddsa_legacy_opts_to_new(c);
-  const Point = edwards(CURVE, curveOpts);
-  const EDDSA = eddsa(Point, hash, eddsaOpts);
-  return _eddsa_new_output_to_legacy(c, EDDSA);
+function failureName(error) {
+  if (error instanceof SyntaxError) return "a profile file is not valid JSON";
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") return error.code;
+  return error instanceof Error ? error.name : "unknown error";
 }
-
-// ../../node_modules/@noble/curves/esm/ed25519.js
-var _0n5 = /* @__PURE__ */ BigInt(0);
-var _1n5 = BigInt(1);
-var _2n3 = BigInt(2);
-var _3n2 = BigInt(3);
-var _5n2 = BigInt(5);
-var _8n3 = BigInt(8);
-var ed25519_CURVE_p = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
-var ed25519_CURVE = /* @__PURE__ */ (() => ({
-  p: ed25519_CURVE_p,
-  n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),
-  h: _8n3,
-  a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),
-  d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),
-  Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),
-  Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")
-}))();
-function ed25519_pow_2_252_3(x) {
-  const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
-  const P = ed25519_CURVE_p;
-  const x2 = x * x % P;
-  const b2 = x2 * x % P;
-  const b4 = pow2(b2, _2n3, P) * b2 % P;
-  const b5 = pow2(b4, _1n5, P) * x % P;
-  const b10 = pow2(b5, _5n2, P) * b5 % P;
-  const b20 = pow2(b10, _10n, P) * b10 % P;
-  const b40 = pow2(b20, _20n, P) * b20 % P;
-  const b80 = pow2(b40, _40n, P) * b40 % P;
-  const b160 = pow2(b80, _80n, P) * b80 % P;
-  const b240 = pow2(b160, _80n, P) * b80 % P;
-  const b250 = pow2(b240, _10n, P) * b10 % P;
-  const pow_p_5_8 = pow2(b250, _2n3, P) * x % P;
-  return { pow_p_5_8, b2 };
+function annotate(error, note) {
+  if (note === void 0) return error;
+  const cause = wrapError(error);
+  return new CLIError(cause.code, `${cause.message} ${note}`, cause.exitCode, cause.metadata);
 }
-function adjustScalarBytes(bytes) {
-  bytes[0] &= 248;
-  bytes[31] &= 127;
-  bytes[31] |= 64;
-  return bytes;
+async function ensureAuthenticated(ctx, options) {
+  if (options?.privateKey) {
+    return createSDKInstance(ctx, options);
+  }
+  const profile = await ProfileManager.getProfile(ctx.profile).catch(() => null);
+  if (profile?.authMethod === "local" && profile.privateKey) {
+    return createSDKInstance(ctx);
+  }
+  const session = await ProfileManager.getSession(ctx.profile);
+  if (!session) {
+    throw new CLIError(
+      "AUTH_REQUIRED",
+      `Not authenticated. Run \`tc auth login\` or \`tc init\` first.`,
+      ExitCode.AUTH_REQUIRED
+    );
+  }
+  return createSDKInstance(ctx, options);
 }
-var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
-function uvRatio(u, v) {
-  const P = ed25519_CURVE_p;
-  const v3 = mod(v * v * v, P);
-  const v7 = mod(v3 * v3 * v, P);
-  const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
-  let x = mod(u * v3 * pow, P);
-  const vx2 = mod(v * x * x, P);
-  const root1 = x;
-  const root2 = mod(x * ED25519_SQRT_M1, P);
-  const useRoot1 = vx2 === u;
-  const useRoot2 = vx2 === mod(-u, P);
-  const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P);
-  if (useRoot1)
-    x = root1;
-  if (useRoot2 || noRoot)
-    x = root2;
-  if (isNegativeLE(x, P))
-    x = mod(-x, P);
-  return { isValid: useRoot1 || useRoot2, value: x };
+var BOOTSTRAP_PROFILE_FIELDS;
+var init_sdk = __esm({
+  "src/lib/sdk.ts"() {
+    "use strict";
+    init_profiles();
+    init_types();
+    init_errors();
+    init_constants();
+    init_permissions();
+    init_session_expired();
+    init_warnings();
+    init_delegation_expiry();
+    init_replication_config();
+    init_replication_registry();
+    init_replication_registry();
+    BOOTSTRAP_PROFILE_FIELDS = ["sessionDid", "spaceId"];
+  }
+});
+
+// src/lib/host.ts
+var host_exports = {};
+__export(host_exports, {
+  completeDeferredLocalDiscovery: () => completeDeferredLocalDiscovery,
+  discoverLocalNodeHost: () => discoverLocalNodeHost,
+  isRootAuthority: () => isRootAuthority,
+  ownerDidFromSpaceUri: () => ownerDidFromSpaceUri,
+  profileLocalNodeIdentityStore: () => profileLocalNodeIdentityStore,
+  resolveHostSpace: () => resolveHostSpace,
+  spaceNameFromUri: () => spaceNameFromUri,
+  unhostedSpaceError: () => unhostedSpaceError
+});
+import {
+  discoverLocalTinyCloudNode
+} from "@tinycloud/sdk-core";
+function profileLocalNodeIdentityStore(profileName) {
+  return {
+    get: async (url) => {
+      const profile = await ProfileManager.getProfile(profileName).catch(
+        () => null
+      );
+      return profile?.pinnedLocalNodeDids?.[url];
+    },
+    set: async (url, nodeDid) => {
+      if (!await ProfileManager.profileExists(profileName)) return;
+      await ProfileManager.updateProfile(profileName, (profile) => ({
+        ...profile,
+        pinnedLocalNodeDids: {
+          ...profile.pinnedLocalNodeDids,
+          [url]: nodeDid
+        }
+      }));
+    }
+  };
 }
-var Fp = /* @__PURE__ */ (() => Field(ed25519_CURVE.p, { isLE: true }))();
-var Fn = /* @__PURE__ */ (() => Field(ed25519_CURVE.n, { isLE: true }))();
-var ed25519Defaults = /* @__PURE__ */ (() => ({
-  ...ed25519_CURVE,
-  Fp,
-  hash: sha512,
-  adjustScalarBytes,
-  // dom2
-  // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
-  // Constant-time, u/√v
-  uvRatio
-}))();
-var ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();
-var SQRT_M1 = ED25519_SQRT_M1;
-var SQRT_AD_MINUS_ONE = /* @__PURE__ */ BigInt("25063068953384623474111414158702152701244531502492656460079210482610430750235");
-var INVSQRT_A_MINUS_D = /* @__PURE__ */ BigInt("54469307008909316920995813868745141605393597292927456921205312896311721017578");
-var ONE_MINUS_D_SQ = /* @__PURE__ */ BigInt("1159843021668779879193775521855586647937357759715417654439879720876111806838");
-var D_MINUS_ONE_SQ = /* @__PURE__ */ BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952");
-var invertSqrt = (number) => uvRatio(_1n5, number);
-var MAX_255B = /* @__PURE__ */ BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-var bytes255ToNumberLE = (bytes) => ed25519.Point.Fp.create(bytesToNumberLE(bytes) & MAX_255B);
-function calcElligatorRistrettoMap(r0) {
-  const { d } = ed25519_CURVE;
-  const P = ed25519_CURVE_p;
-  const mod2 = (n) => Fp.create(n);
-  const r = mod2(SQRT_M1 * r0 * r0);
-  const Ns = mod2((r + _1n5) * ONE_MINUS_D_SQ);
-  let c = BigInt(-1);
-  const D = mod2((c - d * r) * mod2(r + d));
-  let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D);
-  let s_ = mod2(s * r0);
-  if (!isNegativeLE(s_, P))
-    s_ = mod2(-s_);
-  if (!Ns_D_is_sq)
-    s = s_;
-  if (!Ns_D_is_sq)
-    c = r;
-  const Nt = mod2(c * (r - _1n5) * D_MINUS_ONE_SQ - D);
-  const s2 = s * s;
-  const W0 = mod2((s + s) * D);
-  const W1 = mod2(Nt * SQRT_AD_MINUS_ONE);
-  const W2 = mod2(_1n5 - s2);
-  const W3 = mod2(_1n5 + s2);
-  return new ed25519.Point(mod2(W0 * W3), mod2(W2 * W1), mod2(W1 * W3), mod2(W0 * W2));
+async function discoverLocalNodeHost(profileName, options) {
+  const profile = await ProfileManager.getProfile(profileName).catch(() => null);
+  if (profile?.autoDiscoverLocalNode === false) return { host: null, deferred: false };
+  if (!profile?.localNodeUrl && !profile?.localLinkName) return { host: null, deferred: false };
+  if (options.awaitStoredSession) {
+    const { storedSessionVerifiesLocally: storedSessionVerifiesLocally2 } = await Promise.resolve().then(() => (init_sdk(), sdk_exports));
+    if (!await storedSessionVerifiesLocally2(profileName)) return { host: null, deferred: true };
+  }
+  const discovered = await discoverLocalTinyCloudNode({
+    localNodeUrl: profile?.localNodeUrl,
+    localLinkName: profile?.localLinkName,
+    expectedNodeDid: profile?.expectedNodeDid,
+    identityStore: profileLocalNodeIdentityStore(profileName)
+  });
+  return { host: discovered?.url ?? null, deferred: false };
 }
-function ristretto255_map(bytes) {
-  abytes(bytes, 64);
-  const r1 = bytes255ToNumberLE(bytes.subarray(0, 32));
-  const R1 = calcElligatorRistrettoMap(r1);
-  const r2 = bytes255ToNumberLE(bytes.subarray(32, 64));
-  const R2 = calcElligatorRistrettoMap(r2);
-  return new _RistrettoPoint(R1.add(R2));
+async function completeDeferredLocalDiscovery(ctx) {
+  const deferred = ctx.localDiscovery;
+  if (deferred === void 0) return;
+  delete ctx.localDiscovery;
+  if (ctx.host !== deferred.deferredFrom) return;
+  const discovered = await discoverLocalNodeHost(ctx.profile, { awaitStoredSession: false });
+  if (discovered.host !== null) ctx.host = discovered.host;
 }
-var _RistrettoPoint = class __RistrettoPoint extends PrimeEdwardsPoint {
-  constructor(ep) {
-    super(ep);
-  }
-  static fromAffine(ap) {
-    return new __RistrettoPoint(ed25519.Point.fromAffine(ap));
-  }
-  assertSame(other) {
-    if (!(other instanceof __RistrettoPoint))
-      throw new Error("RistrettoPoint expected");
-  }
-  init(ep) {
-    return new __RistrettoPoint(ep);
-  }
-  /** @deprecated use `import { ristretto255_hasher } from '@noble/curves/ed25519.js';` */
-  static hashToCurve(hex3) {
-    return ristretto255_map(ensureBytes("ristrettoHash", hex3, 64));
-  }
-  static fromBytes(bytes) {
-    abytes(bytes, 32);
-    const { a, d } = ed25519_CURVE;
-    const P = ed25519_CURVE_p;
-    const mod2 = (n) => Fp.create(n);
-    const s = bytes255ToNumberLE(bytes);
-    if (!equalBytes(Fp.toBytes(s), bytes) || isNegativeLE(s, P))
-      throw new Error("invalid ristretto255 encoding 1");
-    const s2 = mod2(s * s);
-    const u1 = mod2(_1n5 + a * s2);
-    const u2 = mod2(_1n5 - a * s2);
-    const u1_2 = mod2(u1 * u1);
-    const u2_2 = mod2(u2 * u2);
-    const v = mod2(a * d * u1_2 - u2_2);
-    const { isValid: isValid3, value: I } = invertSqrt(mod2(v * u2_2));
-    const Dx = mod2(I * u2);
-    const Dy = mod2(I * Dx * v);
-    let x = mod2((s + s) * Dx);
-    if (isNegativeLE(x, P))
-      x = mod2(-x);
-    const y = mod2(u1 * Dy);
-    const t = mod2(x * y);
-    if (!isValid3 || isNegativeLE(t, P) || y === _0n5)
-      throw new Error("invalid ristretto255 encoding 2");
-    return new __RistrettoPoint(new ed25519.Point(x, y, _1n5, t));
-  }
-  /**
-   * Converts ristretto-encoded string to ristretto point.
-   * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-decode).
-   * @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding
-   */
-  static fromHex(hex3) {
-    return __RistrettoPoint.fromBytes(ensureBytes("ristrettoHex", hex3, 32));
+function canonicalizeAddress2(address) {
+  const trimmed = address.trim();
+  return trimmed.startsWith("0x") ? `0x${trimmed.slice(2).toLowerCase()}` : trimmed.toLowerCase();
+}
+async function resolveLocalAddress(profile, profileName) {
+  const session = await ProfileManager.getSession(profileName);
+  const sessAddr = session?.address;
+  if (typeof sessAddr === "string" && sessAddr.length > 0) {
+    return canonicalizeAddress2(sessAddr);
   }
-  static msm(points, scalars) {
-    return pippenger(__RistrettoPoint, ed25519.Point.Fn, points, scalars);
+  if (profile.address) return canonicalizeAddress2(profile.address);
+  if (profile.ownerDid) {
+    const match = profile.ownerDid.match(/^did:pkh:eip155:\d+:(0x[a-fA-F0-9]{40})$/);
+    if (match) return canonicalizeAddress2(match[1]);
   }
-  /**
-   * Encodes ristretto point to Uint8Array.
-   * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-encode).
-   */
-  toBytes() {
-    let { X, Y, Z, T } = this.ep;
-    const P = ed25519_CURVE_p;
-    const mod2 = (n) => Fp.create(n);
-    const u1 = mod2(mod2(Z + Y) * mod2(Z - Y));
-    const u2 = mod2(X * Y);
-    const u2sq = mod2(u2 * u2);
-    const { value: invsqrt } = invertSqrt(mod2(u1 * u2sq));
-    const D1 = mod2(invsqrt * u1);
-    const D2 = mod2(invsqrt * u2);
-    const zInv = mod2(D1 * D2 * T);
-    let D;
-    if (isNegativeLE(T * zInv, P)) {
-      let _x = mod2(Y * SQRT_M1);
-      let _y = mod2(X * SQRT_M1);
-      X = _x;
-      Y = _y;
-      D = mod2(D1 * INVSQRT_A_MINUS_D);
-    } else {
-      D = D2;
-    }
-    if (isNegativeLE(X * zInv, P))
-      Y = mod2(-Y);
-    let s = mod2((Z - Y) * D);
-    if (isNegativeLE(s, P))
-      s = mod2(-s);
-    return Fp.toBytes(s);
+  return null;
+}
+function ownerAddressFromSpaceUri(spaceUri) {
+  const match = spaceUri.match(/^tinycloud:pkh:eip155:\d+:(0x[a-fA-F0-9]{40}):/);
+  return match ? canonicalizeAddress2(match[1]) : null;
+}
+function ownerDidFromSpaceUri(spaceUri) {
+  const match = spaceUri.match(/^tinycloud:pkh:eip155:(\d+):(0x[a-fA-F0-9]{40}):/);
+  if (!match) return null;
+  return `did:pkh:eip155:${match[1]}:${canonicalizeAddress2(match[2])}`;
+}
+async function isRootAuthority(spaceUri, profileName) {
+  const profile = await ProfileManager.getProfile(profileName);
+  if (resolveProfilePosture(profile) === "delegate-session") return false;
+  const ownerAddr = ownerAddressFromSpaceUri(spaceUri);
+  if (!ownerAddr) return false;
+  const selfAddr = await resolveLocalAddress(profile, profileName);
+  return selfAddr !== null && selfAddr === ownerAddr;
+}
+function spaceNameFromUri(spaceUri) {
+  return spaceUri.slice(spaceUri.lastIndexOf(":") + 1);
+}
+async function unhostedSpaceError(error, spaceUri, profileName) {
+  if (!spaceUri) return null;
+  const status = error.meta?.status;
+  const isUnhosted = status === 404 && /space not found/i.test(error.message);
+  if (!isUnhosted) return null;
+  const spaceName = spaceNameFromUri(spaceUri);
+  const owner = await isRootAuthority(spaceUri, profileName);
+  const hint = owner ? [
+    "You are the owner. Host it once:",
+    `  tc space host ${spaceName}`,
+    "Then retry."
+  ].join("\n") : [
+    "You are a delegate and CANNOT host this space \u2014 only its owner can.",
+    "Emit a host request:",
+    `  tc space host-request ${spaceName} --emit ./host-request.json`,
+    "Send it to the owner; they run `tc space host` and confirm. Then retry."
+  ].join("\n");
+  const message = owner ? `Space '${spaceName}' (${spaceUri}) is not hosted.` : `Space '${spaceName}' (owner ${ownerDidFromSpaceUri(spaceUri) ?? spaceUri}) is not hosted.`;
+  return new CLIError("SPACE_NOT_HOSTED", message, ExitCode.ERROR, { hint });
+}
+async function resolveHostSpace(name, profileName) {
+  const resolved = await resolveSpaceUri(name, profileName);
+  if (!resolved) {
+    throw new Error(`Could not resolve a space for "${name}".`);
   }
-  /**
-   * Compares two Ristretto points.
-   * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-equals).
-   */
-  equals(other) {
-    this.assertSame(other);
-    const { X: X1, Y: Y1 } = this.ep;
-    const { X: X2, Y: Y2 } = other.ep;
-    const mod2 = (n) => Fp.create(n);
-    const one = mod2(X1 * Y2) === mod2(Y1 * X2);
-    const two = mod2(Y1 * Y2) === mod2(X1 * X2);
-    return one || two;
+  return resolved;
+}
+var init_host = __esm({
+  "src/lib/host.ts"() {
+    "use strict";
+    init_profiles();
+    init_constants();
+    init_types();
+    init_errors();
+    init_space();
   }
-  is0() {
-    return this.equals(__RistrettoPoint.ZERO);
+});
+
+// src/config/profiles.ts
+import { chmod as chmod2, lstat, readdir as readdir2, rm as rm2, rmdir } from "fs/promises";
+import { join as join6 } from "path";
+import {
+  profilePath as profilePath2,
+  readSession,
+  recordProfileDeletion,
+  refuseWriteToDeletedProfile as refuseWriteToDeletedProfile2,
+  removeSession,
+  withProfileLock as withProfileLock3,
+  writeSession
+} from "@tinycloud/operations/state";
+var ProfileManager;
+var init_profiles = __esm({
+  "src/config/profiles.ts"() {
+    "use strict";
+    init_constants();
+    init_storage2();
+    init_errors();
+    ProfileManager = class _ProfileManager {
+      // ── Initialization ──────────────────────────────────────────────────
+      /**
+       * Runs `action` holding the profile's store lock (shared with operations
+       * and MCP). Reentrant, so the writers below can be called inside it; hold
+       * it around a whole read-modify-write, not just each write.
+       */
+      static async withLock(name, action, options) {
+        return withProfileLock3(name, action, options);
+      }
+      /**
+       * Read-modify-write of profile.json under the profile lock, so concurrent
+       * updates (another command, a login commit) are never erased.
+       */
+      static async updateProfile(name, update) {
+        return _ProfileManager.withLock(name, async () => {
+          const next = update(await _ProfileManager.getProfile(name));
+          await _ProfileManager.setProfile(name, next);
+          return next;
+        });
+      }
+      /**
+       * Creates ~/.tinycloud/ and ~/.tinycloud/profiles/ if they don't exist and
+       * (re)sets both to 0700: older releases created them 0775.
+       */
+      static async ensureConfigDir() {
+        for (const directory of [CONFIG_DIR, PROFILES_DIR]) {
+          await ensureDir(directory);
+          await chmod2(directory, PRIVATE_DIR_MODE);
+        }
+      }
+      /** Owner-only profile directory (0700), created or tightened before any write into it. */
+      static async ensureProfileDir(name) {
+        await _ProfileManager.ensureConfigDir();
+        const profileDir = join6(PROFILES_DIR, name);
+        await ensureDir(profileDir);
+        await chmod2(profileDir, PRIVATE_DIR_MODE);
+        return profileDir;
+      }
+      // ── Global config ───────────────────────────────────────────────────
+      /**
+       * Reads config.json. Returns a default config if the file is missing.
+       */
+      static async getConfig() {
+        const config = await readJson(CONFIG_FILE);
+        if (!config) {
+          return { defaultProfile: DEFAULT_PROFILE, version: 1 };
+        }
+        return config;
+      }
+      /**
+       * Writes the global config to config.json.
+       */
+      static async setConfig(config) {
+        await _ProfileManager.ensureConfigDir();
+        await writeJson(CONFIG_FILE, config);
+      }
+      // ── Profile CRUD ────────────────────────────────────────────────────
+      /**
+       * Returns the profile config for the given name.
+       * Throws CLIError if the profile doesn't exist.
+       */
+      static async getProfile(name) {
+        const profilePath3 = join6(PROFILES_DIR, name, "profile.json");
+        const profile = await readJson(profilePath3);
+        if (!profile) {
+          throw new CLIError(
+            "PROFILE_NOT_FOUND",
+            `Profile "${name}" does not exist. Create it with \`tc init --name ${name}\`.`
+          );
+        }
+        return profile;
+      }
+      /**
+       * Saves a profile config under the profile lock, creating the profile
+       * directory if needed. Use `updateProfile` to change an existing profile.
+       */
+      static async setProfile(name, data) {
+        await _ProfileManager.withLock(name, async () => {
+          await writeJson(join6(await _ProfileManager.ensureProfileDir(name), "profile.json"), data);
+        });
+      }
+      /** Removes profile.json under the profile lock (rollback of a profile a failed login created). */
+      static async removeProfileConfig(name) {
+        await _ProfileManager.withLock(name, () => rm2(join6(PROFILES_DIR, name, "profile.json"), { force: true }));
+      }
+      /**
+       * Returns true if a profile directory exists.
+       */
+      static async profileExists(name) {
+        return fileExists(join6(PROFILES_DIR, name, "profile.json"));
+      }
+      /**
+       * Returns an array of profile directory names.
+       */
+      static async listProfiles() {
+        return listDirs(PROFILES_DIR);
+      }
+      /**
+       * Deletes a profile. Its key, session, settings, stores and cache are
+       * removed while holding the profile lock, so another writer's critical
+       * section never sees them vanish midway: session and key first, settings
+       * last, so a crash midway never leaves a session or key without its
+       * profile. The deletion is then recorded, so a store write that waited for
+       * the lock meanwhile refuses rather than recreating a profile with only a
+       * session in it. `.lock` itself is left to the lock's release; the
+       * then-empty directory is removed afterwards unless another writer took
+       * the lock (or wrote) meanwhile. A profile directory that is a symlink is
+       * unlinked, its target left alone.
+       * Throws if the name is not one path segment or names the default profile.
+       */
+      static async deleteProfile(name) {
+        let profileDir;
+        try {
+          profileDir = profilePath2(name);
+        } catch {
+          throw new CLIError(
+            "INVALID_PROFILE_NAME",
+            `Invalid profile name "${name}": a profile name is one path segment (no "/", "\\", "." or "..").`,
+            ExitCode.USAGE_ERROR
+          );
+        }
+        const config = await _ProfileManager.getConfig();
+        if (config.defaultProfile === name) {
+          throw new CLIError(
+            "PROFILE_DELETE_DEFAULT",
+            `Cannot delete the default profile "${name}". Change the default first with \`tc profile default <other>\`.`
+          );
+        }
+        const kind = await lstat(profileDir).then((stats) => stats.isSymbolicLink() ? "link" : "present", (error) => {
+          if (error.code === "ENOENT") return "missing";
+          throw error;
+        });
+        if (kind === "missing") return;
+        if (kind === "link") {
+          await rm2(profileDir, { force: true });
+          return;
+        }
+        await _ProfileManager.withLock(name, async () => {
+          for (const file of ["session.json", "key.json"]) await rm2(join6(profileDir, file), { force: true });
+          for (const entry of await readdir2(profileDir)) {
+            if (entry !== ".lock" && entry !== "profile.json") await rm2(join6(profileDir, entry), { recursive: true, force: true });
+          }
+          await rm2(join6(profileDir, "profile.json"), { force: true });
+          await recordProfileDeletion(name);
+        });
+        await rmdir(profileDir).catch((error) => {
+          if (error.code !== "ENOENT" && error.code !== "ENOTEMPTY" && error.code !== "EEXIST") throw error;
+        });
+      }
+      // ── Key management ──────────────────────────────────────────────────
+      /**
+       * Returns the parsed JWK for a profile, or null if no key exists.
+       */
+      static async getKey(name) {
+        return readJson(join6(PROFILES_DIR, name, "key.json"));
+      }
+      /**
+       * Saves a JWK key under the profile lock (0600, in an owner-only profile
+       * directory). Refused (PROFILE_NOT_FOUND) if the profile was deleted while
+       * this waited for the lock, rather than leaving a key-only profile.
+       */
+      static async setKey(name, jwk) {
+        await _ProfileManager.withLock(name, async () => {
+          await refuseWriteToDeletedProfile2(name);
+          await writeJson(join6(await _ProfileManager.ensureProfileDir(name), "key.json"), jwk);
+        });
+      }
+      /** Removes key.json under the profile lock (rollback of a key a failed login created). */
+      static async removeKey(name) {
+        await _ProfileManager.withLock(name, () => rm2(join6(PROFILES_DIR, name, "key.json"), { force: true }));
+      }
+      // ── Session management ──────────────────────────────────────────────
+      /**
+       * Returns the parsed session for a profile, or null if none exists.
+       */
+      static async getSession(name) {
+        return readSession(name);
+      }
+      /**
+       * Saves session data for a profile.
+       */
+      static async setSession(name, session) {
+        await writeSession(name, session);
+      }
+      /**
+       * Removes the session file for a profile.
+       */
+      static async clearSession(name) {
+        await removeSession(name);
+      }
+      // ── Cache management ────────────────────────────────────────────────
+      /**
+       * Returns the profile's cache directory (share history lives here),
+       * created or tightened to 0700.
+       */
+      static async getCacheDir(name) {
+        const cacheDir = join6(await _ProfileManager.ensureProfileDir(name), "cache");
+        await ensureDir(cacheDir);
+        await chmod2(cacheDir, PRIVATE_DIR_MODE);
+        return cacheDir;
+      }
+      // ── Resolution helpers ──────────────────────────────────────────────
+      /**
+       * Resolves the full CLI context from flags, env vars, and config.
+       *
+       * Profile resolution: options.profile > TC_PROFILE env > config.defaultProfile > "default"
+       * Host resolution:    options.host    > TC_HOST env    > discovered local node > profile.host > DEFAULT_HOST
+       *
+       * Local-node discovery (TC-106) only runs when no explicit host was given
+       * (`--host` / `TC_HOST`); it probes configured or registered local nodes and,
+       * after DID verification against the profile's pinned identity, prefers one
+       * over the stored/default host. For session-using commands, it verifies the
+       * stored session locally before probing. Loopback requires an explicit
+       * `localNodeUrl`; disable discovery with `autoDiscoverLocalNode: false`.
+       */
+      static async resolveContext(options, settings = {}) {
+        const config = await _ProfileManager.getConfig();
+        const profile = options.profile ?? process.env.TC_PROFILE ?? config.defaultProfile ?? DEFAULT_PROFILE;
+        let profileHost;
+        let profileConfig;
+        try {
+          profileConfig = await _ProfileManager.getProfile(profile);
+          profileHost = profileConfig.host;
+        } catch {
+        }
+        const envReplication = process.env.TC_REPLICATION?.toLowerCase();
+        const envEnabled = envReplication === "1" || envReplication === "true" || envReplication === "on";
+        const explicitEnvOff = envReplication === "0" || envReplication === "false" || envReplication === "off";
+        if (envReplication !== void 0 && !envEnabled && !explicitEnvOff) {
+          throw new CLIError("INVALID_ARGUMENT", "TC_REPLICATION must be one of 1, true, on, 0, false or off.", ExitCode.USAGE_ERROR);
+        }
+        const explicitOff = options.noReplication === true || options.replication === false;
+        const replication = options.replication === true ? true : explicitOff ? false : envEnabled;
+        const explicitHost = options.host ?? process.env.TC_HOST;
+        let host = explicitHost ?? profileHost ?? DEFAULT_HOST;
+        let localDiscovery;
+        if (explicitHost === void 0) {
+          const { discoverLocalNodeHost: discoverLocalNodeHost2 } = await Promise.resolve().then(() => (init_host(), host_exports));
+          const explicitKey = Boolean(options.privateKey || process.env.TC_PRIVATE_KEY);
+          const discovered = await discoverLocalNodeHost2(profile, {
+            awaitStoredSession: settings.storedSession !== "unused" && !explicitKey
+          });
+          if (discovered.host !== null) host = discovered.host;
+          if (discovered.deferred) localDiscovery = { deferredFrom: host };
+        }
+        setActiveProfileName(profile);
+        return {
+          profile,
+          host,
+          verbose: options.verbose ?? false,
+          noCache: options.noCache ?? false,
+          quiet: options.quiet ?? false,
+          replication,
+          replicationDebug: options.replicationDebug === true || process.env.TC_REPLICATION_DEBUG === "1",
+          ...localDiscovery === void 0 ? {} : { localDiscovery }
+        };
+      }
+    };
   }
-};
-_RistrettoPoint.BASE = /* @__PURE__ */ (() => new _RistrettoPoint(ed25519.Point.BASE))();
-_RistrettoPoint.ZERO = /* @__PURE__ */ (() => new _RistrettoPoint(ed25519.Point.ZERO))();
-_RistrettoPoint.Fp = /* @__PURE__ */ (() => Fp)();
-_RistrettoPoint.Fn = /* @__PURE__ */ (() => Fn)();
+});
 
-// ../../node_modules/@noble/hashes/esm/blake3.js
-init_md();
-init_u64();
+// src/commands/courier.ts
+var TC_OPTIONS_BEFORE_COURIER = 'tc courier takes no tc options and does not use tc profiles; Courier keeps its own profile in $COURIER_HOME (default ~/.courier). Put flags after "courier", e.g. tc courier init --host <url>.';
 
-// ../../node_modules/@noble/hashes/esm/_blake.js
-init_utils();
-function G1s(a, b, c, d, x) {
-  a = a + b + x | 0;
-  d = rotr(d ^ a, 16);
-  c = c + d | 0;
-  b = rotr(b ^ c, 12);
-  return { a, b, c, d };
-}
-function G2s(a, b, c, d, x) {
-  a = a + b + x | 0;
-  d = rotr(d ^ a, 8);
-  c = c + d | 0;
-  b = rotr(b ^ c, 7);
-  return { a, b, c, d };
-}
+// src/index.ts
+init_errors();
+import { readFileSync as readFileSync2 } from "fs";
+import { Command } from "commander";
 
-// ../../node_modules/@noble/hashes/esm/blake2.js
-init_utils();
-var BLAKE2 = class extends Hash {
-  constructor(blockLen, outputLen) {
-    super();
-    this.finished = false;
-    this.destroyed = false;
-    this.length = 0;
-    this.pos = 0;
-    anumber(blockLen);
-    anumber(outputLen);
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.buffer = new Uint8Array(blockLen);
-    this.buffer32 = u32(this.buffer);
-  }
-  update(data) {
-    aexists(this);
-    data = toBytes(data);
-    abytes(data);
-    const { blockLen, buffer, buffer32 } = this;
-    const len = data.length;
-    const offset = data.byteOffset;
-    const buf = data.buffer;
-    for (let pos = 0; pos < len; ) {
-      if (this.pos === blockLen) {
-        swap32IfBE(buffer32);
-        this.compress(buffer32, 0, false);
-        swap32IfBE(buffer32);
-        this.pos = 0;
-      }
-      const take = Math.min(blockLen - this.pos, len - pos);
-      const dataOffset = offset + pos;
-      if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
-        const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
-        swap32IfBE(data32);
-        for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
-          this.length += blockLen;
-          this.compress(data32, pos32, false);
-        }
-        swap32IfBE(data32);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      this.length += take;
-      pos += take;
+// src/output/banner.ts
+init_formatter();
+
+// src/output/taglines.ts
+var HOLIDAY_TAGLINES = [
+  { month: 1, day: 1, range: 1, tagline: "New year, new keys, same cloud." },
+  { month: 2, day: 14, tagline: "We love your data as much as you do." },
+  { month: 3, day: 14, tagline: "3.14159 reasons to encrypt everything." },
+  { month: 5, day: 4, tagline: "May the fourth be with your keys." },
+  { month: 10, day: 31, tagline: "Nothing scarier than plaintext secrets." },
+  { month: 12, day: 25, range: 2, tagline: "Unwrap your data, not your keys." },
+  { month: 12, day: 31, tagline: "Encrypt your resolutions." }
+];
+var TAGLINES = [
+  // Professional
+  "Your data, your keys, your cloud.",
+  "Self-sovereign storage for the modern web.",
+  "The cloud you actually own.",
+  "Encrypted by default, decentralized by design.",
+  "Where your data answers only to you.",
+  "End-to-end encrypted. No exceptions.",
+  "Like S3 but you hold the keys.",
+  "Privacy isn't a feature. It's the architecture.",
+  "Sovereign storage, zero knowledge.",
+  "Your .env is safe here \u2014 we use real cryptography.",
+  // Playful / nerdy
+  "UCAN do anything.",
+  "Keys generated, delegations granted, data liberated.",
+  "Decentralized storage, centralized vibes.",
+  "Trust nobody, delegate everything.",
+  "sudo make me a sandwich, encrypted.",
+  "Have you tried turning your keys off and on again?",
+  "All your base are belong to you.",
+  "In UCAN we trust.",
+  "0 knowledge, 100% confidence.",
+  "Keeping secrets since 2024."
+];
+function getHolidayTagline() {
+  const now = /* @__PURE__ */ new Date();
+  const month = now.getMonth() + 1;
+  const day = now.getDate();
+  for (const h of HOLIDAY_TAGLINES) {
+    const range = h.range ?? 0;
+    if (h.month === month && Math.abs(day - h.day) <= range) {
+      return h.tagline;
     }
-    return this;
-  }
-  digestInto(out) {
-    aexists(this);
-    aoutput(out, this);
-    const { pos, buffer32 } = this;
-    this.finished = true;
-    clean(this.buffer.subarray(pos));
-    swap32IfBE(buffer32);
-    this.compress(buffer32, 0, true);
-    swap32IfBE(buffer32);
-    const out32 = u32(out);
-    this.get().forEach((v, i) => out32[i] = swap8IfBE(v));
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to) {
-    const { buffer, length: length4, finished, destroyed, outputLen, pos } = this;
-    to || (to = new this.constructor({ dkLen: outputLen }));
-    to.set(...this.get());
-    to.buffer.set(buffer);
-    to.destroyed = destroyed;
-    to.finished = finished;
-    to.length = length4;
-    to.pos = pos;
-    to.outputLen = outputLen;
-    return to;
-  }
-  clone() {
-    return this._cloneInto();
-  }
-};
-function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
-  let j = 0;
-  for (let i = 0; i < rounds; i++) {
-    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
-    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
-    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
-    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
-    ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
-    ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
-    ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
-    ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
-    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
-    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
-    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
-    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
-    ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
-    ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
-    ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
-    ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
   }
-  return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+  return null;
+}
+function pickTagline() {
+  const holiday = getHolidayTagline();
+  if (holiday) return holiday;
+  return TAGLINES[Math.floor(Math.random() * TAGLINES.length)];
 }
 
-// ../../node_modules/@noble/hashes/esm/blake3.js
-init_utils();
-var B3_Flags = {
-  CHUNK_START: 1,
-  CHUNK_END: 2,
-  PARENT: 4,
-  ROOT: 8,
-  KEYED_HASH: 16,
-  DERIVE_KEY_CONTEXT: 32,
-  DERIVE_KEY_MATERIAL: 64
-};
-var B3_IV = SHA256_IV.slice();
-var B3_SIGMA = /* @__PURE__ */ (() => {
-  const Id = Array.from({ length: 16 }, (_, i) => i);
-  const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
-  const res = [];
-  for (let i = 0, v = Id; i < 7; i++, v = permute(v))
-    res.push(...v);
-  return Uint8Array.from(res);
-})();
-var BLAKE3 = class _BLAKE3 extends BLAKE2 {
-  constructor(opts = {}, flags = 0) {
-    super(64, opts.dkLen === void 0 ? 32 : opts.dkLen);
-    this.chunkPos = 0;
-    this.chunksDone = 0;
-    this.flags = 0 | 0;
-    this.stack = [];
-    this.posOut = 0;
-    this.bufferOut32 = new Uint32Array(16);
-    this.chunkOut = 0;
-    this.enableXOF = true;
-    const { key, context } = opts;
-    const hasContext = context !== void 0;
-    if (key !== void 0) {
-      if (hasContext)
-        throw new Error('Only "key" or "context" can be specified at same time');
-      const k = toBytes(key).slice();
-      abytes(k, 32);
-      this.IV = u32(k);
-      swap32IfBE(this.IV);
-      this.flags = flags | B3_Flags.KEYED_HASH;
-    } else if (hasContext) {
-      const ctx = toBytes(context);
-      const contextKey = new _BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT).update(ctx).digest();
-      this.IV = u32(contextKey);
-      swap32IfBE(this.IV);
-      this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
-    } else {
-      this.IV = B3_IV.slice();
-      this.flags = flags;
-    }
-    this.state = this.IV.slice();
-    this.bufferOut = u8(this.bufferOut32);
-  }
-  // Unused
-  get() {
-    return [];
+// src/output/banner.ts
+init_theme();
+import { execSync } from "child_process";
+var bannerEmitted = false;
+function resolveCommitHash() {
+  try {
+    return execSync("git rev-parse --short HEAD", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim() || null;
+  } catch {
+    return null;
   }
-  set() {
-  }
-  b2Compress(counter, flags, buf, bufPos = 0) {
-    const { state: s, pos } = this;
-    const { h, l } = fromBig(BigInt(counter), true);
-    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags);
-    s[0] = v0 ^ v8;
-    s[1] = v1 ^ v9;
-    s[2] = v2 ^ v10;
-    s[3] = v3 ^ v11;
-    s[4] = v4 ^ v12;
-    s[5] = v5 ^ v13;
-    s[6] = v6 ^ v14;
-    s[7] = v7 ^ v15;
-  }
-  compress(buf, bufPos = 0, isLast = false) {
-    let flags = this.flags;
-    if (!this.chunkPos)
-      flags |= B3_Flags.CHUNK_START;
-    if (this.chunkPos === 15 || isLast)
-      flags |= B3_Flags.CHUNK_END;
-    if (!isLast)
-      this.pos = this.blockLen;
-    this.b2Compress(this.chunksDone, flags, buf, bufPos);
-    this.chunkPos += 1;
-    if (this.chunkPos === 16 || isLast) {
-      let chunk = this.state;
-      this.state = this.IV.slice();
-      for (let last, chunks = this.chunksDone + 1; isLast || !(chunks & 1); chunks >>= 1) {
-        if (!(last = this.stack.pop()))
-          break;
-        this.buffer32.set(last, 0);
-        this.buffer32.set(chunk, 8);
-        this.pos = this.blockLen;
-        this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
-        chunk = this.state;
-        this.state = this.IV.slice();
-      }
-      this.chunksDone++;
-      this.chunkPos = 0;
-      this.stack.push(chunk);
-    }
-    this.pos = 0;
-  }
-  _cloneInto(to) {
-    to = super._cloneInto(to);
-    const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
-    to.state.set(state.slice());
-    to.stack = stack.map((i) => Uint32Array.from(i));
-    to.IV.set(IV);
-    to.flags = flags;
-    to.chunkPos = chunkPos;
-    to.chunksDone = chunksDone;
-    to.posOut = posOut;
-    to.chunkOut = chunkOut;
-    to.enableXOF = this.enableXOF;
-    to.bufferOut32.set(this.bufferOut32);
-    return to;
-  }
-  destroy() {
-    this.destroyed = true;
-    clean(this.state, this.buffer32, this.IV, this.bufferOut32);
-    clean(...this.stack);
-  }
-  // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)
-  b2CompressOut() {
-    const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
-    const { h, l } = fromBig(BigInt(this.chunkOut++));
-    swap32IfBE(buffer32);
-    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags);
-    out32[0] = v0 ^ v8;
-    out32[1] = v1 ^ v9;
-    out32[2] = v2 ^ v10;
-    out32[3] = v3 ^ v11;
-    out32[4] = v4 ^ v12;
-    out32[5] = v5 ^ v13;
-    out32[6] = v6 ^ v14;
-    out32[7] = v7 ^ v15;
-    out32[8] = s[0] ^ v8;
-    out32[9] = s[1] ^ v9;
-    out32[10] = s[2] ^ v10;
-    out32[11] = s[3] ^ v11;
-    out32[12] = s[4] ^ v12;
-    out32[13] = s[5] ^ v13;
-    out32[14] = s[6] ^ v14;
-    out32[15] = s[7] ^ v15;
-    swap32IfBE(buffer32);
-    swap32IfBE(out32);
-    this.posOut = 0;
-  }
-  finish() {
-    if (this.finished)
-      return;
-    this.finished = true;
-    clean(this.buffer.subarray(this.pos));
-    let flags = this.flags | B3_Flags.ROOT;
-    if (this.stack.length) {
-      flags |= B3_Flags.PARENT;
-      swap32IfBE(this.buffer32);
-      this.compress(this.buffer32, 0, true);
-      swap32IfBE(this.buffer32);
-      this.chunksDone = 0;
-      this.pos = this.blockLen;
-    } else {
-      flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
-    }
-    this.flags = flags;
-    this.b2CompressOut();
-  }
-  writeInto(out) {
-    aexists(this, false);
-    abytes(out);
-    this.finish();
-    const { blockLen, bufferOut } = this;
-    for (let pos = 0, len = out.length; pos < len; ) {
-      if (this.posOut >= blockLen)
-        this.b2CompressOut();
-      const take = Math.min(blockLen - this.posOut, len - pos);
-      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-      this.posOut += take;
-      pos += take;
-    }
-    return out;
-  }
-  xofInto(out) {
-    if (!this.enableXOF)
-      throw new Error("XOF is not possible after digest call");
-    return this.writeInto(out);
-  }
-  xof(bytes) {
-    anumber(bytes);
-    return this.xofInto(new Uint8Array(bytes));
-  }
-  digestInto(out) {
-    aoutput(out, this);
-    if (this.finished)
-      throw new Error("digest() was already called");
-    this.enableXOF = false;
-    this.writeInto(out);
-    this.destroy();
-    return out;
-  }
-  digest() {
-    return this.digestInto(new Uint8Array(this.outputLen));
+}
+function formatBannerLine(version2) {
+  const commit = resolveCommitHash();
+  const tagline = pickTagline();
+  const versionPart = `tc v${version2}`;
+  const commitPart = commit ? ` (${commit})` : "";
+  const separator = " \u2014 ";
+  if (!isInteractive()) {
+    return `${versionPart}${commitPart}${separator}${tagline}`;
   }
-};
-var blake3 = /* @__PURE__ */ createXOFer((opts) => new BLAKE3(opts));
+  return [
+    theme.brand("\u2601\uFE0F  tc"),
+    " ",
+    theme.muted(`v${version2}`),
+    commit ? theme.dim(` (${commit})`) : "",
+    theme.dim(separator),
+    theme.primary(tagline)
+  ].join("");
+}
+function emitBanner(version2) {
+  if (bannerEmitted) return;
+  if (shouldOutputJson()) return;
+  if (process.env.TC_HIDE_BANNER === "1") return;
+  bannerEmitted = true;
+  process.stderr.write(formatBannerLine(version2) + "\n\n");
+}
+
+// src/index.ts
+init_replication_registry();
+init_theme();
+init_formatter();
+init_profiles();
 
 // ../share-sdk/dist/index.js
+init_sha2();
+init_ed25519();
+init_blake3();
+init_ed25519();
 init_sha256();
 init_sha256();
 var __defProp2 = Object.defineProperty;
@@ -15280,12 +15792,12 @@ async function notifyShare(input) {
     if (input.signal?.aborted) throw new ShareNotifyError("share delivery was cancelled");
     attempts += 1;
     try {
-      const state = await input.adapter.deliver({ shareId: input.shareId, recipient, idempotencyKey, ...input.record === void 0 ? {} : { record: input.record }, ...input.signal === void 0 ? {} : { signal: input.signal } });
+      const state2 = await input.adapter.deliver({ shareId: input.shareId, recipient, idempotencyKey, ...input.record === void 0 ? {} : { record: input.record }, ...input.signal === void 0 ? {} : { signal: input.signal } });
       return {
         protocol: "tinycloud-share",
         version: 1,
         shareId: input.shareId,
-        state: state === "delivered" && input.record?.deliveredRecipients?.includes(recipient) ? "already-delivered" : state,
+        state: state2 === "delivered" && input.record?.deliveredRecipients?.includes(recipient) ? "already-delivered" : state2,
         idempotencyKey,
         attempts
       };
@@ -16982,7 +17494,7 @@ function receiveJson(result, path) {
 import { constants } from "fs";
 import { lstat as lstat2, mkdir as mkdir2, mkdtemp, open as open2, readFile as readFile3, realpath, stat as stat2, link, rename as rename2, rm as rm3, unlink } from "fs/promises";
 import { randomBytes as randomBytes2 } from "crypto";
-import { basename as basename2, join as join5, resolve, sep } from "path";
+import { basename as basename2, join as join7, resolve, sep } from "path";
 init_errors();
 var MAX_SHARE_STDIN_BYTES = 100 * 1024 * 1024;
 var MAX_SHARE_URL_BYTES = 64 * 1024;
@@ -17036,7 +17548,7 @@ async function assertDirectory(path) {
   const segments = absolute.split(sep).filter(Boolean);
   let current = absolute.startsWith(sep) ? sep : "";
   for (const segment of segments) {
-    current = current === sep ? join5(current, segment) : join5(current, segment);
+    current = current === sep ? join7(current, segment) : join7(current, segment);
     try {
       const info = await lstat2(current);
       if (info.isSymbolicLink()) {
@@ -17058,17 +17570,17 @@ async function writeShareOutput(directory, filename, bytes, force) {
   const safeName = safeFilename(filename);
   const directoryHandle = await open2(outputDirectory, constants.O_RDONLY | (constants.O_DIRECTORY ?? 0) | (constants.O_NOFOLLOW ?? 0));
   const stableDirectory = await realpath(outputDirectory);
-  const outputPath = join5(stableDirectory, safeName);
+  const outputPath = join7(stableDirectory, safeName);
   const directoryIdentity = await directoryHandle.stat();
   const assertStableDirectory = async () => {
     const current = await stat2(stableDirectory);
     if (current.dev !== directoryIdentity.dev || current.ino !== directoryIdentity.ino) throw new Error("OUTPUT_EXISTS");
   };
   await assertStableDirectory();
-  const stagingDirectory = await mkdtemp(join5(stableDirectory, ".tinycloud-share-stage-"));
+  const stagingDirectory = await mkdtemp(join7(stableDirectory, ".tinycloud-share-stage-"));
   const stagingInfo = await lstat2(stagingDirectory);
   if (!stagingInfo.isDirectory() || (stagingInfo.mode & 511) !== 448) throw new Error("OUTPUT_EXISTS");
-  const stagingPath = join5(stagingDirectory, `.tinycloud-share-${randomBytes2(16).toString("hex")}.tmp`);
+  const stagingPath = join7(stagingDirectory, `.tinycloud-share-${randomBytes2(16).toString("hex")}.tmp`);
   let temporaryPath;
   let handle;
   try {
@@ -17105,7 +17617,7 @@ async function writeShareOutput(directory, filename, bytes, force) {
     await rm3(stagingDirectory, { recursive: true, force: true });
     await directoryHandle.close();
   }
-  return join5(outputDirectory, safeName);
+  return join7(outputDirectory, safeName);
 }
 
 // src/share/errors.ts
@@ -17391,7 +17903,7 @@ function registerShareCommand(program2) {
       if (json) writeJson2({ ...redactPublishedShare(result), expiryClamped: result.metadata.expiryClamped === true, ...notification === void 0 ? {} : { notification } });
       else publishHuman(result);
     } catch (error) {
-      handleError(shareCliError(error));
+      return handleError(shareCliError(error));
     }
   });
   share.command("inspect [url]").description("Verify a share link and print safe metadata").option("--stdin", "Read the complete URL from stdin").option("--json", "Print versioned redacted JSON").option("--viewer-origin <origin>", "Require this canonical Share origin", SHARE_ORIGIN).action(async (url, options, command) => {
@@ -17401,7 +17913,7 @@ function registerShareCommand(program2) {
       if (json) writeJson2(result);
       else inspectHuman(result);
     } catch (error) {
-      handleError(shareCliError(error));
+      return handleError(shareCliError(error));
     }
   });
   share.command("receive [url]").description("Verify and receive a share link").option("--stdin", "Read the complete URL from stdin").option("--output <directory>", "Create the file in this directory").option("--stdout", "Write verified plaintext bytes to stdout").option("--force", "Allow replacing an existing non-symlink output").option("--max-bytes <bytes>", "Bound received content bytes").option("--json", "Print versioned redacted JSON").option("--viewer-origin <origin>", "Require this canonical Share origin", SHARE_ORIGIN).action(async (url, options, command) => {
@@ -17449,7 +17961,7 @@ function registerShareCommand(program2) {
       if (json) receiveJson(result, output);
       else receiveHuman(output);
     } catch (error) {
-      handleError(shareCliError(error));
+      return handleError(shareCliError(error));
     }
   });
   share.command("list").description("List encrypted sender history without complete bearer URLs").option("--json", "Print versioned redacted JSON").action(async (options, command) => {
@@ -17460,7 +17972,7 @@ function registerShareCommand(program2) {
       if (json) writeJson2({ protocol: "tinycloud-share", version: 1, shares: result });
       else process.stdout.write(result.map((item) => `${item.shareId}	${item.target}	${item.expiresAt}`).join("\n") + (result.length ? "\n" : ""));
     } catch (error) {
-      handleError(shareCliError(error));
+      return handleError(shareCliError(error));
     }
   });
   share.command("show <id>").description("Show one redacted sender-history record").option("--reveal-link", "Explicitly include the complete link").option("--json", "Print versioned redacted JSON").action(async (id, options, command) => {
@@ -17472,7 +17984,7 @@ function registerShareCommand(program2) {
       if (json) writeJson2({ protocol: "tinycloud-share", version: 1, share: result });
       else writeJson2(result);
     } catch (error) {
-      handleError(shareCliError(error));
+      return handleError(shareCliError(error));
     }
   });
   share.command("notify <id>").description("Retry idempotent delivery within 5 minutes of publication; after that publish a new share").requiredOption("--to <address>", "Recipient email").option("--json", "Print versioned JSON").action(async (id, options, command) => {
@@ -17499,7 +18011,7 @@ function registerShareCommand(program2) {
       if (result.reason === "delivery-window-expired") process.stderr.write(NOTIFY_WINDOW_MESSAGE);
       if (result.state === "partial-failure") process.exitCode = 9;
     } catch (error) {
-      handleError(shareCliError(error, "notify"));
+      return handleError(shareCliError(error, "notify"));
     }
   });
   share.command("revoke <id>").description("Revoke addressed shares; report bearer retention honestly").option("--ancestor", "Revoke the owner delegation ancestry").option("--json", "Print versioned JSON").action(async (id, options, command) => {
@@ -17516,7 +18028,7 @@ function registerShareCommand(program2) {
       else process.stdout.write(`${result.state}
 `);
     } catch (error) {
-      handleError(shareCliError(error));
+      return handleError(shareCliError(error));
     }
   });
 }
@@ -17527,7 +18039,7 @@ init_profiles();
 init_constants();
 init_session_expired();
 import { readFile as readFile4 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import { createHash } from "crypto";
 import { writeJsonAtomic as writeJsonAtomic2 } from "@tinycloud/operations/state";
 import { LocationRecordValidationError, LocationRegistryHttpError, revokePolicyRootV3 } from "@tinycloud/sdk-core";
@@ -17632,8 +18144,8 @@ function createEncryptedProfileHistory(profileName, sessionSigner) {
   const observedProfiles = /* @__PURE__ */ new Set();
   let preparedKeys;
   let preparedKey;
-  const path = async (profile) => join6(await ProfileManager.getCacheDir(profile), "share-history-v2.json");
-  const legacyPath = async (profile) => join6(await ProfileManager.getCacheDir(profile), "share-history-v1.bin");
+  const path = async (profile) => join8(await ProfileManager.getCacheDir(profile), "share-history-v2.json");
+  const legacyPath = async (profile) => join8(await ProfileManager.getCacheDir(profile), "share-history-v1.bin");
   const b64 = (value) => Buffer.from(value).toString("base64url");
   const unb64 = (value) => {
     if (typeof value !== "string" || !/^[A-Za-z0-9_-]+$/.test(value)) throw new Error("share history is unavailable");
@@ -18179,6 +18691,12 @@ async function selectedProfileName() {
   return process.env.TC_PROFILE ?? config.defaultProfile;
 }
 
+// src/lib/courier-loader.ts
+async function loadCourierEntry() {
+  const load = new Function("specifier", "return import(specifier)");
+  return load(new URL("./courier-entry.js", import.meta.url).href);
+}
+
 // src/index.ts
 var { version } = JSON.parse(
   readFileSync2(new URL("../package.json", import.meta.url), "utf-8")
@@ -18197,7 +18715,7 @@ function selectedShareProfile() {
   }
   return process.env.TC_PROFILE;
 }
-program.name("tc").description("TinyCloud CLI \u2014 self-sovereign storage from the terminal").version(version).option("-p, --profile <name>", "Profile to use").option("-H, --host <url>", "TinyCloud node URL").option("-v, --verbose", "Enable verbose output").option("--no-cache", "Disable caching").option("-q, --quiet", "Suppress non-essential output").option("--json", "Force JSON output");
+program.name("tc").description("TinyCloud CLI \u2014 self-sovereign storage from the terminal").version(version).option("-p, --profile <name>", "Profile to use").option("-H, --host <url>", "TinyCloud node URL").option("-v, --verbose", "Enable verbose output").option("--no-cache", "Disable caching").option("-q, --quiet", "Suppress non-essential output").option("--json", "Force JSON output").option("--replication", "Enable read-through replication for this invocation").option("--no-replication", "Disable read-through replication for this invocation").option("--replication-debug", "Write replication diagnostics to stderr");
 program.hook("preAction", async (thisCommand) => {
   const opts = thisCommand.optsWithGlobals();
   setJsonOutputRequested(opts.json === true);
@@ -18238,30 +18756,28 @@ configureShareCommandServices({
   nativeReader: shareAuthority.nativeReader
 });
 var argv = process.argv.slice(2);
-var globalOptionsWithValues = /* @__PURE__ */ new Set(["--profile", "-p", "--host", "-H"]);
+var globalLongOptionsWithValues = { "--profile": true, "--host": true };
+var globalShortOptionsWithValues = { p: true, H: true };
 function firstCommandToken(values) {
   for (let index = 0; index < values.length; index += 1) {
     const value = values[index];
     if (value === "--") return values[index + 1];
-    if (globalOptionsWithValues.has(value)) {
-      index += 1;
+    if (value.startsWith("--")) {
+      if (globalLongOptionsWithValues[value]) index += 1;
+      continue;
+    }
+    if (value.length > 1 && value.startsWith("-")) {
+      for (let char = 1; char < value.length; char += 1) {
+        if (!globalShortOptionsWithValues[value[char]]) continue;
+        if (char === value.length - 1) index += 1;
+        break;
+      }
       continue;
     }
-    if (value.startsWith("--profile=") || value.startsWith("--host=")) continue;
-    if (value === "--verbose" || value === "--no-cache" || value === "-q" || value === "--quiet" || value === "--json") continue;
-    if (value.startsWith("-")) continue;
     return value;
   }
   return void 0;
 }
-var isShareInvocation = firstCommandToken(argv) === "share";
-if (isShareInvocation) {
-  registerShareCommand(program);
-} else {
-  const loadLegacy = new Function("specifier", "return import(specifier)");
-  const { registerTinyCloudCommands } = await loadLegacy(new URL("./legacy-entry.js", import.meta.url).href);
-  registerTinyCloudCommands(program);
-}
 program.addHelpText("before", () => `${theme.label("Version:")} ${theme.value(version)}
 `);
 program.addHelpText("afterAll", () => {
@@ -18281,10 +18797,37 @@ ${theme.muted("Docs:")} ${theme.accent("https://docs.tinycloud.xyz/cli")}
 ${theme.muted("Repo:")} ${theme.accent("https://github.com/tinycloudlabs/web-sdk")}
 `;
 });
-try {
-  await program.parseAsync(process.argv);
-} catch (error) {
-  handleError(error);
+var commandToken = firstCommandToken(argv);
+if (argv[0] === "courier") {
+  const code3 = await (await loadCourierEntry()).runCourier(argv.slice(1));
+  if (code3 !== 0) process.exit(code3);
+} else if (commandToken === "courier") {
+  process.stderr.write(`${TC_OPTIONS_BEFORE_COURIER}
+`);
+  process.exit(2);
+} else {
+  if (commandToken === "share") {
+    registerShareCommand(program);
+  } else {
+    const loadLegacy = new Function("specifier", "return import(specifier)");
+    const { registerTinyCloudCommands } = await loadLegacy(new URL("./legacy-entry.js", import.meta.url).href);
+    registerTinyCloudCommands(program);
+  }
+  try {
+    await program.parseAsync(process.argv);
+    if (await closeReplication()) {
+      process.exitCode = 0;
+      const stdoutFlushed = Promise.withResolvers();
+      process.stdout.write("", () => stdoutFlushed.resolve());
+      await stdoutFlushed.promise;
+      const stderrFlushed = Promise.withResolvers();
+      process.stderr.write("", () => stderrFlushed.resolve());
+      await stderrFlushed.promise;
+      process.exit();
+    }
+  } catch (error) {
+    await handleError(error);
+  }
 }
 /*! Bundled license information: