@tinycloud/cli 1.2.0-beta.4 → 1.2.0-beta.6

package/dist/index.js

@@ -5806,1095 +5806,568 @@ var init_replication_log = __esm({
   }
 });
 
-// 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;
-  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)
-  };
+// ../../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 };
 }
-var init_replication_config = __esm({
-  "src/lib/replication-config.ts"() {
+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_replication_log();
+    init_utils();
   }
 });
 
-// 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;
+// ../../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 { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
 }
-function selectSignerJwk(sessionJwk, key) {
-  if (jwkHasPrivateParameter(sessionJwk)) {
-    return sessionJwk;
+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();
+      }
+    };
   }
-  return key ?? void 0;
+});
+
+// ../../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);
+      }
+      // 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));
+  }
+});
+
+// ../../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;
 }
-function signerJwkForProfile(profileName, sessionJwk, key) {
-  const jwk = selectSignerJwk(sessionJwk, key);
-  if (jwkHasPrivateParameter(jwk)) {
-    return jwk;
+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);
   }
-  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`
-    }
-  );
+  return value;
 }
-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();
+function hexToNumber(hex3) {
+  if (typeof hex3 !== "string")
+    throw new Error("hex string expected, got " + typeof hex3);
+  return hex3 === "" ? _0n : BigInt("0x" + hex3);
 }
-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 bytesToNumberBE(bytes) {
+  return hexToNumber(bytesToHex(bytes));
 }
-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
-  };
+function bytesToNumberLE(bytes) {
+  abytes(bytes);
+  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
 }
-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" };
-  }
-}
-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 numberToBytesBE(n, len) {
+  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
 }
-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 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");
-    }
-    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;
-  }
-  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");
-  }
-  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
-    }));
-  }
-  return node;
+function numberToBytesLE(n, len) {
+  return numberToBytesBE(n, len).reverse();
 }
-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
-    };
-    const profile = { ...previousProfile, sessionDid, spaceId: delegation.spaceId };
+function ensureBytes(title, hex3, expectedLength) {
+  let res;
+  if (typeof hex3 === "string") {
     try {
-      await ProfileManager.setSession(ctx.profile, session);
-      await ProfileManager.setProfile(ctx.profile, profile);
-    } catch (error) {
-      throw annotate(error, await restoreBeforeBootstrap(ctx.profile, previousProfile));
+      res = hexToBytes(hex3);
+    } catch (e) {
+      throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
     }
-    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.`;
-      }
-      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);
+  } else if (isBytes(hex3)) {
+    res = Uint8Array.from(hex3);
+  } else {
+    throw new Error(title + " must be hex string or Uint8Array");
   }
-  return { node, abandon };
+  const len = res.length;
+  if (typeof expectedLength === "number" && len !== expectedLength)
+    throw new Error(title + " of length " + expectedLength + " expected, got " + len);
+  return res;
 }
-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 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 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 copyBytes(bytes) {
+  return Uint8Array.from(bytes);
 }
-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 inRange(n, min, max) {
+  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
 }
-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 aInRange(title, n, min, max) {
+  if (!inRange(n, min, max))
+    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
 }
-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
-        }
-      }));
-    }
-  };
+function bitLen(n) {
+  let len;
+  for (len = 0; n > _0n; n >>= _1n, len += 1)
+    ;
+  return len;
 }
-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 };
+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}`);
   }
-  const discovered = await discoverLocalTinyCloudNode({
-    localNodeUrl: profile?.localNodeUrl,
-    localLinkName: profile?.localLinkName,
-    expectedNodeDid: profile?.expectedNodeDid,
-    identityStore: profileLocalNodeIdentityStore(profileName)
-  });
-  return { host: discovered?.url ?? null, deferred: false };
-}
-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;
+  Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
+  Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
 }
-function canonicalizeAddress2(address) {
-  const trimmed = address.trim();
-  return trimmed.startsWith("0x") ? `0x${trimmed.slice(2).toLowerCase()}` : trimmed.toLowerCase();
+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;
+  };
 }
-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);
+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");
+    };
   }
-  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]);
+});
+
+// ../../node_modules/@noble/curves/esm/abstract/modular.js
+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 null;
+  return res;
 }
-function ownerAddressFromSpaceUri(spaceUri) {
-  const match = spaceUri.match(/^tinycloud:pkh:eip155:\d+:(0x[a-fA-F0-9]{40}):/);
-  return match ? canonicalizeAddress2(match[1]) : null;
+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 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 assertIsSquare(Fp2, root, n) {
+  if (!Fp2.eql(Fp2.sqr(root), n))
+    throw new Error("Cannot find square root");
 }
-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 sqrt3mod4(Fp2, n) {
+  const p1div4 = (Fp2.ORDER + _1n2) / _4n;
+  const root = Fp2.pow(n, p1div4);
+  assertIsSquare(Fp2, root, n);
+  return root;
 }
-function spaceNameFromUri(spaceUri) {
-  return spaceUri.slice(spaceUri.lastIndexOf(":") + 1);
+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 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 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;
+  };
 }
-async function resolveHostSpace(name, profileName) {
-  const resolved = await resolveSpaceUri(name, profileName);
-  if (!resolved) {
-    throw new Error(`Could not resolve a space for "${name}".`);
+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++;
   }
-  return resolved;
-}
-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 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 }
-        };
-      }
-    };
-  }
-});
-
-// 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_replication_registry();
-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++;
-  }
-  let Z = _2n;
-  const _Fp = Field(P);
-  while (FpLegendre(_Fp, Z) === 1) {
-    if (Z++ > 1e3)
-      throw new Error("Cannot find square root: probably non-prime P");
+  let Z = _2n;
+  const _Fp = Field(P);
+  while (FpLegendre(_Fp, Z) === 1) {
+    if (Z++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
   }
   if (S === 1)
     return sqrt3mod4;
@@ -6939,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",
@@ -7121,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;
@@ -7171,149 +6659,20 @@ function validateMSMPoints(points, c) {
   });
 }
 function validateMSMScalars(scalars, field) {
-  if (!Array.isArray(scalars))
-    throw new Error("array of scalars expected");
-  scalars.forEach((s, i) => {
-    if (!field.isValid(s))
-      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;
-}
-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;
-  }
-};
+  if (!Array.isArray(scalars))
+    throw new Error("array of scalars expected");
+  scalars.forEach((s, i) => {
+    if (!field.isValid(s))
+      throw new Error("invalid scalar at index " + i);
+  });
+}
+function getW(P) {
+  return pointWindowSizes.get(P) || 1;
+}
+function assert0(n) {
+  if (n !== _0n3)
+    throw new Error("invalid wNAF");
+}
 function pippenger(c, fieldN, points, scalars) {
   validateMSMPoints(points, c);
   validateMSMScalars(scalars, fieldN);
@@ -7384,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);
@@ -7673,828 +7167,1513 @@ function edwards(params, extraOpts = {}) {
   Point.BASE.precompute(8);
   return Point;
 }
-var PrimeEdwardsPoint = class {
-  constructor(ep) {
-    this.ep = ep;
+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));
   }
-  // Static methods that must be implemented by subclasses
-  static fromBytes(_bytes) {
-    notImplemented();
+  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 };
   }
-  static fromHex(_hex) {
-    notImplemented();
+  function getExtendedPublicKey(secretKey) {
+    const { head, prefix, scalar } = getPrivateScalar(secretKey);
+    const point = BASE.multiply(scalar);
+    const pointBytes = point.toBytes();
+    return { head, prefix, scalar, point, pointBytes };
   }
-  get x() {
-    return this.toAffine().x;
+  function getPublicKey(secretKey) {
+    return getExtendedPublicKey(secretKey).pointBytes;
   }
-  get y() {
-    return this.toAffine().y;
+  function hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
+    const msg = concatBytes(...msgs);
+    return modN_LE(cHash(domain(msg, ensureBytes("context", context), !!prehash)));
   }
-  // Common implementations
-  clearCofactor() {
-    return this;
+  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) };
   }
-  assertValidity() {
-    this.ep.assertValidity();
+  function isValidSecretKey(key) {
+    return isBytes(key) && key.length === Fn2.BYTES;
   }
-  toAffine(invertedZ) {
-    return this.ep.toAffine(invertedZ);
+  function isValidPublicKey(key, zip215) {
+    try {
+      return !!Point.fromBytes(key, zip215);
+    } catch (error) {
+      return false;
+    }
   }
-  toHex() {
-    return bytesToHex(this.toBytes());
+  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();
+      }
+    };
   }
-  toString() {
-    return this.toHex();
+});
+
+// ../../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)();
   }
-  isTorsionFree() {
-    return true;
+});
+
+// ../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}`);
   }
-  isSmallOrder() {
-    return false;
+}
+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.`
+    );
   }
-  add(other) {
-    this.assertSame(other);
-    return this.init(this.ep.add(other.ep));
+}
+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();
   }
-  subtract(other) {
-    this.assertSame(other);
-    return this.init(this.ep.subtract(other.ep));
+});
+
+// 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.` }
+      );
+    }
   }
-  multiply(scalar) {
-    return this.init(this.ep.multiply(scalar));
+  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();
   }
-  multiplyUnsafe(scalar) {
-    return this.init(this.ep.multiplyUnsafe(scalar));
+});
+
+// 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;
   }
-  double() {
-    return this.init(this.ep.double());
+  return key ?? void 0;
+}
+function signerJwkForProfile(profileName, sessionJwk, key) {
+  const jwk = selectSignerJwk(sessionJwk, key);
+  if (jwkHasPrivateParameter(jwk)) {
+    return jwk;
   }
-  negate() {
-    return this.init(this.ep.negate());
+  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;
   }
-  precompute(windowSize, isLazy) {
-    return this.init(this.ep.precompute(windowSize, isLazy));
+}
+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" };
   }
-  /** @deprecated use `toBytes` */
-  toRawBytes() {
-    return this.toBytes();
+  if (typeof session.expiresAt === "string" && Date.parse(session.expiresAt) <= Date.now()) {
+    return { unavailable: "session_expired" };
   }
-};
-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));
+  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 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 };
+}
+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 getExtendedPublicKey(secretKey) {
-    const { head, prefix, scalar } = getPrivateScalar(secretKey);
-    const point = BASE.multiply(scalar);
-    const pointBytes = point.toBytes();
-    return { head, prefix, scalar, point, pointBytes };
+}
+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
+    );
   }
-  function getPublicKey(secretKey) {
-    return getExtendedPublicKey(secretKey).pointBytes;
+  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");
+    }
+    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 hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
-    const msg = concatBytes(...msgs);
-    return modN_LE(cHash(domain(msg, ensureBytes("context", context), !!prehash)));
+  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 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 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
+    }));
   }
-  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;
+  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 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 {
-      A = Point.fromBytes(publicKey, zip215);
-      R = Point.fromBytes(r, zip215);
-      SB = BASE.multiplyUnsafe(s);
+      await ProfileManager.setSession(ctx.profile, session);
+      await ProfileManager.setProfile(ctx.profile, profile);
     } catch (error) {
-      return false;
+      throw annotate(error, await restoreBeforeBootstrap(ctx.profile, previousProfile));
     }
-    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
+    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.`;
+      }
+      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);
   };
-  function randomSecretKey(seed = randomBytes3(lengths.seed)) {
-    return _abytes2(seed, lengths.seed, "seed");
+  let node;
+  try {
+    node = await createSDKInstance(ctx);
+  } catch (error) {
+    return abandon(error);
   }
-  function keygen(seed) {
-    const secretKey = utils.randomSecretKey(seed);
-    return { secretKey, publicKey: getPublicKey(secretKey) };
+  return { node, abandon };
+}
+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 isValidSecretKey(key) {
-    return isBytes(key) && key.length === Fn2.BYTES;
+  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 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 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);
+}
+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
+    );
   }
-  function isValidPublicKey(key, zip215) {
-    try {
-      return !!Point.fromBytes(key, zip215);
-    } catch (error) {
-      return false;
-    }
+  return createSDKInstance(ctx, options);
+}
+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"];
   }
-  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);
+});
+
+// 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];
     },
-    /** @deprecated */
-    randomPrivateKey: randomSecretKey,
-    /** @deprecated */
-    precompute(windowSize = 8, point = Point.BASE) {
-      return point.precompute(windowSize, false);
+    set: async (url, nodeDid) => {
+      if (!await ProfileManager.profileExists(profileName)) return;
+      await ProfileManager.updateProfile(profileName, (profile) => ({
+        ...profile,
+        pinnedLocalNodeDids: {
+          ...profile.pinnedLocalNodeDids,
+          [url]: nodeDid
+        }
+      }));
     }
   };
-  return Object.freeze({
-    keygen,
-    getPublicKey,
-    sign,
-    verify,
-    utils,
-    Point,
-    lengths
+}
+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 _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 };
+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 _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 canonicalizeAddress2(address) {
+  const trimmed = address.trim();
+  return trimmed.startsWith("0x") ? `0x${trimmed.slice(2).toLowerCase()}` : trimmed.toLowerCase();
 }
-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);
+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);
+  }
+  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]);
+  }
+  return null;
 }
-
-// ../../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 ownerAddressFromSpaceUri(spaceUri) {
+  const match = spaceUri.match(/^tinycloud:pkh:eip155:\d+:(0x[a-fA-F0-9]{40}):/);
+  return match ? canonicalizeAddress2(match[1]) : null;
 }
-function adjustScalarBytes(bytes) {
-  bytes[0] &= 248;
-  bytes[31] &= 127;
-  bytes[31] |= 64;
-  return bytes;
+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])}`;
 }
-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 };
+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;
 }
-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));
+function spaceNameFromUri(spaceUri) {
+  return spaceUri.slice(spaceUri.lastIndexOf(":") + 1);
 }
-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 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 });
 }
-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));
-  }
-  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);
+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: 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));
+}
+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;
@@ -18512,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")
@@ -18571,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" || value === "--replication" || value === "--no-replication" || value === "--replication-debug") 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", () => {
@@ -18614,20 +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);
-  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);
+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: