@agentunion/fastaun-browser 0.5.16 → 0.5.17

package/dist/bundle.js

@@ -460,7 +460,7 @@ var init_indexeddb_store = __esm({
 });
 
 // src/version.ts
-var VERSION = "0.5.16";
+var VERSION = "0.5.17";
 
 // src/types.ts
 var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
@@ -5139,6 +5139,7 @@ var PUSHED_SEQS_LIMIT = 5e4;
 var PENDING_ORDERED_LIMIT = 5e4;
 var MESSAGE_RECALL_SEEN_LIMIT = 1e4;
 var GROUP_RECALL_SEEN_LIMIT = 1e4;
+var VOLATILE_SEEN_LIMIT = 1e4;
 var SEQ_TRACKER_PERSIST_FLUSH_DELAY_MS = 200;
 var P2P_GAP_FILL_RETRY_LIMIT = 12;
 var P2P_GAP_FILL_RETRY_BASE_MS = 1e3;
@@ -5203,8 +5204,7 @@ var APP_GROUP_EVENT_ENVELOPE_KEYS = [
   "timestamp",
   "t_server",
   "status",
-  "device_id",
-  "slot_id"
+  "device_id"
 ];
 var MAX_INLINE_PENDING_ACK_NAMESPACES = 4096;
 function formatDeliveryError(error) {
@@ -5293,6 +5293,10 @@ var MessageDeliveryEngine = class {
     __publicField(this, "pendingP2PInlineAcks", null);
     __publicField(this, "pendingGroupInlineAcks", null);
     __publicField(this, "pendingGroupInlineAckNamespaces", null);
+    __publicField(this, "volatileContext", "");
+    __publicField(this, "volatilePullCursorValue", "");
+    __publicField(this, "volatileSeenMessages", /* @__PURE__ */ new Map());
+    __publicField(this, "volatileInFlightMessages", /* @__PURE__ */ new Set());
     // reset 后旧 inline Promise 只能自行结束，不能触碰新身份上下文的状态。
     __publicField(this, "inlineGeneration", 0);
     // 同一实例的 tracker 写入必须串行，避免旧的延迟 flush 覆盖新的 Forward 提交。
@@ -5970,6 +5974,10 @@ var MessageDeliveryEngine = class {
     const client = this.runtime.client;
     this.ensurePullOperationCurrent(ns);
     const response = result;
+    const volatileMessages = this.volatileMessages(response.messages);
+    if (method === "message.pull" && volatileMessages.length > 0) {
+      await this.publishPlainVolatileMessages(volatileMessages, "pull", true);
+    }
     const messages = deduplicatePlainForwardPageMessages(response.messages, afterSeq);
     const coordinator = this.forwardCoordinator();
     const pageContigBefore = client._seqTracker.getContiguousSeq(ns);
@@ -6169,14 +6177,19 @@ var MessageDeliveryEngine = class {
       normalized = this.attachAppMessageEnvelope(this.stripInternalSenderDeviceFields(this.attachCurrentInstanceContext(payload)));
     } else if (this.isGroupScopedEvent(event)) {
       payload = this.stripInlineInternalFields(payload);
-      normalized = this.attachAppGroupEventEnvelope(this.attachCurrentInstanceContext(payload));
+      normalized = this.attachAppGroupEventEnvelope(this.stripInternalSenderDeviceFields(this.attachCurrentInstanceContext(payload)));
     } else {
       normalized = payload;
     }
+    if (this.isVolatileMessage(normalized) && isJsonObject(normalized)) {
+      normalized = { ...normalized };
+      delete normalized.seq;
+    }
     const canonicalSource = canonicalDeliverySource(source);
     if (canonicalSource === "direct" || !isJsonObject(normalized)) return normalized;
     if (!this.isInstanceScopedMessageEvent(event) && !this.isGroupScopedEvent(event)) return normalized;
-    return { ...normalized, source: canonicalSource };
+    normalized = { ...normalized, source: canonicalSource };
+    return normalized;
   }
   stripInlineInternalFields(payload) {
     if (!isJsonObject(payload)) return payload;
@@ -6317,10 +6330,13 @@ var MessageDeliveryEngine = class {
   stripInternalSenderDeviceFields(payload) {
     if (!isJsonObject(payload)) return payload;
     const result = { ...payload };
-    delete result.sender_device_id;
     delete result._sender_device_id;
     delete result.from_device_id;
     delete result.from_device;
+    delete result.slot_id;
+    delete result.sender_slot_id;
+    delete result.target_slot_id;
+    delete result.owner_slot_id;
     return result;
   }
   recallEventFromMessage(message) {
@@ -6373,6 +6389,112 @@ var MessageDeliveryEngine = class {
     if (recall) return { event: "message.recalled", payload: recall };
     return { event: "message.received", payload: message };
   }
+  isVolatileMessage(message) {
+    return isJsonObject(message) && String(message.storage ?? "").trim() === "volatile";
+  }
+  volatileMessages(value) {
+    if (!Array.isArray(value)) return [];
+    return value.filter((item) => this.isVolatileMessage(item)).map((item) => ({ ...item }));
+  }
+  ensureVolatileContext() {
+    const client = this.runtime.client;
+    const context = JSON.stringify([client._aid ?? "", client._deviceId ?? "", client._slotId ?? ""]);
+    if (context === this.volatileContext) return;
+    this.volatileContext = context;
+    this.volatilePullCursorValue = "";
+    this.volatileSeenMessages.clear();
+    this.volatileInFlightMessages.clear();
+  }
+  volatilePullCursor() {
+    this.ensureVolatileContext();
+    return this.volatilePullCursorValue;
+  }
+  resetVolatilePullCursor() {
+    this.ensureVolatileContext();
+    this.volatilePullCursorValue = "";
+  }
+  shouldResetVolatileCursor(cursor, error) {
+    const text3 = error instanceof Error ? error.message : String(error);
+    return Boolean(cursor) && cursor === this.volatilePullCursor() && text3.toLowerCase().includes("volatile cursor epoch mismatch");
+  }
+  volatileSeenKey(message) {
+    const sender = String(message.from_aid ?? message.from ?? "").trim();
+    const messageId = String(message.message_id ?? "").trim();
+    const cursor = String(message.volatile_cursor ?? "").trim();
+    return `${sender}|${messageId || cursor}`;
+  }
+  isVolatileSeen(message) {
+    this.ensureVolatileContext();
+    const now = Date.now();
+    for (const [key, expiresAt] of this.volatileSeenMessages) {
+      if (expiresAt <= now) this.volatileSeenMessages.delete(key);
+    }
+    return this.volatileSeenMessages.has(this.volatileSeenKey(message));
+  }
+  markVolatileSeen(message) {
+    this.ensureVolatileContext();
+    const now = Date.now();
+    const expiresAt = Math.max(now + 6e4, Number(message.expires_at ?? now + 18e5) || now + 18e5);
+    this.volatileSeenMessages.set(this.volatileSeenKey(message), expiresAt);
+    while (this.volatileSeenMessages.size > VOLATILE_SEEN_LIMIT) {
+      const oldest = this.volatileSeenMessages.keys().next().value;
+      if (oldest === void 0) break;
+      this.volatileSeenMessages.delete(oldest);
+    }
+  }
+  beginVolatileDelivery(message) {
+    if (this.isVolatileSeen(message)) return "seen";
+    const key = this.volatileSeenKey(message);
+    if (this.volatileInFlightMessages.has(key)) return "inflight";
+    this.volatileInFlightMessages.add(key);
+    return "claimed";
+  }
+  finishVolatileDelivery(message) {
+    this.ensureVolatileContext();
+    this.volatileInFlightMessages.delete(this.volatileSeenKey(message));
+  }
+  publicVolatileMessage(message) {
+    const result = this.stripInternalSenderDeviceFields(message);
+    delete result.seq;
+    return result;
+  }
+  async ackVolatileMessages(messages, v2, advanceCursor) {
+    const cursors = [...new Set(messages.map((item) => String(item.volatile_cursor ?? "").trim()).filter(Boolean))];
+    if (cursors.length === 0) return void 0;
+    const method = v2 ? "message.v2.ack" : "message.ack";
+    const result = await this.runtime.client._rpcPipeline.rawCall(
+      method,
+      { volatile_cursors: cursors },
+      { background: true }
+    );
+    if (advanceCursor) {
+      this.ensureVolatileContext();
+      this.volatilePullCursorValue = cursors[cursors.length - 1];
+    }
+    return result;
+  }
+  async publishPlainVolatileMessages(messages, source, advanceCursor) {
+    const processed = [];
+    for (const rawMessage of messages) {
+      const message = this.publicVolatileMessage(rawMessage);
+      const claim = this.beginVolatileDelivery(message);
+      if (claim === "seen") {
+        processed.push(rawMessage);
+        continue;
+      }
+      if (claim === "inflight") continue;
+      try {
+        const appEvent = this.p2pAppEventForMessage(message);
+        await this.runtime.client._publishAppEvent(appEvent.event, appEvent.payload, source);
+        this.markVolatileSeen(message);
+      } finally {
+        this.finishVolatileDelivery(message);
+      }
+      processed.push(rawMessage);
+    }
+    if (processed.length > 0) await this.ackVolatileMessages(processed, false, advanceCursor);
+    return processed.map((item) => this.publicVolatileMessage(item));
+  }
   messageRecallDedupKey(payload) {
     const ids = payload.message_ids;
     const idPart = Array.isArray(ids) ? ids.map((i) => String(i ?? "").trim()).filter(Boolean).sort().join(",") : String(ids ?? "").trim();
@@ -6662,7 +6784,7 @@ var MessageDeliveryEngine = class {
     client._clientLog.debug(`_onRawMessageReceived enter: from=${data?.from ?? "-"} mid=${data?.message_id ?? "-"} seq=${data?.seq ?? "-"}`);
     const ns = isJsonObject(data) && client._aid && data.seq !== void 0 ? `p2p:${client._aid}` : "";
     const seq2 = isJsonObject(data) ? positiveSafeSequenceHint(data.seq) : 0;
-    if (client._v2Session && ns && seq2 > 0 && this.messageTargetsCurrentInstance(data)) {
+    if (client._v2Session && ns && seq2 > 0 && !this.isVolatileMessage(data) && this.messageTargetsCurrentInstance(data)) {
       client._seqTracker.updateMaxSeen(ns, seq2);
     }
     const hasInlineObject = isJsonObject(data) && hasNonEmptyInlineMessage(data.inline_message);
@@ -6696,6 +6818,10 @@ var MessageDeliveryEngine = class {
       if (!this.messageTargetsCurrentInstance(msg)) {
         return;
       }
+      if (this.isVolatileMessage(msg)) {
+        await this.publishPlainVolatileMessages([msg], "push", false);
+        return;
+      }
       const legacyPushSeq = positiveSafeSequenceHint(msg.seq);
       const hasInlineField = hasNonEmptyInlineMessage(msg.inline_message);
       if (client._v2Session && client._aid && (legacyPushSeq > 0 || hasInlineField)) {
@@ -7826,6 +7952,10 @@ var MessageDeliveryEngine = class {
     const client = this.runtime.client;
     const ns = client._aid ? `p2p:${client._aid}` : "";
     if (!ns) return;
+    if (this.isVolatileMessage(data)) {
+      await client._v2E2EE.publishV2VolatileMessages([data], "push", false);
+      return;
+    }
     if (isJsonObject(data) && String(data.kind ?? "").trim() === "message.online_unread_hint") {
       if (client._sessionOptions?.background_sync === false) return;
       this.enqueueOnlineUnreadP2pHint(data);
@@ -15912,6 +16042,9 @@ var SIGNED_METHODS = /* @__PURE__ */ new Set([
   "group.commit_state",
   "group.ban",
   "group.unban",
+  "group.block",
+  "group.unblock",
+  "group.report_status",
   "group.dissolve",
   "group.suspend",
   "group.resume"
@@ -16084,12 +16217,22 @@ var RpcPipeline = class {
   async call(method, params2) {
     const client = this.runtime.client;
     const tStart = Date.now();
+    const volatileCursor = method === "message.pull" ? String(params2?.after_volatile_cursor ?? client._delivery.volatilePullCursor() ?? "").trim() : "";
     client._clientLog.debug(`call enter: method=${method}`);
     try {
       const result = await this.callImpl(method, params2);
       client._clientLog.debug(`call exit: elapsed=${Date.now() - tStart}ms method=${method}`);
       return result;
     } catch (err) {
+      if (method === "message.pull" && client._delivery.shouldResetVolatileCursor(volatileCursor, err)) {
+        client._delivery.resetVolatilePullCursor();
+        const retryParams = { ...params2 ?? {} };
+        delete retryParams.after_volatile_cursor;
+        delete retryParams.client_signature;
+        const result = await this.callImpl(method, retryParams);
+        client._clientLog.debug(`call exit: elapsed=${Date.now() - tStart}ms method=${method}`);
+        return result;
+      }
       client._clientLog.debug(`call exit (error): elapsed=${Date.now() - tStart}ms method=${method} err=${err instanceof Error ? err.message : String(err)}`);
       throw err;
     }
@@ -16119,6 +16262,8 @@ var RpcPipeline = class {
         return await client._sendV2(String(p.to ?? ""), p.payload ?? {}, {
           messageId: String(p.message_id ?? "") || void 0,
           timestamp: p.timestamp,
+          ttl: p.ttl,
+          deviceId: String(p.device_id ?? "").trim() || String(p.to_device_id ?? "").trim() || void 0,
           protectedHeaders: client._protectedHeadersFromParams(p),
           context: isJsonObject(p.context) ? p.context : void 0
         });
@@ -16193,7 +16338,8 @@ var RpcPipeline = class {
         if (p.window_mode === "tail") return await client._v2E2EE.pullV2TailInternal(p);
         const messages = await client._pullV2(Number(p.after_seq ?? 0) || 0, Number(p.limit ?? 50) || 50, {
           gateLocked: true,
-          force: p.force === true
+          force: p.force === true,
+          afterVolatileCursor: String(p.after_volatile_cursor ?? "").trim() || void 0
         });
         return { messages };
       } catch (exc) {
@@ -16210,7 +16356,17 @@ var RpcPipeline = class {
     if (method === "message.v2.ack" || method === "message.ack" && hasMatchingV2Session(client)) {
       await client._ensureV2SessionReady("message.ack");
       client._clientLog.debug(`call route: ${method} -> V2 ack`);
-      return await client._ackV2(p.seq ?? p.up_to_seq);
+      const volatileCursors = Array.isArray(p.volatile_cursors) ? p.volatile_cursors.map((value) => String(value ?? "").trim()).filter(Boolean) : String(p.volatile_cursor ?? "").trim() ? [String(p.volatile_cursor).trim()] : [];
+      const volatileIds = Array.isArray(p.volatile_ids) ? p.volatile_ids.map((value) => String(value ?? "").trim()).filter(Boolean) : [];
+      if (volatileCursors.length === 0 && volatileIds.length === 0) {
+        return await client._ackV2(p.seq ?? p.up_to_seq);
+      }
+      return await client._ackV2(
+        p.seq ?? p.up_to_seq ?? 0,
+        void 0,
+        volatileCursors,
+        volatileIds
+      );
     }
     if ((method === "group.v2.pull" || method === "group.pull") && p.group_id && (method === "group.v2.pull" || hasMatchingV2Session(client))) {
       await client._ensureV2SessionReady("group.pull");
@@ -16378,7 +16534,7 @@ var RpcPipeline = class {
     }
   }
   injectMessageCursorContext(method, params2) {
-    if (method !== "message.pull" && method !== "message.ack") {
+    if (!["message.pull", "message.v2.pull", "message.ack", "message.v2.ack"].includes(method)) {
       return;
     }
     const client = this.runtime.client;
@@ -16391,6 +16547,10 @@ var RpcPipeline = class {
     }
     params2.device_id = client._deviceId;
     params2.slot_id = client._slotId;
+    if ((method === "message.pull" || method === "message.v2.pull") && params2.after_volatile_cursor === void 0) {
+      const volatileCursor = client._delivery.volatilePullCursor();
+      if (volatileCursor) params2.after_volatile_cursor = volatileCursor;
+    }
   }
   async applyClientSignature(method, params2) {
     try {
@@ -16462,7 +16622,7 @@ var RpcPipeline = class {
       const mode = method === "message.history" ? "history" : params2.window_mode === "tail" ? "tail" : "forward";
       const cursor = mode === "history" ? `before=${String(params2.before_seq)}` : `after=${String(params2.after_seq ?? 0)}`;
       const limit = mode === "forward" ? Number(params2.limit ?? 50) || 50 : params2.limit;
-      return `p2p:${client._aid}|mode=${mode}|cursor=${cursor}|force=${String(Boolean(params2.force))}|limit=${String(limit)}`;
+      return `p2p:${client._aid}|mode=${mode}|cursor=${cursor}|volatile=${String(params2.after_volatile_cursor ?? "")}|force=${String(Boolean(params2.force))}|limit=${String(limit)}`;
     }
     if (method === "group.pull" || method === "group.v2.pull" || method === "group.history") {
       const gid = String(params2.group_id ?? params2.group_aid ?? "").trim();
@@ -17003,6 +17163,9 @@ var RpcPipeline = class {
         this.postprocessGroupPull(params2, next);
       }
     }
+    if ((method === "message.pull" || method === "group.pull") && isJsonObject(next) && Array.isArray(next.messages)) {
+      next.messages = next.messages.map((message) => isJsonObject(message) && client._delivery ? client._delivery.stripInternalSenderDeviceFields(message) : message);
+    }
     if (!options.skipGroupState) {
       next = await client._groupState.postprocessResult(method, params2, next);
     }
@@ -17683,721 +17846,1335 @@ var StorageLowLevel = class {
   }
 };
 
-// src/group-fs.ts
-var WINDOWS_DRIVE_RE = /^[A-Za-z]:[\\/]/;
-var GROUP_REF_RE = /^[^:/\\][^:]*:\//;
-var LOCAL_PREFIX = "local:";
-function isExplicitLocalPath(value) {
-  return String(value || "").trim().toLowerCase().startsWith(LOCAL_PREFIX);
+// src/storage/types.ts
+function text(value, fallback = "") {
+  if (value === null || value === void 0) return fallback;
+  return String(value);
 }
-function stripLocalPathPrefix(value) {
-  const text3 = String(value || "").trim();
-  return text3.toLowerCase().startsWith(LOCAL_PREFIX) ? text3.slice(LOCAL_PREFIX.length) : text3;
+function intValue(value, fallback = 0) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : fallback;
 }
-function isGroupRemoteCopyPath(value, ...groupHints) {
-  if (isExplicitLocalPath(value)) return false;
-  return isGroupRemotePath(value) || groupHints.some(Boolean);
+function boolValue(value, fallback = false) {
+  if (value === null || value === void 0) return fallback;
+  return Boolean(value);
 }
-function isGroupRemotePath(value) {
-  const text3 = String(value || "").trim();
-  if (!text3) return false;
-  if (isExplicitLocalPath(text3)) return false;
-  if (WINDOWS_DRIVE_RE.test(text3)) return false;
-  if (text3.startsWith("http://") || text3.startsWith("https://")) return true;
-  return GROUP_REF_RE.test(text3);
+function mountSourceFromRaw(raw) {
+  const explicit = text(raw.mount_source);
+  if (explicit) return explicit;
+  const sourceAid = text(raw.source_aid);
+  if (!sourceAid) return "";
+  return `${sourceAid}:${keyToPath(raw.source_path)}`;
 }
-function stripNil(params2) {
-  const out = {};
-  for (const [key, value] of Object.entries(params2 ?? {})) {
-    if (value !== void 0 && value !== null) out[key] = value;
+function normalizePath(path) {
+  let raw = String(path || "/").replace(/\\/g, "/").trim();
+  if (!raw.startsWith("/")) raw = `/${raw}`;
+  raw = raw.replace(/\/+/g, "/");
+  const parts = [];
+  for (const part of raw.split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
   }
-  return out;
+  return parts.length ? `/${parts.join("/")}` : "/";
 }
-async function loadSigningAID(store, signAs) {
-  const loaded = store.load ? await store.load(signAs) : store.loadAsync ? await store.loadAsync(signAs) : null;
-  if (!loaded?.ok || !loaded.data?.aid) {
-    throw new Error(loaded?.error?.message || `signer identity not found: ${signAs}`);
-  }
-  if (!loaded.data.aid.privateKeyPem) {
-    throw new Error(`signer identity missing private key: ${signAs}`);
-  }
-  return loaded.data.aid;
+function pathToKey(path) {
+  const normalized = normalizePath(path);
+  return normalized === "/" ? "" : normalized.slice(1);
 }
-function text(value) {
-  return value === void 0 || value === null ? "" : String(value).trim();
+function keyToPath(key) {
+  return normalizePath(text(key));
 }
-function accessTokenFromClient(client) {
-  const authClient = client;
-  if (typeof authClient.getAccessToken === "function") {
-    const token = text(authClient.getAccessToken());
-    if (token) return token;
-  }
-  const directToken = text(authClient.accessToken ?? authClient.access_token);
-  if (directToken) return directToken;
-  const identityToken = text(authClient._identity?.access_token);
-  if (identityToken) return identityToken;
-  return text(authClient._sessionParams?.access_token);
+function nameFromPath(path) {
+  const cleaned = normalizePath(path).replace(/\/+$/g, "");
+  if (!cleaned || cleaned === "/") return "/";
+  return cleaned.split("/").pop() || "/";
 }
-function bearerHeaders(client) {
-  const token = accessTokenFromClient(client);
-  return token ? { Authorization: `Bearer ${token}` } : void 0;
+function baseNode(raw, type, path) {
+  return {
+    type,
+    path,
+    name: text(raw.name) || nameFromPath(path),
+    owner: text(raw.owner ?? raw.owner_aid),
+    bucket: text(raw.bucket, "default") || "default",
+    size: intValue(raw.size ?? raw.size_bytes),
+    mtime: intValue(raw.mtime ?? raw.updated_at),
+    contentType: text(raw.content_type),
+    version: intValue(raw.version),
+    mode: text(raw.mode),
+    isPublic: !boolValue(raw.is_private, true),
+    objectId: text(raw.object_id),
+    folderId: text(raw.folder_id),
+    target: text(raw.target),
+    mountSource: mountSourceFromRaw(raw),
+    metadata: raw.metadata && typeof raw.metadata === "object" && !Array.isArray(raw.metadata) ? raw.metadata : {}
+  };
 }
-function toExactArrayBuffer(bytes) {
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+function nodeFromAny(input) {
+  const raw = input && typeof input === "object" ? input : {};
+  const nodeType = text(raw.type ?? raw.node_type).toLowerCase();
+  if (["folder", "dir", "directory"].includes(nodeType)) return baseNode(raw, "dir", keyToPath(raw.path));
+  if (["symlink", "link"].includes(nodeType)) return baseNode(raw, "symlink", keyToPath(raw.path));
+  if (nodeType === "mount") return baseNode(raw, "mount", keyToPath(raw.path));
+  const path = keyToPath(raw.path ?? raw.object_key);
+  return {
+    ...baseNode(raw, "file", path),
+    sha256: text(raw.sha256),
+    etag: text(raw.etag)
+  };
+}
+function usageFromAny(input, ownerFallback = "") {
+  const raw = input && typeof input === "object" ? input : {};
+  const quota = intValue(raw.quota_bytes ?? raw.quota_total_bytes);
+  const used = intValue(raw.used_bytes ?? raw.quota_used_bytes);
+  return {
+    owner: text(raw.owner ?? raw.owner_aid, ownerFallback),
+    quotaBytes: quota,
+    usedBytes: used,
+    availBytes: quota ? Math.max(0, quota - used) : 0,
+    objectCount: intValue(raw.object_count)
+  };
 }
+function unmountFromAny(input, fallback) {
+  const raw = input && typeof input === "object" ? input : {};
+  const path = keyToPath(raw.mount_path ?? raw.path ?? fallback.mountPath);
+  return {
+    unmounted: boolValue(raw.unmounted),
+    owner: text(raw.owner ?? raw.owner_aid, fallback.owner ?? ""),
+    bucket: text(raw.bucket, fallback.bucket ?? "default") || (fallback.bucket ?? "default"),
+    path,
+    mountPath: path
+  };
+}
+
+// src/storage/vfs.ts
 async function sha256Hex(data) {
+  const copy = new Uint8Array(data.byteLength);
+  copy.set(data);
   const subtle = globalThis.crypto?.subtle;
   if (!subtle?.digest) throw new StorageError("SHA-256 unavailable", "EUNSUPPORTED");
-  const digest = await subtle.digest("SHA-256", toExactArrayBuffer(data));
+  const digest = await subtle.digest("SHA-256", copy.buffer);
   return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function blobToBytes(blob) {
-  if (typeof blob.arrayBuffer === "function") {
-    return new Uint8Array(await blob.arrayBuffer());
-  }
-  if (typeof blob.stream === "function" && typeof Response !== "undefined") {
-    return new Uint8Array(await new Response(blob).arrayBuffer());
-  }
-  if (typeof FileReader !== "undefined") {
-    return await new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => resolve(new Uint8Array(reader.result));
-      reader.onerror = () => reject(reader.error ?? new StorageError("Blob read failed", "ESTORAGE"));
-      reader.readAsArrayBuffer(blob);
-    });
-  }
-  if (typeof blob.text === "function") {
-    return new TextEncoder().encode(await blob.text());
-  }
-  throw new StorageError("Blob reads are unavailable in this JavaScript runtime", "EUNSUPPORTED");
-}
-async function toBytes(source) {
-  if (typeof source === "string") return new TextEncoder().encode(source);
-  if (source instanceof Uint8Array) return source;
-  if (source instanceof ArrayBuffer) return new Uint8Array(source);
-  if (typeof Blob !== "undefined" && source instanceof Blob) {
-    return blobToBytes(source);
-  }
-  if (ArrayBuffer.isView(source)) {
-    return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-  }
-  throw new StorageError("unsupported group fs upload source", "EUNSUPPORTED");
+function toBytes(data) {
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  if (data instanceof Uint8Array) return data;
+  return new Uint8Array(data);
 }
-async function importNodeModule(specifier) {
-  if (typeof document !== "undefined") return null;
-  const getBuiltinModule = globalThis.process?.getBuiltinModule;
-  if (typeof getBuiltinModule === "function" && specifier.startsWith("node:")) {
+function contentTypeForPath(path) {
+  const ext = path.toLowerCase().split(/[?#]/, 1)[0].match(/\.[^./\\]+$/)?.[0] ?? "";
+  const known = {
+    ".txt": "text/plain",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".html": "text/html",
+    ".csv": "text/csv",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".pdf": "application/pdf"
+  };
+  return known[ext] ?? "application/octet-stream";
+}
+function contentTypeForData(data, path = "") {
+  const startsWith = (...bytes) => bytes.every((value, index) => data[index] === value);
+  if (startsWith(137, 80, 78, 71, 13, 10, 26, 10)) return "image/png";
+  if (startsWith(255, 216, 255)) return "image/jpeg";
+  if (startsWith(71, 73, 70, 56)) return "image/gif";
+  if (startsWith(66, 77)) return "image/bmp";
+  if (startsWith(37, 80, 68, 70, 45)) return "application/pdf";
+  if (startsWith(31, 139)) return "application/gzip";
+  if (startsWith(80, 75, 3, 4) || startsWith(80, 75, 5, 6) || startsWith(80, 75, 7, 8)) return "application/zip";
+  if (data.length >= 12 && startsWith(82, 73, 70, 70) && data[8] === 87 && data[9] === 69 && data[10] === 66 && data[11] === 80) return "image/webp";
+  if (data.length >= 12 && data[4] === 102 && data[5] === 116 && data[6] === 121 && data[7] === 112) return "video/mp4";
+  if (data.length === 0) return contentTypeForPath(path);
+  if (!data.some((value) => value < 9 || value > 13 && value < 32 || value === 127)) {
     try {
-      return getBuiltinModule(specifier.slice("node:".length));
+      const text3 = new TextDecoder("utf-8", { fatal: true }).decode(data);
+      const trimmed = text3.trimStart();
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          JSON.parse(text3);
+          return "application/json";
+        } catch {
+        }
+      }
+      if (/^<!doctype\s+html\b|^<html\b/i.test(trimmed)) return "text/html";
+      if (text3.trim()) return "text/plain";
     } catch {
     }
   }
-  try {
-    const requireFn = Function('return typeof require !== "undefined" ? require : undefined');
-    const requireModule = requireFn();
-    if (requireModule) return requireModule(specifier);
-  } catch {
-  }
-  try {
-    const dynamicImport = Function(`return import(${JSON.stringify(specifier)})`);
-    return await dynamicImport();
-  } catch {
-    return null;
-  }
+  return contentTypeForPath(path);
 }
-async function readLocalFile(path) {
-  const fs = await importNodeModule("node:fs/promises");
-  if (!fs?.readFile) throw new StorageError("local file reads are unavailable in this JavaScript runtime", "EUNSUPPORTED", path);
-  return new Uint8Array(await fs.readFile(path));
+function textValue(value) {
+  if (value === void 0 || value === null) return "";
+  return String(value).trim();
 }
-async function writeLocalFile(path, data, force) {
-  const fs = await importNodeModule("node:fs/promises");
-  const pathMod = await importNodeModule("node:path");
-  if (!fs?.writeFile || !pathMod?.dirname) return false;
-  await fs.mkdir(pathMod.dirname(path), { recursive: true });
-  try {
-    await fs.writeFile(path, data, force ? void 0 : { flag: "wx" });
-    return true;
-  } catch (exc) {
-    const code = text(exc.code);
-    if (code === "EEXIST") throw new StorageExistsError(`local path already exists: ${path}`, "EEXIST", path);
-    throw exc;
-  }
+function aidIssuer(aid) {
+  const value = textValue(aid).replace(/^\.+|\.+$/g, "").toLowerCase();
+  const separator = value.indexOf(".");
+  return separator >= 0 ? value.slice(separator + 1).replace(/^\.+|\.+$/g, "") : "";
 }
-async function localFileStatus(path) {
-  const fs = await importNodeModule("node:fs/promises");
-  if (!fs?.stat) return "unavailable";
-  try {
-    const info = await fs.stat(path);
-    return info.isDirectory() ? "dir" : "file";
-  } catch (exc) {
-    const code = text(exc.code);
-    if (code === "ENOENT") return "missing";
-    throw exc;
-  }
+function accessTokenFromClient(client) {
+  const auth = client;
+  return textValue(
+    auth.accessToken ?? auth.access_token ?? auth._identity?.access_token ?? auth._sessionParams?.access_token ?? auth._session_params?.access_token
+  );
 }
-function guessContentType(path) {
-  const lower = path.toLowerCase();
-  if (lower.endsWith(".md")) return "text/markdown";
-  if (lower.endsWith(".txt")) return "text/plain";
-  if (lower.endsWith(".json")) return "application/json";
-  if (lower.endsWith(".html") || lower.endsWith(".htm")) return "text/html";
-  if (lower.endsWith(".png")) return "image/png";
-  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
-  return "application/octet-stream";
+function isInlineFallbackError(error) {
+  const code = String(error.code).toUpperCase();
+  if (["EINLINE", "EINLINE_LIMIT", "ERR_INLINE_LIMIT", "INLINE_LIMIT", "-32033"].includes(code)) return true;
+  return error.code === -32602 && error.message.toLowerCase().includes("inline");
 }
-function downloadTarget(dst) {
-  if (typeof dst === "string") {
-    if (dst === "blob:") return { mode: "blob" };
-    if (dst === "bytes:") return { mode: "bytes" };
-    return { mode: "local", localPath: stripLocalPathPrefix(dst) };
+function parsePathLike(input, fallbackOwner) {
+  if (typeof input !== "string") {
+    return { owner: input.owner ?? fallbackOwner ?? null, path: input.path };
   }
-  const mode = dst.type === "blob" ? "blob" : dst.type === "bytes" ? "bytes" : dst.path || dst.localPath ? "local" : "bytes";
-  const localPath = dst.path ?? dst.localPath;
-  return { mode, localPath: localPath ? stripLocalPathPrefix(localPath) : localPath };
+  const match = input.match(/^([^:]+):(\/.*)$/);
+  if (match) {
+    return { owner: match[1], path: match[2] };
+  }
+  return { owner: fallbackOwner ?? null, path: input };
 }
-var GroupFSVFS = class {
+var StorageVFS = class {
   constructor(client, options = {}) {
     __publicField(this, "lowlevel");
+    __publicField(this, "useFsRpc");
     __publicField(this, "client");
     this.client = client;
     this.lowlevel = options.lowlevel ?? new StorageLowLevel(client);
+    this.useFsRpc = options.useFsRpc ?? true;
   }
-  async call(method, params2, path = "") {
+  get defaultOwner() {
+    return this.client.aid ?? null;
+  }
+  owner(owner) {
+    return owner || this.defaultOwner;
+  }
+  downloadUrlAndHeaders(ticket, owner) {
+    const url = textValue(ticket.logical_url ?? ticket.download_url ?? ticket.url);
+    const currentAid = textValue(this.defaultOwner);
+    const targetAid = textValue(ticket.owner_aid ?? owner);
+    const currentIssuer = aidIssuer(currentAid);
+    const targetIssuer = aidIssuer(targetAid);
+    const sameIssuer = Boolean(currentAid && targetAid && (currentAid.toLowerCase() === targetAid.toLowerCase() || currentIssuer && targetIssuer && currentIssuer === targetIssuer));
+    const token = sameIssuer ? accessTokenFromClient(this.client) : "";
+    return { url, headers: token ? { Authorization: `Bearer ${token}` } : void 0 };
+  }
+  async writeBytes(path, input, options = {}) {
+    const data = toBytes(input);
+    const contentType = options.contentType?.trim() || contentTypeForData(data, path);
+    const owner = this.owner(options.owner);
+    const bucket = options.bucket ?? "default";
+    const objectKey = pathToKey(path);
+    const sha2566 = await sha256Hex(data);
+    const overwrite = options.overwrite ?? false;
     try {
-      return await this.client.call(method, await this.prepareParams(params2));
+      const check = await this.lowlevel.checkUpload({ owner, bucket, objectKey, size: data.length, sha256: sha2566 });
+      if (check.within_limit === false) {
+        throw new StorageError(`file size exceeds max_file_size_bytes: ${data.length}`, "E2BIG", path, check);
+      }
+      if (check.target_exists && !overwrite && options.expectedVersion === void 0) {
+        throw new StorageExistsError(`remote path already exists: ${path}`, "EEXIST", path, check.target);
+      }
+      if (check.dedup_hit || check.skip_upload) {
+        const completed = await this.lowlevel.completeUpload({
+          owner,
+          bucket,
+          objectKey,
+          size: data.length,
+          sha256: sha2566,
+          contentType,
+          metadata: options.metadata,
+          isPublic: options.public ?? false,
+          expectedVersion: options.expectedVersion,
+          skipBlob: true,
+          overwrite
+        });
+        return nodeFromAny(completed);
+      }
+      if (check.inline === true) {
+        return nodeFromAny(await this.lowlevel.putObject({
+          owner,
+          bucket,
+          objectKey,
+          content: data,
+          contentType,
+          metadata: options.metadata,
+          isPublic: options.public ?? false,
+          expectedVersion: options.expectedVersion,
+          overwrite
+        }));
+      }
+      const session = await this.lowlevel.createUploadSession({
+        owner,
+        bucket,
+        objectKey,
+        size: data.length,
+        contentType,
+        expectedVersion: options.expectedVersion,
+        overwrite
+      });
+      const uploadUrl = String(session.upload_url ?? "");
+      if (!uploadUrl) throw new StorageError(`create_upload_session did not return upload_url`, "ESTORAGE", path);
+      const headers = {};
+      if (session.headers && typeof session.headers === "object") {
+        for (const [key, value] of Object.entries(session.headers)) {
+          if (value !== void 0 && value !== null) headers[key] = String(value);
+        }
+      }
+      for (const key of Object.keys(headers)) {
+        if (key.toLowerCase() === "content-type") delete headers[key];
+      }
+      headers["Content-Type"] = contentType;
+      await this.lowlevel.httpPut(uploadUrl, data, headers);
+      return nodeFromAny(await this.lowlevel.completeUpload({
+        owner,
+        bucket,
+        objectKey,
+        sessionId: String(session.session_id ?? ""),
+        size: data.length,
+        sha256: sha2566,
+        contentType,
+        metadata: options.metadata,
+        isPublic: options.public ?? false,
+        expectedVersion: options.expectedVersion,
+        overwrite
+      }));
     } catch (exc) {
       throw mapStorageError(exc, path);
     }
   }
-  async prepareParams(params2) {
-    const next = { ...params2 ?? {} };
-    const signAs = text(next.sign_as ?? next.signAs);
-    const aidStore = next.aid_store ?? next.aidStore;
-    delete next.sign_as;
-    delete next.signAs;
-    delete next.aid_store;
-    delete next.aidStore;
-    if (signAs) {
-      const currentAid = text(this.client.aid ?? this.client._aid);
-      if (currentAid.toLowerCase() !== signAs.toLowerCase()) {
-        if (!aidStore) {
-          throw new Error(`group.fs operation requires aidStore to sign as ${signAs}`);
-        }
-        next._client_signature_identity = await loadSigningAID(aidStore, signAs);
-      }
+  async readBytes(path, options = {}) {
+    return (await this.readBytesWithMetadata(path, options)).data;
+  }
+  async readBytesWithMetadata(path, options = {}) {
+    const owner = this.owner(options.owner);
+    const bucket = options.bucket ?? "default";
+    const objectKey = pathToKey(path);
+    try {
+      const result = await this.lowlevel.getObject({ owner, bucket, objectKey, token: options.token, offset: options.offset, limit: options.limit });
+      return {
+        data: base64ToBytes(String(result.content ?? "")),
+        sha256: textValue(result.sha256)
+      };
+    } catch (exc) {
+      const mapped = mapStorageError(exc, path);
+      if (options.offset !== void 0 || options.limit !== void 0) throw mapped;
+      if (!isInlineFallbackError(mapped)) throw mapped;
     }
-    return stripNil(next);
+    const ticket = await this.lowlevel.createDownloadTicket({ owner, bucket, objectKey, token: options.token });
+    const { url: downloadUrl, headers } = this.downloadUrlAndHeaders(ticket, owner);
+    if (!downloadUrl) throw new StorageError(`create_download_ticket did not return download_url`, "ESTORAGE", path);
+    return {
+      data: headers ? await this.lowlevel.httpGet(downloadUrl, headers) : await this.lowlevel.httpGet(downloadUrl),
+      sha256: textValue(ticket.sha256)
+    };
   }
-  ls(path, options = {}) {
-    return this.call("group.fs.ls", { path, ...options }, path);
+  async downloadFile(path, options = {}) {
+    const { data, sha256: expectedSha } = await this.readBytesWithMetadata(path, options);
+    const actualSha = await sha256Hex(data);
+    const expected = expectedSha.toLowerCase();
+    const verified = Boolean(expected) && actualSha.toLowerCase() === expected;
+    if (!verified && expected && (options.verifyHash ?? true)) {
+      throw new StorageError(
+        `hash mismatch: expected=${expected} actual=${actualSha.toLowerCase()}`,
+        "EHASH",
+        path
+      );
+    }
+    return {
+      path,
+      size: data.length,
+      sha256: expectedSha || actualSha,
+      verified,
+      data
+    };
   }
-  find(path, options = {}) {
-    return this.call("group.fs.find", { path, ...options }, path);
+  async list(path, options = {}) {
+    if (options.recursive) {
+      const result = [];
+      const pending = [path];
+      while (pending.length) {
+        const current = pending.shift();
+        const children = await this.list(current, { ...options, recursive: false });
+        result.push(...children);
+        pending.push(...children.filter((node) => node.type === "dir").map((node) => node.path));
+      }
+      return result;
+    }
+    const owner = this.owner(options.owner);
+    const bucket = options.bucket ?? "default";
+    const key = pathToKey(path);
+    const raw = await this.lowlevel.fsList({
+      owner,
+      bucket,
+      path: key,
+      page: options.page,
+      size: options.size,
+      marker: options.marker,
+      token: options.token
+    });
+    const items = raw.nodes ?? raw.items ?? [];
+    return items.map((item) => nodeFromAny(item));
   }
-  stat(path, options = {}) {
-    return this.call("group.fs.stat", { path, ...options }, path);
+  async stat(path, options = {}) {
+    const owner = this.owner(options.owner);
+    const raw = await this.lowlevel.fsStat({ owner, bucket: options.bucket ?? "default", path: pathToKey(path), token: options.token });
+    return nodeFromAny(raw);
   }
-  lstat(path, options = {}) {
-    return this.call("group.fs.lstat", { path, ...options }, path);
+  async lstat(path, options = {}) {
+    const owner = this.owner(options.owner);
+    const raw = await this.lowlevel.fsLstat({ owner, bucket: options.bucket ?? "default", path: pathToKey(path), token: options.token });
+    return nodeFromAny(raw);
   }
-  mkdir(path, options = {}) {
-    return this.call("group.fs.mkdir", { path, parents: options.parents ?? false, ...options }, path);
+  async mkdir(path, options = {}) {
+    const raw = await this.lowlevel.fsMkdir({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), parents: options.parents });
+    return nodeFromAny(raw.node ?? raw);
   }
-  setAcl(path, options = {}) {
-    const grantee = options.grantee_aid ?? options.granteeAid ?? "role:admin";
-    const params2 = { ...options, path, grantee_aid: grantee, perms: options.perms ?? "rwx" };
-    delete params2.granteeAid;
-    return this.call("group.fs.set_acl", params2, path);
+  async touch(path, options = {}) {
+    const raw = await this.lowlevel.fsTouch({
+      owner: this.owner(options.owner),
+      bucket: options.bucket ?? "default",
+      path: pathToKey(path),
+      parents: options.parents,
+      noCreate: options.noCreate,
+      mtime: options.mtime,
+      followSymlinks: options.followSymlinks
+    });
+    return nodeFromAny(raw.node ?? raw);
   }
-  removeAcl(path, options = {}) {
-    const grantee = options.grantee_aid ?? options.granteeAid ?? "role:admin";
-    const params2 = { ...options, path, grantee_aid: grantee };
-    delete params2.granteeAid;
-    return this.call("group.fs.remove_acl", params2, path);
+  async remove(path, options = {}) {
+    const raw = await this.lowlevel.fsRemove({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), recursive: options.recursive });
+    return { path, removedCount: Number(raw.removed_count ?? raw.deleted_count ?? 0) };
   }
-  getAcl(path, options = {}) {
-    return this.call("group.fs.get_acl", { path, ...options }, path);
+  async rename(src, dst, options = {}) {
+    const raw = await this.lowlevel.fsRename({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", src: pathToKey(src), dst: pathToKey(dst), overwrite: options.overwrite, expectedVersion: options.expectedVersion });
+    return nodeFromAny(raw.node ?? raw);
   }
-  listAcl(path, options = {}) {
-    return this.call("group.fs.list_acl", { path, ...options }, path);
+  async copy(src, dst, options = {}) {
+    const raw = await this.lowlevel.fsCopy({
+      owner: this.owner(options.owner),
+      bucket: options.bucket ?? "default",
+      src: pathToKey(src),
+      dst: pathToKey(dst),
+      overwrite: options.overwrite,
+      followSymlinks: options.followSymlinks,
+      recursive: options.recursive,
+      dstOwner: options.dstOwner,
+      dstBucket: options.dstBucket
+    });
+    return nodeFromAny(raw.node ?? raw);
   }
-  rm(path, options = {}) {
-    return this.call("group.fs.rm", {
-      path,
-      recursive: options.recursive ?? false,
-      force: options.force ?? false,
-      ...options
-    }, path);
+  async find(path, options = {}) {
+    const raw = await this.lowlevel.fsFind({
+      owner: this.owner(options.owner),
+      bucket: options.bucket ?? "default",
+      path: pathToKey(path),
+      name: options.name,
+      nodeType: options.nodeType,
+      size: options.size,
+      mtime: options.mtime,
+      page: options.page,
+      pageSize: options.pageSize,
+      token: options.token
+    });
+    const items = raw.nodes ?? raw.items ?? [];
+    return items.map((item) => nodeFromAny(item));
   }
-  async cp(src, dst, options = {}) {
-    const groupRef = options.group_aid ?? options.groupAid ?? options.group_id ?? options.groupId;
-    const srcGroupRef = options.src_group_aid ?? options.srcGroupAid ?? options.src_group_id ?? options.srcGroupId;
-    const dstGroupRef = options.dst_group_aid ?? options.dstGroupAid ?? options.dst_group_id ?? options.dstGroupId;
-    const srcRemote = typeof src === "string" && isGroupRemoteCopyPath(src, srcGroupRef, groupRef);
-    const dstRemote = typeof dst === "string" && isGroupRemoteCopyPath(dst, dstGroupRef, groupRef);
-    if (srcRemote && dstRemote) return this.copyRemoteToRemote(src, dst, options);
-    if (!srcRemote && dstRemote) return this.uploadToGroup(src, dst, options);
-    if (srcRemote && !dstRemote) return this.downloadFromGroup(src, dst, options);
-    throw new StorageError("local-to-local copy is not handled by group.fs", "EINVAL", typeof src === "string" ? src : "");
+  async df(options = {}) {
+    const owner = this.owner(options.owner);
+    const raw = await this.lowlevel.fsDf({ owner, bucket: options.bucket ?? "default" });
+    return usageFromAny(raw, owner ?? void 0);
   }
-  async mv(src, dst, options = {}) {
-    const groupRef = options.group_aid ?? options.groupAid ?? options.group_id ?? options.groupId;
-    const srcGroupRef = options.src_group_aid ?? options.srcGroupAid ?? options.src_group_id ?? options.srcGroupId;
-    const dstGroupRef = options.dst_group_aid ?? options.dstGroupAid ?? options.dst_group_id ?? options.dstGroupId;
-    if (!isGroupRemoteCopyPath(src, srcGroupRef, groupRef) || !isGroupRemoteCopyPath(dst, dstGroupRef, groupRef)) {
-      throw new StorageError("group.fs.mv only supports group remote paths", "EINVAL", src);
+  async du(path, options = {}) {
+    const nodes = await this.find(path, {
+      owner: options.owner,
+      bucket: options.bucket,
+      page: 1,
+      pageSize: options.pageSize ?? 1e3,
+      token: options.token
+    });
+    const rootParts = pathToKey(path).split("/").filter(Boolean);
+    let sizeBytes = 0;
+    let fileCount = 0;
+    let dirCount = 0;
+    let symlinkCount = 0;
+    let truncated = false;
+    for (const node of nodes) {
+      const nodeParts = pathToKey(node.path).split("/").filter(Boolean);
+      const depth = Math.max(0, nodeParts.length - rootParts.length);
+      if (options.maxDepth !== void 0 && depth > options.maxDepth) {
+        truncated = true;
+        continue;
+      }
+      if (node.type === "file") {
+        fileCount += 1;
+        sizeBytes += node.size;
+      } else if (node.type === "dir") {
+        dirCount += 1;
+      } else if (node.type === "symlink") {
+        symlinkCount += 1;
+      }
     }
-    const params2 = this.remoteCopyParams(src, dst, options);
-    return this.call("group.fs.mv", params2, src);
+    return {
+      path,
+      sizeBytes,
+      fileCount,
+      dirCount,
+      symlinkCount,
+      maxDepth: options.maxDepth,
+      truncated
+    };
   }
-  df(pathOrGroup, options = {}) {
-    const params2 = { ...options };
-    if (pathOrGroup !== void 0 && pathOrGroup !== null) params2.path = pathOrGroup;
-    return this.call("group.fs.df", params2, pathOrGroup ?? "");
+  async mount(source, mountPath, options = {}) {
+    const owner = this.owner(options.owner);
+    const mountRef = parsePathLike(mountPath, owner);
+    const sourceRef = parsePathLike(source, options.sourceOwner ?? this.defaultOwner);
+    const raw = await this.lowlevel.fsMount({
+      owner: mountRef.owner,
+      bucket: options.bucket ?? "default",
+      mountPath: pathToKey(mountRef.path),
+      sourceAid: String(sourceRef.owner ?? ""),
+      sourceBucket: options.sourceBucket,
+      sourcePath: pathToKey(sourceRef.path),
+      readonly: options.readonly,
+      expiresAt: options.expiresAt ?? options.expires,
+      requireApproval: options.requireApproval
+    });
+    return nodeFromAny(raw.node ?? raw.mount ?? raw);
   }
-  mount(path, options = {}) {
-    return this.call("group.fs.mount", { path, ...options }, path);
+  async mountVolume(volumeId, mountPath, options = {}) {
+    const owner = this.owner(options.owner);
+    const mountRef = parsePathLike(mountPath, owner);
+    const raw = await this.lowlevel.fsMount({
+      owner: mountRef.owner,
+      bucket: options.bucket ?? "default",
+      mountPath: pathToKey(mountRef.path),
+      readonly: options.readonly,
+      expiresAt: options.expiresAt ?? options.expires,
+      requireApproval: options.requireApproval,
+      volumeId
+    });
+    return nodeFromAny(raw.node ?? raw.mount ?? raw);
   }
-  umount(path, options = {}) {
-    return this.call("group.fs.umount", { path, ...options }, path);
+  approveMount(mountPath, options = {}) {
+    const owner = this.owner(options.owner);
+    const mountRef = parsePathLike(mountPath, owner);
+    return this.lowlevel.fsApprove({
+      owner: mountRef.owner,
+      bucket: options.bucket ?? "default",
+      mountPath: pathToKey(mountRef.path),
+      mountId: options.mountId,
+      requestId: options.requestId
+    });
   }
-  remoteCopyParams(src, dst, options) {
-    const params2 = { ...options, src, dst };
-    delete params2.contentType;
-    delete params2.content_type;
-    delete params2.metadata;
-    delete params2.expectedVersion;
-    delete params2.expected_version;
-    delete params2.parents;
-    delete params2.verifyHash;
-    delete params2.verify_hash;
-    delete params2.sourceType;
-    delete params2.source_type;
-    delete params2.localPath;
-    delete params2.local_path;
-    if (options.groupAid !== void 0) params2.group_aid = options.groupAid;
-    if (options.groupId !== void 0) params2.group_id = options.groupId;
-    if (options.srcGroupAid !== void 0) params2.src_group_aid = options.srcGroupAid;
-    if (options.srcGroupId !== void 0) params2.src_group_id = options.srcGroupId;
-    if (options.dstGroupAid !== void 0) params2.dst_group_aid = options.dstGroupAid;
-    if (options.dstGroupId !== void 0) params2.dst_group_id = options.dstGroupId;
-    if (options.followSymlinks !== void 0) params2.follow_symlinks = options.followSymlinks;
-    delete params2.groupAid;
-    delete params2.srcGroupAid;
-    delete params2.dstGroupAid;
-    delete params2.followSymlinks;
-    if (!options.force) delete params2.force;
-    if (!options.recursive) delete params2.recursive;
-    return stripNil(params2);
+  rejectMount(mountPath, options = {}) {
+    const owner = this.owner(options.owner);
+    const mountRef = parsePathLike(mountPath, owner);
+    return this.lowlevel.fsReject({
+      owner: mountRef.owner,
+      bucket: options.bucket ?? "default",
+      mountPath: pathToKey(mountRef.path),
+      mountId: options.mountId,
+      requestId: options.requestId
+    });
   }
-  copyRemoteToRemote(src, dst, options) {
-    return this.call("group.fs.cp", this.remoteCopyParams(src, dst, options), src);
+  async unmount(mountPath, options = {}) {
+    const owner = this.owner(options.owner);
+    const mountRef = parsePathLike(mountPath, owner);
+    const raw = await this.lowlevel.fsUnmount({
+      owner: mountRef.owner,
+      bucket: options.bucket ?? "default",
+      mountPath: pathToKey(mountRef.path)
+    });
+    return unmountFromAny(raw, {
+      owner: mountRef.owner,
+      bucket: options.bucket ?? "default",
+      mountPath: pathToKey(mountRef.path)
+    });
   }
-  async sourceBytes(src, options) {
-    if (typeof src === "string") {
-      const sourceType = text(options.source_type ?? options.sourceType);
-      if (isExplicitLocalPath(src) || sourceType === "path" || options.localPath === true || options.local_path === true) {
-        const localPath = stripLocalPathPrefix(src);
-        return { data: await readLocalFile(localPath), contentType: guessContentType(localPath) };
-      }
-      return { data: await toBytes(src), contentType: "text/plain;charset=utf-8" };
-    }
-    const data = await toBytes(src);
-    const blobType = typeof Blob !== "undefined" && src instanceof Blob ? text(src.type) : "";
-    const fileName = text(src.name);
-    return { data, contentType: blobType || (fileName ? guessContentType(fileName) : "application/octet-stream") };
+  async symlink(target, linkPath, options = {}) {
+    const raw = await this.lowlevel.createSymlink({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(linkPath), target, overwrite: options.overwrite });
+    return nodeFromAny(raw.symlink ?? raw);
   }
-  async uploadToGroup(src, dst, options) {
-    const { data, contentType } = await this.sourceBytes(src, options);
-    const digest = await sha256Hex(data);
-    const groupAid = options.group_aid ?? options.groupAid ?? options.dst_group_aid ?? options.dstGroupAid;
-    const groupId = options.group_id ?? options.groupId ?? options.dst_group_id ?? options.dstGroupId;
-    const baseParams = stripNil({
-      ...options,
-      path: dst,
-      group_aid: groupAid,
-      group_id: groupAid ? void 0 : groupId,
-      size_bytes: data.byteLength,
-      sha256: digest,
-      content_type: options.content_type ?? options.contentType ?? contentType,
-      force: options.force ?? false,
-      parents: options.parents ?? true,
-      metadata: options.metadata,
-      expected_version: options.expected_version ?? options.expectedVersion
+  async readlink(path, options = {}) {
+    const raw = await this.lowlevel.readlink({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path) });
+    return nodeFromAny(raw.symlink ?? raw);
+  }
+  async repoint(path, newTarget, options = {}) {
+    const raw = await this.lowlevel.atomicRepoint({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), newTarget, expectedVersion: options.expectedVersion });
+    if (raw.ok === false) throw new StorageConflictError("symlink version conflict", "ECONFLICT", path, raw);
+    return nodeFromAny(raw.symlink ?? raw);
+  }
+  async renameSymlink(src, dst, options = {}) {
+    const raw = await this.lowlevel.renameSymlink({
+      owner: this.owner(options.owner),
+      bucket: options.bucket ?? "default",
+      path: pathToKey(src),
+      newPath: pathToKey(dst),
+      overwrite: options.overwrite,
+      expectedVersion: options.expectedVersion
     });
-    delete baseParams.groupId;
-    delete baseParams.groupAid;
-    delete baseParams.dstGroupId;
-    delete baseParams.dstGroupAid;
-    delete baseParams.dst_group_aid;
-    delete baseParams.dst_group_id;
-    delete baseParams.srcGroupId;
-    delete baseParams.srcGroupAid;
-    delete baseParams.src_group_aid;
-    delete baseParams.src_group_id;
-    delete baseParams.contentType;
-    delete baseParams.expectedVersion;
-    delete baseParams.verifyHash;
-    delete baseParams.verify_hash;
-    delete baseParams.recursive;
-    delete baseParams.followSymlinks;
-    delete baseParams.follow_symlinks;
-    delete baseParams.sourceType;
-    delete baseParams.source_type;
-    delete baseParams.localPath;
-    delete baseParams.local_path;
-    const check = await this.call("group.fs.check_upload", baseParams, dst);
-    if (check && typeof check === "object") {
-      const raw = check;
-      if (raw.within_limit === false) throw new StorageError("file size exceeds group fs upload limit", "E2BIG", dst, raw);
-      if (raw.target_exists && !options.force && options.expected_version === void 0 && options.expectedVersion === void 0) {
-        throw new StorageExistsError("group fs target already exists", "EEXIST", dst, raw.target);
-      }
-      if (raw.instant || raw.dedup_hit || raw.skip_upload) {
-        return this.call("group.fs.complete_upload", {
-          ...baseParams,
-          skip_blob: true,
-          session_id: raw.session_id
-        }, dst);
-      }
-    }
-    const session = await this.call("group.fs.create_upload_session", baseParams, dst);
-    if (!session || typeof session !== "object") {
-      throw new StorageError(`group.fs.create_upload_session returned invalid response`, "ESTORAGE", dst, session);
-    }
-    const rawSession = session;
-    const uploadUrl = text(rawSession.upload_url ?? rawSession.url);
-    if (!uploadUrl) throw new StorageError("group.fs.create_upload_session did not return upload_url", "ESTORAGE", dst, session);
-    const headers = {};
-    if (rawSession.headers && typeof rawSession.headers === "object" && !Array.isArray(rawSession.headers)) {
-      for (const [key, value] of Object.entries(rawSession.headers)) {
-        if (value !== void 0 && value !== null) headers[key] = String(value);
-      }
-    }
-    if (!Object.keys(headers).some((key) => key.toLowerCase() === "content-type")) {
-      headers["Content-Type"] = text(baseParams.content_type) || "application/octet-stream";
-    }
-    await this.lowlevel.httpPut(uploadUrl, data, headers);
-    return this.call("group.fs.complete_upload", {
-      ...baseParams,
-      session_id: rawSession.session_id ?? rawSession.id
-    }, dst);
+    if (raw.ok === false) throw new StorageConflictError("symlink version conflict", "ECONFLICT", src, raw);
+    return nodeFromAny(raw.symlink ?? raw);
   }
-  async downloadFromGroup(src, dst, options) {
-    const target = downloadTarget(dst);
-    if (target.mode === "local" && target.localPath) {
-      const status = await localFileStatus(target.localPath);
-      if (status === "file" && !options.force) {
-        throw new StorageExistsError(`local path already exists: ${target.localPath}`, "EEXIST", target.localPath);
-      }
-    }
-    const groupAid = options.group_aid ?? options.groupAid ?? options.src_group_aid ?? options.srcGroupAid;
-    const groupId = options.group_id ?? options.groupId ?? options.src_group_id ?? options.srcGroupId;
-    const params2 = stripNil({
-      ...options,
-      path: src,
-      group_aid: groupAid,
-      group_id: groupAid ? void 0 : groupId
+  setAcl(path, options) {
+    return this.lowlevel.setAcl({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), granteeAid: options.granteeAid, perms: options.perms, expiresAt: options.expiresAt, maxUses: options.maxUses });
+  }
+  removeAcl(path, options) {
+    return this.lowlevel.removeAcl({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), granteeAid: options.granteeAid });
+  }
+  listAcl(path, options = {}) {
+    return this.lowlevel.listAcl({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path) });
+  }
+  async setVisibility(path, options) {
+    const raw = await this.lowlevel.setVisibility({
+      owner: this.owner(options.owner),
+      bucket: options.bucket ?? "default",
+      path: pathToKey(path),
+      visibility: options.visibility,
+      allowRoles: options.allowRoles
     });
-    delete params2.groupId;
-    delete params2.groupAid;
-    delete params2.srcGroupId;
-    delete params2.srcGroupAid;
-    delete params2.src_group_aid;
-    delete params2.src_group_id;
-    delete params2.dstGroupId;
-    delete params2.dstGroupAid;
-    delete params2.dst_group_aid;
-    delete params2.dst_group_id;
-    delete params2.force;
-    delete params2.recursive;
-    delete params2.parents;
-    delete params2.contentType;
-    delete params2.content_type;
-    delete params2.expectedVersion;
-    delete params2.expected_version;
-    delete params2.verifyHash;
-    delete params2.verify_hash;
-    delete params2.sourceType;
-    delete params2.source_type;
-    delete params2.localPath;
-    delete params2.local_path;
-    const ticket = await this.call("group.fs.create_download_ticket", params2, src);
-    if (!ticket || typeof ticket !== "object") {
-      throw new StorageError("group.fs.create_download_ticket returned invalid response", "ESTORAGE", src, ticket);
-    }
-    const rawTicket = ticket;
-    const downloadUrl = text(rawTicket.download_url ?? rawTicket.url);
-    if (!downloadUrl) throw new StorageError("group.fs.create_download_ticket did not return download_url", "ESTORAGE", src, ticket);
-    const data = await this.lowlevel.httpGet(downloadUrl, bearerHeaders(this.client));
-    const expectedSha = text(rawTicket.sha256);
-    const verifyHash = options.verify_hash ?? options.verifyHash ?? true;
-    const verified = !verifyHash || !expectedSha || await sha256Hex(data) === expectedSha.toLowerCase();
-    if (verifyHash && !verified) {
-      throw new StorageConflictError("download hash verification failed", "ECONFLICT", src, ticket);
-    }
-    if (target.mode === "local" && target.localPath) {
-      const status = await localFileStatus(target.localPath);
-      if (status === "dir") {
-        throw new StorageError("directory download target is not supported in this JavaScript runtime", "EISDIR", target.localPath);
-      }
-      if (status === "file" && !options.force) {
-        throw new StorageExistsError(`local path already exists: ${target.localPath}`, "EEXIST", target.localPath);
-      }
-    }
-    const result = {
-      path: src,
-      localPath: target.localPath,
-      size: data.byteLength,
-      sha256: expectedSha,
-      verified,
-      data
-    };
-    if (target.mode === "blob" && typeof Blob !== "undefined") {
-      result.blob = new Blob([toExactArrayBuffer(data)], { type: text(rawTicket.content_type) || "application/octet-stream" });
-    }
-    if (target.mode === "local" && target.localPath) {
-      result.wroteLocalFile = await writeLocalFile(target.localPath, data, Boolean(options.force));
-    }
-    return result;
+    return nodeFromAny(raw.node ?? raw);
+  }
+  checkAccess(path, options = {}) {
+    return this.lowlevel.checkAccess({
+      owner: this.owner(options.owner),
+      bucket: options.bucket ?? "default",
+      path: pathToKey(path),
+      operation: options.operation ?? "read",
+      token: options.token,
+      followSymlinks: options.followSymlinks ?? true
+    });
+  }
+  issueToken(path, options = {}) {
+    return this.lowlevel.issueToken({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), expiresAt: options.expiresAt, maxReads: options.maxReads });
+  }
+  revokeToken(path, options) {
+    return this.lowlevel.revokeToken({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), token: options.token });
+  }
+  listTokens(path, options = {}) {
+    return this.lowlevel.listTokens({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path) });
+  }
+  async getUsage(options = {}) {
+    const owner = this.owner(options.owner);
+    const raw = await this.lowlevel.getQuota({ owner, bucket: options.bucket ?? "default" });
+    return usageFromAny(raw, owner ?? "");
   }
 };
 
-// src/v2/crypto/canonical.ts
-var encoder = new TextEncoder();
-var MAX_SAFE_JSON_INTEGER = 9007199254740991;
-function canonicalJson(obj) {
-  return encoder.encode(serialize(obj));
+// src/group-fs.ts
+var WINDOWS_DRIVE_RE = /^[A-Za-z]:[\\/]/;
+var GROUP_REF_RE = /^[^:/\\][^:]*:\//;
+var LOCAL_PREFIX = "local:";
+function isExplicitLocalPath(value) {
+  return String(value || "").trim().toLowerCase().startsWith(LOCAL_PREFIX);
 }
-function serialize(obj) {
-  if (obj === null) return "null";
-  if (obj === true) return "true";
-  if (obj === false) return "false";
-  if (typeof obj === "number") {
-    return serializeNumber(obj);
+function stripLocalPathPrefix(value) {
+  const text3 = String(value || "").trim();
+  return text3.toLowerCase().startsWith(LOCAL_PREFIX) ? text3.slice(LOCAL_PREFIX.length) : text3;
+}
+function isGroupRemoteCopyPath(value, ...groupHints) {
+  if (isExplicitLocalPath(value)) return false;
+  return isGroupRemotePath(value) || groupHints.some(Boolean);
+}
+function isGroupRemotePath(value) {
+  const text3 = String(value || "").trim();
+  if (!text3) return false;
+  if (isExplicitLocalPath(text3)) return false;
+  if (WINDOWS_DRIVE_RE.test(text3)) return false;
+  if (text3.startsWith("http://") || text3.startsWith("https://")) return true;
+  return GROUP_REF_RE.test(text3);
+}
+function stripNil(params2) {
+  const out = {};
+  for (const [key, value] of Object.entries(params2 ?? {})) {
+    if (value !== void 0 && value !== null) out[key] = value;
   }
-  if (typeof obj === "string") {
-    return serializeString(obj);
+  return out;
+}
+async function loadSigningAID(store, signAs) {
+  const loaded = store.load ? await store.load(signAs) : store.loadAsync ? await store.loadAsync(signAs) : null;
+  if (!loaded?.ok || !loaded.data?.aid) {
+    throw new Error(loaded?.error?.message || `signer identity not found: ${signAs}`);
   }
-  if (Array.isArray(obj)) {
-    return serializeArray(obj);
+  if (!loaded.data.aid.privateKeyPem) {
+    throw new Error(`signer identity missing private key: ${signAs}`);
   }
-  if (typeof obj === "object") {
-    return serializeObject(obj);
+  return loaded.data.aid;
+}
+function text2(value) {
+  return value === void 0 || value === null ? "" : String(value).trim();
+}
+function accessTokenFromClient2(client) {
+  const authClient = client;
+  if (typeof authClient.getAccessToken === "function") {
+    const token = text2(authClient.getAccessToken());
+    if (token) return token;
   }
-  throw new TypeError(`canonicalJson: unsupported type ${typeof obj}`);
+  const directToken = text2(authClient.accessToken ?? authClient.access_token);
+  if (directToken) return directToken;
+  const identityToken = text2(authClient._identity?.access_token);
+  if (identityToken) return identityToken;
+  return text2(authClient._sessionParams?.access_token);
 }
-function serializeNumber(n) {
-  if (!isFinite(n)) {
-    throw new RangeError("canonicalJson: Infinity and NaN not allowed");
+function bearerHeaders(client) {
+  const token = accessTokenFromClient2(client);
+  return token ? { Authorization: `Bearer ${token}` } : void 0;
+}
+function toExactArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+async function sha256Hex2(data) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle?.digest) throw new StorageError("SHA-256 unavailable", "EUNSUPPORTED");
+  const digest = await subtle.digest("SHA-256", toExactArrayBuffer(data));
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function blobToBytes(blob) {
+  if (typeof blob.arrayBuffer === "function") {
+    return new Uint8Array(await blob.arrayBuffer());
   }
-  if (Object.is(n, -0)) return "0";
-  if (Number.isInteger(n)) {
-    if (Math.abs(n) > MAX_SAFE_JSON_INTEGER) {
-      throw new RangeError(`canonicalJson: integer outside safe range ${n}`);
-    }
-    return String(n);
+  if (typeof blob.stream === "function" && typeof Response !== "undefined") {
+    return new Uint8Array(await new Response(blob).arrayBuffer());
   }
-  return expandExponent(String(n));
-}
-function expandExponent(s) {
-  if (!/[eE]/.test(s)) return s;
-  const match = /^(-?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(s);
-  if (!match) {
-    throw new TypeError(`canonicalJson: invalid number ${s}`);
+  if (typeof FileReader !== "undefined") {
+    return await new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(new Uint8Array(reader.result));
+      reader.onerror = () => reject(reader.error ?? new StorageError("Blob read failed", "ESTORAGE"));
+      reader.readAsArrayBuffer(blob);
+    });
   }
-  const sign = match[1] ?? "";
-  const intPart = match[2] ?? "";
-  const fracPart = match[3] ?? "";
-  const exp = Number(match[4]);
-  const digits = intPart + fracPart;
-  const point = intPart.length + exp;
-  if (point <= 0) {
-    return `${sign}0.${"0".repeat(-point)}${digits}`;
+  if (typeof blob.text === "function") {
+    return new TextEncoder().encode(await blob.text());
   }
-  if (point >= digits.length) {
-    return `${sign}${digits}${"0".repeat(point - digits.length)}`;
+  throw new StorageError("Blob reads are unavailable in this JavaScript runtime", "EUNSUPPORTED");
+}
+async function toBytes2(source) {
+  if (typeof source === "string") return new TextEncoder().encode(source);
+  if (source instanceof Uint8Array) return source;
+  if (source instanceof ArrayBuffer) return new Uint8Array(source);
+  if (typeof Blob !== "undefined" && source instanceof Blob) {
+    return blobToBytes(source);
   }
-  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+  if (ArrayBuffer.isView(source)) {
+    return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+  }
+  throw new StorageError("unsupported group fs upload source", "EUNSUPPORTED");
 }
-function serializeString(s) {
-  let result = '"';
-  for (let i = 0; i < s.length; i++) {
-    const ch = s[i];
-    const code = s.charCodeAt(i);
-    if (ch === '"') {
-      result += '\\"';
-    } else if (ch === "\\") {
-      result += "\\\\";
-    } else if (ch === "\b") {
-      result += "\\b";
-    } else if (ch === "\f") {
-      result += "\\f";
-    } else if (ch === "\n") {
-      result += "\\n";
-    } else if (ch === "\r") {
-      result += "\\r";
-    } else if (ch === "	") {
-      result += "\\t";
-    } else if (code < 32) {
-      result += "\\u" + code.toString(16).padStart(4, "0");
-    } else {
-      result += ch;
+async function importNodeModule(specifier) {
+  if (typeof document !== "undefined") return null;
+  const getBuiltinModule = globalThis.process?.getBuiltinModule;
+  if (typeof getBuiltinModule === "function" && specifier.startsWith("node:")) {
+    try {
+      return getBuiltinModule(specifier.slice("node:".length));
+    } catch {
     }
   }
-  result += '"';
-  return result;
+  try {
+    const requireFn = Function('return typeof require !== "undefined" ? require : undefined');
+    const requireModule = requireFn();
+    if (requireModule) return requireModule(specifier);
+  } catch {
+  }
+  try {
+    const dynamicImport = Function(`return import(${JSON.stringify(specifier)})`);
+    return await dynamicImport();
+  } catch {
+    return null;
+  }
 }
-function serializeArray(arr) {
-  const items = arr.map((item) => serialize(item));
-  return "[" + items.join(",") + "]";
+async function readLocalFile(path) {
+  const fs = await importNodeModule("node:fs/promises");
+  if (!fs?.readFile) throw new StorageError("local file reads are unavailable in this JavaScript runtime", "EUNSUPPORTED", path);
+  return new Uint8Array(await fs.readFile(path));
 }
-function serializeObject(obj) {
-  const sortedKeys = Object.keys(obj).sort(compareCodePoints);
-  const pairs2 = sortedKeys.map(
-    (key) => serializeString(key) + ":" + serialize(obj[key])
-  );
-  return "{" + pairs2.join(",") + "}";
+async function writeLocalFile(path, data, force) {
+  const fs = await importNodeModule("node:fs/promises");
+  const pathMod = await importNodeModule("node:path");
+  if (!fs?.writeFile || !pathMod?.dirname) return false;
+  await fs.mkdir(pathMod.dirname(path), { recursive: true });
+  try {
+    await fs.writeFile(path, data, force ? void 0 : { flag: "wx" });
+    return true;
+  } catch (exc) {
+    const code = text2(exc.code);
+    if (code === "EEXIST") throw new StorageExistsError(`local path already exists: ${path}`, "EEXIST", path);
+    throw exc;
+  }
 }
-function compareCodePoints(a, b) {
-  const ac = Array.from(a);
-  const bc = Array.from(b);
-  const n = Math.min(ac.length, bc.length);
-  for (let i = 0; i < n; i++) {
-    const av = ac[i].codePointAt(0) ?? 0;
-    const bv = bc[i].codePointAt(0) ?? 0;
-    if (av !== bv) return av - bv;
+async function localFileStatus(path) {
+  const fs = await importNodeModule("node:fs/promises");
+  if (!fs?.stat) return "unavailable";
+  try {
+    const info = await fs.stat(path);
+    return info.isDirectory() ? "dir" : "file";
+  } catch (exc) {
+    const code = text2(exc.code);
+    if (code === "ENOENT") return "missing";
+    throw exc;
   }
-  return ac.length - bc.length;
 }
-
-// src/group-index.ts
-var GROUP_INDEX_SCHEMA = "aun.group.index.v1";
-var GROUP_INDEX_KEY = "group.index";
-var GROUP_INDEX_SIG_ALG = "ECDSA-P256-SHA256";
-var GROUP_INDEX_CACHE_VERIFICATION_VERSION = 1;
-var GroupIndexMetaCache = class {
-  constructor() {
-    __publicField(this, "remote", /* @__PURE__ */ new Map());
-    __publicField(this, "localEtags", /* @__PURE__ */ new Map());
-    __publicField(this, "stale", /* @__PURE__ */ new Set());
-    __publicField(this, "settings", /* @__PURE__ */ new Map());
-    __publicField(this, "entryEtags", /* @__PURE__ */ new Map());
-    __publicField(this, "verificationVersions", /* @__PURE__ */ new Map());
+function downloadTarget(dst) {
+  if (typeof dst === "string") {
+    if (dst === "blob:") return { mode: "blob" };
+    if (dst === "bytes:") return { mode: "bytes" };
+    return { mode: "local", localPath: stripLocalPathPrefix(dst) };
   }
-  observeRpcMeta(meta, options) {
-    const groupIndexes = isRecord2(meta?.group_indexes) ? meta.group_indexes : null;
-    if (!groupIndexes) return;
-    const local = String(options.localAid ?? "");
-    for (const [groupAid, value] of Object.entries(groupIndexes)) {
-      if (!isRecord2(value)) continue;
-      const key = this.key(local, groupAid);
-      const remoteMeta = {};
-      for (const name of ["etag", "last_modified", "schema"]) {
-        if (value[name] !== void 0 && value[name] !== null) remoteMeta[name] = value[name];
-      }
-      this.remote.set(key, remoteMeta);
-      const remoteEtag = String(remoteMeta.etag ?? "");
-      if (remoteEtag && this.localEtags.get(key) !== remoteEtag) this.stale.add(key);
-      else if (remoteEtag) this.stale.delete(key);
+  const mode = dst.type === "blob" ? "blob" : dst.type === "bytes" ? "bytes" : dst.path || dst.localPath ? "local" : "bytes";
+  const localPath = dst.path ?? dst.localPath;
+  return { mode, localPath: localPath ? stripLocalPathPrefix(localPath) : localPath };
+}
+var GroupFSVFS = class {
+  constructor(client, options = {}) {
+    __publicField(this, "lowlevel");
+    __publicField(this, "client");
+    this.client = client;
+    this.lowlevel = options.lowlevel ?? new StorageLowLevel(client);
+  }
+  async call(method, params2, path = "") {
+    try {
+      return await this.client.call(method, await this.prepareParams(params2));
+    } catch (exc) {
+      throw mapStorageError(exc, path);
     }
   }
-  markFresh(localAid, groupAid, options) {
-    const key = this.key(localAid, groupAid);
-    const etag = String(options.etag ?? "");
-    const previous = this.localEtags.get(key) ?? "";
-    if (this.verificationVersions.get(key) === GROUP_INDEX_CACHE_VERIFICATION_VERSION && previous !== etag) {
-      this.verificationVersions.delete(key);
-      this.settings.delete(key);
-      this.entryEtags.delete(key);
+  async prepareParams(params2) {
+    const next = { ...params2 ?? {} };
+    const signAs = text2(next.sign_as ?? next.signAs);
+    const aidStore = next.aid_store ?? next.aidStore;
+    delete next.sign_as;
+    delete next.signAs;
+    delete next.aid_store;
+    delete next.aidStore;
+    if (signAs) {
+      const currentAid = text2(this.client.aid ?? this.client._aid);
+      if (currentAid.toLowerCase() !== signAs.toLowerCase()) {
+        if (!aidStore) {
+          throw new Error(`group.fs operation requires aidStore to sign as ${signAs}`);
+        }
+        next._client_signature_identity = await loadSigningAID(aidStore, signAs);
+      }
     }
-    this.localEtags.set(key, etag);
-    this.stale.delete(key);
-    return this.verificationVersions.get(key) ?? 0;
+    return stripNil(next);
   }
-  isStale(localAid, groupAid) {
-    return this.stale.has(this.key(localAid, groupAid));
+  ls(path, options = {}) {
+    return this.call("group.fs.ls", { path, ...options }, path);
   }
-  remoteMeta(localAid, groupAid) {
-    const value = this.remote.get(this.key(localAid, groupAid));
-    return value ? { ...value } : null;
+  find(path, options = {}) {
+    return this.call("group.fs.find", { path, ...options }, path);
   }
-  localEtag(localAid, groupAid) {
-    return this.localEtags.get(this.key(localAid, groupAid)) ?? "";
+  stat(path, options = {}) {
+    return this.call("group.fs.stat", { path, ...options }, path);
   }
-  cachedSettings(localAid, groupAid, keys) {
-    if (this.verificationVersions.get(this.key(localAid, groupAid)) !== GROUP_INDEX_CACHE_VERIFICATION_VERSION) return null;
-    const value = this.settings.get(this.key(localAid, groupAid)) ?? {};
-    if (!keys.every((item) => item in value)) return null;
-    return Object.fromEntries(keys.filter((item) => item in value).map((item) => [item, value[item]]));
+  lstat(path, options = {}) {
+    return this.call("group.fs.lstat", { path, ...options }, path);
   }
-  cachedSettingsByEntries(localAid, groupAid, keys, entries) {
-    const key = this.key(localAid, groupAid);
-    if (this.verificationVersions.get(key) !== GROUP_INDEX_CACHE_VERIFICATION_VERSION) {
-      return { cached: {}, missing: [...keys] };
-    }
-    const value = this.settings.get(key) ?? {};
-    const localEntryEtags = this.entryEtags.get(key) ?? {};
-    const remoteEntryEtags = Object.fromEntries(entries.map((item) => [String(item.key ?? ""), String(item.etag ?? "")]));
-    const cached = {};
-    const missing = [];
-    for (const item of keys) {
-      if (item in value && localEntryEtags[item] === remoteEntryEtags[item]) {
-        cached[item] = value[item];
-      } else {
-        missing.push(item);
-      }
-    }
-    return { cached, missing };
+  mkdir(path, options = {}) {
+    return this.call("group.fs.mkdir", { path, parents: options.parents ?? false, ...options }, path);
   }
-  cacheSettings(localAid, groupAid, settings, options) {
-    const key = this.key(localAid, groupAid);
-    const etag = String(options?.etag ?? "");
-    if (!Array.isArray(options?.entries) || !etag) return;
-    this.settings.set(key, { ...settings });
-    this.entryEtags.set(key, Object.fromEntries(options.entries.map((item) => [String(item.key ?? ""), String(item.etag ?? "")]).filter(([entryKey]) => Boolean(entryKey))));
-    this.localEtags.set(key, etag);
-    this.verificationVersions.set(key, GROUP_INDEX_CACHE_VERIFICATION_VERSION);
-    this.stale.delete(key);
+  setAcl(path, options = {}) {
+    const grantee = options.grantee_aid ?? options.granteeAid ?? "role:admin";
+    const params2 = { ...options, path, grantee_aid: grantee, perms: options.perms ?? "rwx" };
+    delete params2.granteeAid;
+    return this.call("group.fs.set_acl", params2, path);
   }
-  restore(localAid, groupAid, record) {
-    const key = this.key(localAid, groupAid);
-    if (isRecord2(record.remote_meta)) this.remote.set(key, { ...record.remote_meta });
-    if (Number(record.verification_version ?? 0) === GROUP_INDEX_CACHE_VERIFICATION_VERSION) {
-      this.verificationVersions.set(key, GROUP_INDEX_CACHE_VERIFICATION_VERSION);
-      this.localEtags.set(key, String(record.local_etag ?? ""));
-      this.settings.set(key, isRecord2(record.settings) ? { ...record.settings } : {});
-      this.entryEtags.set(key, isRecord2(record.entry_etags) ? Object.fromEntries(Object.entries(record.entry_etags).map(([entryKey, entryEtag]) => [entryKey, String(entryEtag ?? "")])) : {});
-    }
-    const remoteEtag = String(this.remote.get(key)?.etag ?? "");
-    if (remoteEtag && this.localEtags.get(key) !== remoteEtag) this.stale.add(key);
-    if (remoteEtag && this.localEtags.get(key) === remoteEtag) this.stale.delete(key);
+  removeAcl(path, options = {}) {
+    const grantee = options.grantee_aid ?? options.granteeAid ?? "role:admin";
+    const params2 = { ...options, path, grantee_aid: grantee };
+    delete params2.granteeAid;
+    return this.call("group.fs.remove_acl", params2, path);
   }
-  key(localAid, groupAid) {
-    return `${String(localAid ?? "")}\0${String(groupAid ?? "")}`;
+  getAcl(path, options = {}) {
+    return this.call("group.fs.get_acl", { path, ...options }, path);
   }
-};
-async function computeGroupIndexBodyHash(entries) {
-  return `sha256:${await sha256Hex2(entriesBytes(entries))}`;
-}
-async function groupIndexEtag(entries) {
-  return `"sha256:${await sha256Hex2(entriesBytes(entries))}"`;
-}
-async function groupIndexSettingEtag(value) {
-  return `"sha256:${await sha256Hex2(encode(canonicalStringify(value)))}"`;
-}
-function groupIndexSigningPayload(meta, entries) {
-  const metaWithoutSignature = { ...meta };
-  delete metaWithoutSignature.signature;
-  const lines = [canonicalStringify(metaWithoutSignature)];
-  lines.push(...canonicalEntries(entries).map((item) => canonicalStringify(item)));
-  return encode(`${lines.join("\n")}
-`);
-}
-async function buildSignedGroupIndex(options) {
-  const entries = canonicalEntries(options.entries);
-  const meta = {
+  listAcl(path, options = {}) {
+    return this.call("group.fs.list_acl", { path, ...options }, path);
+  }
+  rm(path, options = {}) {
+    return this.call("group.fs.rm", {
+      path,
+      recursive: options.recursive ?? false,
+      force: options.force ?? false,
+      ...options
+    }, path);
+  }
+  async cp(src, dst, options = {}) {
+    const groupRef = options.group_aid ?? options.groupAid ?? options.group_id ?? options.groupId;
+    const srcGroupRef = options.src_group_aid ?? options.srcGroupAid ?? options.src_group_id ?? options.srcGroupId;
+    const dstGroupRef = options.dst_group_aid ?? options.dstGroupAid ?? options.dst_group_id ?? options.dstGroupId;
+    const srcRemote = typeof src === "string" && isGroupRemoteCopyPath(src, srcGroupRef, groupRef);
+    const dstRemote = typeof dst === "string" && isGroupRemoteCopyPath(dst, dstGroupRef, groupRef);
+    if (srcRemote && dstRemote) return this.copyRemoteToRemote(src, dst, options);
+    if (!srcRemote && dstRemote) return this.uploadToGroup(src, dst, options);
+    if (srcRemote && !dstRemote) return this.downloadFromGroup(src, dst, options);
+    throw new StorageError("local-to-local copy is not handled by group.fs", "EINVAL", typeof src === "string" ? src : "");
+  }
+  async mv(src, dst, options = {}) {
+    const groupRef = options.group_aid ?? options.groupAid ?? options.group_id ?? options.groupId;
+    const srcGroupRef = options.src_group_aid ?? options.srcGroupAid ?? options.src_group_id ?? options.srcGroupId;
+    const dstGroupRef = options.dst_group_aid ?? options.dstGroupAid ?? options.dst_group_id ?? options.dstGroupId;
+    if (!isGroupRemoteCopyPath(src, srcGroupRef, groupRef) || !isGroupRemoteCopyPath(dst, dstGroupRef, groupRef)) {
+      throw new StorageError("group.fs.mv only supports group remote paths", "EINVAL", src);
+    }
+    const params2 = this.remoteCopyParams(src, dst, options);
+    return this.call("group.fs.mv", params2, src);
+  }
+  df(pathOrGroup, options = {}) {
+    const params2 = { ...options };
+    if (pathOrGroup !== void 0 && pathOrGroup !== null) params2.path = pathOrGroup;
+    return this.call("group.fs.df", params2, pathOrGroup ?? "");
+  }
+  mount(path, options = {}) {
+    return this.call("group.fs.mount", { path, ...options }, path);
+  }
+  umount(path, options = {}) {
+    return this.call("group.fs.umount", { path, ...options }, path);
+  }
+  remoteCopyParams(src, dst, options) {
+    const params2 = { ...options, src, dst };
+    delete params2.contentType;
+    delete params2.content_type;
+    delete params2.metadata;
+    delete params2.expectedVersion;
+    delete params2.expected_version;
+    delete params2.parents;
+    delete params2.verifyHash;
+    delete params2.verify_hash;
+    delete params2.sourceType;
+    delete params2.source_type;
+    delete params2.localPath;
+    delete params2.local_path;
+    if (options.groupAid !== void 0) params2.group_aid = options.groupAid;
+    if (options.groupId !== void 0) params2.group_id = options.groupId;
+    if (options.srcGroupAid !== void 0) params2.src_group_aid = options.srcGroupAid;
+    if (options.srcGroupId !== void 0) params2.src_group_id = options.srcGroupId;
+    if (options.dstGroupAid !== void 0) params2.dst_group_aid = options.dstGroupAid;
+    if (options.dstGroupId !== void 0) params2.dst_group_id = options.dstGroupId;
+    if (options.followSymlinks !== void 0) params2.follow_symlinks = options.followSymlinks;
+    delete params2.groupAid;
+    delete params2.srcGroupAid;
+    delete params2.dstGroupAid;
+    delete params2.followSymlinks;
+    if (!options.force) delete params2.force;
+    if (!options.recursive) delete params2.recursive;
+    return stripNil(params2);
+  }
+  copyRemoteToRemote(src, dst, options) {
+    return this.call("group.fs.cp", this.remoteCopyParams(src, dst, options), src);
+  }
+  async sourceBytes(src, options) {
+    if (typeof src === "string") {
+      const sourceType = text2(options.source_type ?? options.sourceType);
+      if (isExplicitLocalPath(src) || sourceType === "path" || options.localPath === true || options.local_path === true) {
+        const localPath = stripLocalPathPrefix(src);
+        const data2 = await readLocalFile(localPath);
+        return { data: data2, contentType: contentTypeForData(data2, localPath) };
+      }
+      return { data: await toBytes2(src), contentType: "text/plain;charset=utf-8" };
+    }
+    const data = await toBytes2(src);
+    const fileName = text2(src.name);
+    return { data, contentType: contentTypeForData(data, fileName) };
+  }
+  async uploadToGroup(src, dst, options) {
+    const { data, contentType } = await this.sourceBytes(src, options);
+    const digest = await sha256Hex2(data);
+    const groupAid = options.group_aid ?? options.groupAid ?? options.dst_group_aid ?? options.dstGroupAid;
+    const groupId = options.group_id ?? options.groupId ?? options.dst_group_id ?? options.dstGroupId;
+    const baseParams = stripNil({
+      ...options,
+      path: dst,
+      group_aid: groupAid,
+      group_id: groupAid ? void 0 : groupId,
+      size_bytes: data.byteLength,
+      sha256: digest,
+      content_type: options.content_type ?? options.contentType ?? contentType,
+      force: options.force ?? false,
+      parents: options.parents ?? true,
+      metadata: options.metadata,
+      expected_version: options.expected_version ?? options.expectedVersion
+    });
+    delete baseParams.groupId;
+    delete baseParams.groupAid;
+    delete baseParams.dstGroupId;
+    delete baseParams.dstGroupAid;
+    delete baseParams.dst_group_aid;
+    delete baseParams.dst_group_id;
+    delete baseParams.srcGroupId;
+    delete baseParams.srcGroupAid;
+    delete baseParams.src_group_aid;
+    delete baseParams.src_group_id;
+    delete baseParams.contentType;
+    delete baseParams.expectedVersion;
+    delete baseParams.verifyHash;
+    delete baseParams.verify_hash;
+    delete baseParams.recursive;
+    delete baseParams.followSymlinks;
+    delete baseParams.follow_symlinks;
+    delete baseParams.sourceType;
+    delete baseParams.source_type;
+    delete baseParams.localPath;
+    delete baseParams.local_path;
+    const check = await this.call("group.fs.check_upload", baseParams, dst);
+    if (check && typeof check === "object") {
+      const raw = check;
+      if (raw.within_limit === false) throw new StorageError("file size exceeds group fs upload limit", "E2BIG", dst, raw);
+      if (raw.target_exists && !options.force && options.expected_version === void 0 && options.expectedVersion === void 0) {
+        throw new StorageExistsError("group fs target already exists", "EEXIST", dst, raw.target);
+      }
+      if (raw.instant || raw.dedup_hit || raw.skip_upload) {
+        return this.call("group.fs.complete_upload", {
+          ...baseParams,
+          skip_blob: true,
+          session_id: raw.session_id
+        }, dst);
+      }
+    }
+    const session = await this.call("group.fs.create_upload_session", baseParams, dst);
+    if (!session || typeof session !== "object") {
+      throw new StorageError(`group.fs.create_upload_session returned invalid response`, "ESTORAGE", dst, session);
+    }
+    const rawSession = session;
+    const uploadUrl = text2(rawSession.upload_url ?? rawSession.url);
+    if (!uploadUrl) throw new StorageError("group.fs.create_upload_session did not return upload_url", "ESTORAGE", dst, session);
+    const headers = {};
+    if (rawSession.headers && typeof rawSession.headers === "object" && !Array.isArray(rawSession.headers)) {
+      for (const [key, value] of Object.entries(rawSession.headers)) {
+        if (value !== void 0 && value !== null) headers[key] = String(value);
+      }
+    }
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === "content-type") delete headers[key];
+    }
+    headers["Content-Type"] = text2(baseParams.content_type) || "application/octet-stream";
+    await this.lowlevel.httpPut(uploadUrl, data, headers);
+    return this.call("group.fs.complete_upload", {
+      ...baseParams,
+      session_id: rawSession.session_id ?? rawSession.id
+    }, dst);
+  }
+  async downloadFromGroup(src, dst, options) {
+    const target = downloadTarget(dst);
+    if (target.mode === "local" && target.localPath) {
+      const status = await localFileStatus(target.localPath);
+      if (status === "file" && !options.force) {
+        throw new StorageExistsError(`local path already exists: ${target.localPath}`, "EEXIST", target.localPath);
+      }
+    }
+    const groupAid = options.group_aid ?? options.groupAid ?? options.src_group_aid ?? options.srcGroupAid;
+    const groupId = options.group_id ?? options.groupId ?? options.src_group_id ?? options.srcGroupId;
+    const params2 = stripNil({
+      ...options,
+      path: src,
+      group_aid: groupAid,
+      group_id: groupAid ? void 0 : groupId
+    });
+    delete params2.groupId;
+    delete params2.groupAid;
+    delete params2.srcGroupId;
+    delete params2.srcGroupAid;
+    delete params2.src_group_aid;
+    delete params2.src_group_id;
+    delete params2.dstGroupId;
+    delete params2.dstGroupAid;
+    delete params2.dst_group_aid;
+    delete params2.dst_group_id;
+    delete params2.force;
+    delete params2.recursive;
+    delete params2.parents;
+    delete params2.contentType;
+    delete params2.content_type;
+    delete params2.expectedVersion;
+    delete params2.expected_version;
+    delete params2.verifyHash;
+    delete params2.verify_hash;
+    delete params2.sourceType;
+    delete params2.source_type;
+    delete params2.localPath;
+    delete params2.local_path;
+    const ticket = await this.call("group.fs.create_download_ticket", params2, src);
+    if (!ticket || typeof ticket !== "object") {
+      throw new StorageError("group.fs.create_download_ticket returned invalid response", "ESTORAGE", src, ticket);
+    }
+    const rawTicket = ticket;
+    const downloadUrl = text2(rawTicket.download_url ?? rawTicket.url);
+    if (!downloadUrl) throw new StorageError("group.fs.create_download_ticket did not return download_url", "ESTORAGE", src, ticket);
+    const data = await this.lowlevel.httpGet(downloadUrl, bearerHeaders(this.client));
+    const expectedSha = text2(rawTicket.sha256);
+    const verifyHash = options.verify_hash ?? options.verifyHash ?? true;
+    const verified = !verifyHash || !expectedSha || await sha256Hex2(data) === expectedSha.toLowerCase();
+    if (verifyHash && !verified) {
+      throw new StorageConflictError("download hash verification failed", "ECONFLICT", src, ticket);
+    }
+    if (target.mode === "local" && target.localPath) {
+      const status = await localFileStatus(target.localPath);
+      if (status === "dir") {
+        throw new StorageError("directory download target is not supported in this JavaScript runtime", "EISDIR", target.localPath);
+      }
+      if (status === "file" && !options.force) {
+        throw new StorageExistsError(`local path already exists: ${target.localPath}`, "EEXIST", target.localPath);
+      }
+    }
+    const result = {
+      path: src,
+      localPath: target.localPath,
+      size: data.byteLength,
+      sha256: expectedSha,
+      verified,
+      data
+    };
+    if (target.mode === "blob" && typeof Blob !== "undefined") {
+      result.blob = new Blob([toExactArrayBuffer(data)], { type: text2(rawTicket.content_type) || "application/octet-stream" });
+    }
+    if (target.mode === "local" && target.localPath) {
+      result.wroteLocalFile = await writeLocalFile(target.localPath, data, Boolean(options.force));
+    }
+    return result;
+  }
+};
+
+// src/v2/crypto/canonical.ts
+var encoder = new TextEncoder();
+var MAX_SAFE_JSON_INTEGER = 9007199254740991;
+function canonicalJson(obj) {
+  return encoder.encode(serialize(obj));
+}
+function serialize(obj) {
+  if (obj === null) return "null";
+  if (obj === true) return "true";
+  if (obj === false) return "false";
+  if (typeof obj === "number") {
+    return serializeNumber(obj);
+  }
+  if (typeof obj === "string") {
+    return serializeString(obj);
+  }
+  if (Array.isArray(obj)) {
+    return serializeArray(obj);
+  }
+  if (typeof obj === "object") {
+    return serializeObject(obj);
+  }
+  throw new TypeError(`canonicalJson: unsupported type ${typeof obj}`);
+}
+function serializeNumber(n) {
+  if (!isFinite(n)) {
+    throw new RangeError("canonicalJson: Infinity and NaN not allowed");
+  }
+  if (Object.is(n, -0)) return "0";
+  if (Number.isInteger(n)) {
+    if (Math.abs(n) > MAX_SAFE_JSON_INTEGER) {
+      throw new RangeError(`canonicalJson: integer outside safe range ${n}`);
+    }
+    return String(n);
+  }
+  return expandExponent(String(n));
+}
+function expandExponent(s) {
+  if (!/[eE]/.test(s)) return s;
+  const match = /^(-?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(s);
+  if (!match) {
+    throw new TypeError(`canonicalJson: invalid number ${s}`);
+  }
+  const sign = match[1] ?? "";
+  const intPart = match[2] ?? "";
+  const fracPart = match[3] ?? "";
+  const exp = Number(match[4]);
+  const digits = intPart + fracPart;
+  const point = intPart.length + exp;
+  if (point <= 0) {
+    return `${sign}0.${"0".repeat(-point)}${digits}`;
+  }
+  if (point >= digits.length) {
+    return `${sign}${digits}${"0".repeat(point - digits.length)}`;
+  }
+  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+function serializeString(s) {
+  let result = '"';
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    const code = s.charCodeAt(i);
+    if (ch === '"') {
+      result += '\\"';
+    } else if (ch === "\\") {
+      result += "\\\\";
+    } else if (ch === "\b") {
+      result += "\\b";
+    } else if (ch === "\f") {
+      result += "\\f";
+    } else if (ch === "\n") {
+      result += "\\n";
+    } else if (ch === "\r") {
+      result += "\\r";
+    } else if (ch === "	") {
+      result += "\\t";
+    } else if (code < 32) {
+      result += "\\u" + code.toString(16).padStart(4, "0");
+    } else {
+      result += ch;
+    }
+  }
+  result += '"';
+  return result;
+}
+function serializeArray(arr) {
+  const items = arr.map((item) => serialize(item));
+  return "[" + items.join(",") + "]";
+}
+function serializeObject(obj) {
+  const sortedKeys = Object.keys(obj).sort(compareCodePoints);
+  const pairs2 = sortedKeys.map(
+    (key) => serializeString(key) + ":" + serialize(obj[key])
+  );
+  return "{" + pairs2.join(",") + "}";
+}
+function compareCodePoints(a, b) {
+  const ac = Array.from(a);
+  const bc = Array.from(b);
+  const n = Math.min(ac.length, bc.length);
+  for (let i = 0; i < n; i++) {
+    const av = ac[i].codePointAt(0) ?? 0;
+    const bv = bc[i].codePointAt(0) ?? 0;
+    if (av !== bv) return av - bv;
+  }
+  return ac.length - bc.length;
+}
+
+// src/group-index.ts
+var GROUP_INDEX_SCHEMA = "aun.group.index.v1";
+var GROUP_INDEX_KEY = "group.index";
+var GROUP_INDEX_SIG_ALG = "ECDSA-P256-SHA256";
+var GROUP_INDEX_CACHE_VERIFICATION_VERSION = 1;
+var GroupIndexMetaCache = class {
+  constructor() {
+    __publicField(this, "remote", /* @__PURE__ */ new Map());
+    __publicField(this, "localEtags", /* @__PURE__ */ new Map());
+    __publicField(this, "stale", /* @__PURE__ */ new Set());
+    __publicField(this, "settings", /* @__PURE__ */ new Map());
+    __publicField(this, "entryEtags", /* @__PURE__ */ new Map());
+    __publicField(this, "verificationVersions", /* @__PURE__ */ new Map());
+  }
+  observeRpcMeta(meta, options) {
+    const groupIndexes = isRecord2(meta?.group_indexes) ? meta.group_indexes : null;
+    if (!groupIndexes) return;
+    const local = String(options.localAid ?? "");
+    for (const [groupAid, value] of Object.entries(groupIndexes)) {
+      if (!isRecord2(value)) continue;
+      const key = this.key(local, groupAid);
+      const remoteMeta = {};
+      for (const name of ["etag", "last_modified", "schema"]) {
+        if (value[name] !== void 0 && value[name] !== null) remoteMeta[name] = value[name];
+      }
+      this.remote.set(key, remoteMeta);
+      const remoteEtag = String(remoteMeta.etag ?? "");
+      if (remoteEtag && this.localEtags.get(key) !== remoteEtag) this.stale.add(key);
+      else if (remoteEtag) this.stale.delete(key);
+    }
+  }
+  markFresh(localAid, groupAid, options) {
+    const key = this.key(localAid, groupAid);
+    const etag = String(options.etag ?? "");
+    const previous = this.localEtags.get(key) ?? "";
+    if (this.verificationVersions.get(key) === GROUP_INDEX_CACHE_VERIFICATION_VERSION && previous !== etag) {
+      this.verificationVersions.delete(key);
+      this.settings.delete(key);
+      this.entryEtags.delete(key);
+    }
+    this.localEtags.set(key, etag);
+    this.stale.delete(key);
+    return this.verificationVersions.get(key) ?? 0;
+  }
+  isStale(localAid, groupAid) {
+    return this.stale.has(this.key(localAid, groupAid));
+  }
+  remoteMeta(localAid, groupAid) {
+    const value = this.remote.get(this.key(localAid, groupAid));
+    return value ? { ...value } : null;
+  }
+  localEtag(localAid, groupAid) {
+    return this.localEtags.get(this.key(localAid, groupAid)) ?? "";
+  }
+  cachedSettings(localAid, groupAid, keys) {
+    if (this.verificationVersions.get(this.key(localAid, groupAid)) !== GROUP_INDEX_CACHE_VERIFICATION_VERSION) return null;
+    const value = this.settings.get(this.key(localAid, groupAid)) ?? {};
+    if (!keys.every((item) => item in value)) return null;
+    return Object.fromEntries(keys.filter((item) => item in value).map((item) => [item, value[item]]));
+  }
+  cachedSettingsByEntries(localAid, groupAid, keys, entries) {
+    const key = this.key(localAid, groupAid);
+    if (this.verificationVersions.get(key) !== GROUP_INDEX_CACHE_VERIFICATION_VERSION) {
+      return { cached: {}, missing: [...keys] };
+    }
+    const value = this.settings.get(key) ?? {};
+    const localEntryEtags = this.entryEtags.get(key) ?? {};
+    const remoteEntryEtags = Object.fromEntries(entries.map((item) => [String(item.key ?? ""), String(item.etag ?? "")]));
+    const cached = {};
+    const missing = [];
+    for (const item of keys) {
+      if (item in value && localEntryEtags[item] === remoteEntryEtags[item]) {
+        cached[item] = value[item];
+      } else {
+        missing.push(item);
+      }
+    }
+    return { cached, missing };
+  }
+  cacheSettings(localAid, groupAid, settings, options) {
+    const key = this.key(localAid, groupAid);
+    const etag = String(options?.etag ?? "");
+    if (!Array.isArray(options?.entries) || !etag) return;
+    this.settings.set(key, { ...settings });
+    this.entryEtags.set(key, Object.fromEntries(options.entries.map((item) => [String(item.key ?? ""), String(item.etag ?? "")]).filter(([entryKey]) => Boolean(entryKey))));
+    this.localEtags.set(key, etag);
+    this.verificationVersions.set(key, GROUP_INDEX_CACHE_VERIFICATION_VERSION);
+    this.stale.delete(key);
+  }
+  restore(localAid, groupAid, record) {
+    const key = this.key(localAid, groupAid);
+    if (isRecord2(record.remote_meta)) this.remote.set(key, { ...record.remote_meta });
+    if (Number(record.verification_version ?? 0) === GROUP_INDEX_CACHE_VERIFICATION_VERSION) {
+      this.verificationVersions.set(key, GROUP_INDEX_CACHE_VERIFICATION_VERSION);
+      this.localEtags.set(key, String(record.local_etag ?? ""));
+      this.settings.set(key, isRecord2(record.settings) ? { ...record.settings } : {});
+      this.entryEtags.set(key, isRecord2(record.entry_etags) ? Object.fromEntries(Object.entries(record.entry_etags).map(([entryKey, entryEtag]) => [entryKey, String(entryEtag ?? "")])) : {});
+    }
+    const remoteEtag = String(this.remote.get(key)?.etag ?? "");
+    if (remoteEtag && this.localEtags.get(key) !== remoteEtag) this.stale.add(key);
+    if (remoteEtag && this.localEtags.get(key) === remoteEtag) this.stale.delete(key);
+  }
+  key(localAid, groupAid) {
+    return `${String(localAid ?? "")}\0${String(groupAid ?? "")}`;
+  }
+};
+async function computeGroupIndexBodyHash(entries) {
+  return `sha256:${await sha256Hex3(entriesBytes(entries))}`;
+}
+async function groupIndexEtag(entries) {
+  return `"sha256:${await sha256Hex3(entriesBytes(entries))}"`;
+}
+async function groupIndexSettingEtag(value) {
+  return `"sha256:${await sha256Hex3(encode(canonicalStringify(value)))}"`;
+}
+function groupIndexSigningPayload(meta, entries) {
+  const metaWithoutSignature = { ...meta };
+  delete metaWithoutSignature.signature;
+  const lines = [canonicalStringify(metaWithoutSignature)];
+  lines.push(...canonicalEntries(entries).map((item) => canonicalStringify(item)));
+  return encode(`${lines.join("\n")}
+`);
+}
+async function buildSignedGroupIndex(options) {
+  const entries = canonicalEntries(options.entries);
+  const meta = {
     type: "index_meta",
     group_aid: String(options.groupAid),
     etag: await groupIndexEtag(entries),
@@ -18489,7 +19266,7 @@ function canonicalStringify(value) {
 function encode(text3) {
   return new TextEncoder().encode(text3);
 }
-async function sha256Hex2(data) {
+async function sha256Hex3(data) {
   const digest = await globalThis.crypto.subtle.digest("SHA-256", exactArrayBuffer(data));
   return bytesToHex(new Uint8Array(digest));
 }
@@ -18563,1222 +19340,672 @@ function indexedDocumentKeyName(params2) {
 var RpcFacade = class {
   constructor(client) {
     __publicField(this, "client");
-    this.client = client;
-  }
-  call(method, params2) {
-    return this.client.call(method, stripNil2(params2));
-  }
-};
-var MessageThoughtFacade = class extends RpcFacade {
-  put(params2) {
-    return this.call("message.thought.put", params2);
-  }
-  get(params2) {
-    return this.call("message.thought.get", params2);
-  }
-};
-var MessageFacade = class extends RpcFacade {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "_thought");
-  }
-  get thought() {
-    if (!this._thought) this._thought = new MessageThoughtFacade(this.client);
-    return this._thought;
-  }
-  send(params2) {
-    return this.call("message.send", params2);
-  }
-  pull(params2) {
-    return this.call("message.pull", params2);
-  }
-  history(params2) {
-    return this.call("message.history", params2);
-  }
-  ack(params2) {
-    return this.call("message.ack", params2);
-  }
-  recall(params2) {
-    return this.call("message.recall", params2);
-  }
-  queryOnline(params2) {
-    return this.call("message.query_online", params2);
-  }
-};
-function normalizeInviteParams(params2) {
-  const out = stripNil2(params2);
-  const rawGroupId = out.group_id ?? out.groupId ?? out.group_aid ?? out.groupAid;
-  if (rawGroupId !== void 0) {
-    out.group_id = normalizeGroupId(rawGroupId);
-    delete out.groupId;
-    delete out.group_aid;
-    delete out.groupAid;
-  }
-  for (const [alias, canonical] of [["inviteId", "invite_id"], ["inviteeAid", "invitee_aid"]]) {
-    if (out[canonical] === void 0 && out[alias] !== void 0) out[canonical] = out[alias];
-    delete out[alias];
-  }
-  return out;
-}
-var MailFacade = class extends RpcFacade {
-  send(params2) {
-    return this.call("mail.send", params2);
-  }
-  get(params2) {
-    return this.call("mail.get", params2);
-  }
-  list(params2) {
-    return this.call("mail.list", params2);
-  }
-  delete(params2) {
-    return this.call("mail.delete", params2);
-  }
-  move(params2) {
-    return this.call("mail.move", params2);
-  }
-  mark(params2) {
-    return this.call("mail.mark", params2);
-  }
-  search(params2) {
-    return this.call("mail.search", params2);
-  }
-  getAttachment(params2) {
-    return this.call("mail.get_attachment", params2);
-  }
-  getQuota(params2) {
-    return this.call("mail.get_quota", params2);
-  }
-  health(params2) {
-    return this.call("mail.health", params2);
-  }
-  status(params2) {
-    return this.call("mail.status", params2);
-  }
-};
-var GroupThoughtFacade = class extends RpcFacade {
-  put(params2) {
-    return this.call("group.thought.put", params2);
-  }
-  get(params2) {
-    return this.call("group.thought.get", params2);
-  }
-};
-var GroupFacade = class extends RpcFacade {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "_fs");
-    __publicField(this, "_thought");
-  }
-  get fs() {
-    if (!this._fs) this._fs = new GroupFSVFS(this.client);
-    return this._fs;
-  }
-  get thought() {
-    if (!this._thought) this._thought = new GroupThoughtFacade(this.client);
-    return this._thought;
-  }
-  create(params2) {
-    const split = splitAidStore(params2);
-    if (split.params.group_name === void 0 && split.params.groupName !== void 0) {
-      split.params.group_name = split.params.groupName;
-      delete split.params.groupName;
-    }
-    if (split.aidStore && typeof this.client.createGroup === "function") {
-      return this.client.createGroup(split.params, { aidStore: split.aidStore });
-    }
-    return this.call("group.create", split.params);
-  }
-  bindAid(params2) {
-    return this.call("group.bind_aid", splitAidStore(params2).params);
-  }
-  bindGroupAid(params2) {
-    const split = splitAidStore(params2);
-    if (split.aidStore && typeof this.client.bindGroupAid === "function") {
-      return this.client.bindGroupAid(split.params, { aidStore: split.aidStore });
-    }
-    return this.call("group.bind_group_aid", split.params);
-  }
-  renewGroupAid(params2) {
-    const split = splitAidStore(params2);
-    if (typeof this.client.renewGroupAid === "function") {
-      return this.client.renewGroupAid(split.params, { aidStore: split.aidStore });
-    }
-    return this.call("group.renew_group_aid", split.params);
-  }
-  getInfo(params2) {
-    return this.call("group.get_info", params2);
-  }
-  update(params2) {
-    return this.call("group.update", params2);
-  }
-  list(params2) {
-    return this.call("group.list", params2);
-  }
-  listMy(params2) {
-    return this.call("group.list_my", params2);
-  }
-  search(params2) {
-    return this.call("group.search", params2);
-  }
-  suspend(params2) {
-    return this.call("group.suspend", params2);
-  }
-  resume(params2) {
-    return this.call("group.resume", params2);
-  }
-  dissolve(params2) {
-    return this.call("group.dissolve", params2);
-  }
-  addMember(params2) {
-    return this.call("group.add_member", params2);
-  }
-  async inviteCall(method, params2) {
-    const normalized = normalizeInviteParams(params2);
-    try {
-      const result = await this.call(method, normalized);
-      await this.client._onGroupInviteActionResult?.(method, normalized, result);
-      return result;
-    } catch (error) {
-      await this.client._onGroupInviteActionResult?.(method, normalized, void 0, error);
-      throw error;
-    }
-  }
-  inviteMember(params2) {
-    return this.inviteCall("group.invite_member", params2);
-  }
-  listMyInvites(params2) {
-    return this.inviteCall("group.list_my_invites", params2);
-  }
-  acceptInvite(params2) {
-    return this.inviteCall("group.accept_invite", params2);
-  }
-  rejectInvite(params2) {
-    return this.inviteCall("group.reject_invite", params2);
-  }
-  revokeInvite(params2) {
-    return this.inviteCall("group.revoke_invite", params2);
-  }
-  getMembers(params2) {
-    return this.call("group.get_members", params2);
-  }
-  kick(params2) {
-    return this.call("group.kick", params2);
-  }
-  leave(params2) {
-    return this.call("group.leave", params2);
-  }
-  setRole(params2) {
-    return this.call("group.set_role", params2);
-  }
-  transferOwner(params2) {
-    const split = splitAidStore(params2);
-    if (split.aidStore && typeof this.client.startGroupTransfer === "function") {
-      return this.client.startGroupTransfer(split.params, { aidStore: split.aidStore });
-    }
-    return this.call("group.transfer_owner", split.params);
-  }
-  completeTransfer(params2) {
-    const split = splitAidStore(params2);
-    if (split.aidStore && typeof this.client.completeGroupTransfer === "function") {
-      return this.client.completeGroupTransfer(split.params, { aidStore: split.aidStore });
-    }
-    return this.call("group.complete_transfer", split.params);
+    this.client = client;
   }
-  ban(params2) {
-    return this.call("group.ban", params2);
+  call(method, params2) {
+    return this.client.call(method, stripNil2(params2));
   }
-  unban(params2) {
-    return this.call("group.unban", params2);
+};
+var MessageThoughtFacade = class extends RpcFacade {
+  put(params2) {
+    return this.call("message.thought.put", params2);
   }
-  getBanlist(params2) {
-    return this.call("group.get_banlist", params2);
+  get(params2) {
+    return this.call("message.thought.get", params2);
   }
-  requestJoin(params2) {
-    return this.call("group.request_join", params2);
+};
+var MessageFacade = class extends RpcFacade {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_thought");
   }
-  listJoinRequests(params2) {
-    return this.call("group.list_join_requests", params2);
+  get thought() {
+    if (!this._thought) this._thought = new MessageThoughtFacade(this.client);
+    return this._thought;
   }
-  reviewJoinRequest(params2) {
-    return this.call("group.review_join_request", params2);
+  send(params2) {
+    return this.call("message.send", params2);
   }
-  batchReviewJoinRequest(params2) {
-    return this.call("group.batch_review_join_request", params2);
+  pull(params2) {
+    return this.call("message.pull", params2);
   }
-  createInviteCode(params2) {
-    return this.call("group.create_invite_code", params2);
+  history(params2) {
+    return this.call("message.history", params2);
   }
-  listInviteCodes(params2) {
-    return this.call("group.list_invite_codes", params2);
+  ack(params2) {
+    return this.call("message.ack", params2);
   }
-  useInviteCode(params2) {
-    return this.call("group.use_invite_code", params2);
+  recall(params2) {
+    return this.call("message.recall", params2);
   }
-  revokeInviteCode(params2) {
-    return this.call("group.revoke_invite_code", params2);
+  queryOnline(params2) {
+    return this.call("message.query_online", params2);
   }
-  setSettings(params2) {
-    return this.call("group.set_settings", params2);
+};
+function normalizeInviteParams(params2) {
+  const out = stripNil2(params2);
+  const rawGroupId = out.group_id ?? out.groupId ?? out.group_aid ?? out.groupAid;
+  if (rawGroupId !== void 0) {
+    out.group_id = normalizeGroupId(rawGroupId);
+    delete out.groupId;
+    delete out.group_aid;
+    delete out.groupAid;
   }
-  getSettings(params2) {
-    return this.call("group.get_settings", params2);
+  for (const [alias, canonical] of [["inviteId", "invite_id"], ["inviteeAid", "invitee_aid"]]) {
+    if (out[canonical] === void 0 && out[alias] !== void 0) out[canonical] = out[alias];
+    delete out[alias];
   }
-  async checkGroupIndex(params2) {
-    const merged = stripNil2(params2);
-    const groupAid = String(merged.group_aid ?? merged.group_id ?? "").trim();
-    if (!groupAid) throw new Error("group_aid is required");
-    const clientAny = this.client;
-    const stale = typeof clientAny.isGroupIndexStale === "function" ? Boolean(clientAny.isGroupIndexStale(groupAid)) : false;
-    const remoteMeta = typeof clientAny.getGroupIndexRemoteMeta === "function" ? clientAny.getGroupIndexRemoteMeta(groupAid) ?? {} : {};
-    const localEtag = typeof clientAny.getGroupIndexLocalEtag === "function" ? String(clientAny.getGroupIndexLocalEtag(groupAid) ?? "") : "";
-    const remoteEtag = String(remoteMeta?.etag ?? "");
-    const localFound = Boolean(localEtag);
-    const remoteFound = Boolean(remoteEtag);
-    const inSync = localFound && remoteFound && localEtag === remoteEtag;
-    return {
-      group_aid: groupAid,
-      local_found: localFound,
-      remote_found: remoteFound,
-      local_etag: localEtag,
-      remote_etag: remoteEtag,
-      in_sync: inSync,
-      needs_update: Boolean(stale || remoteFound && !inSync),
-      last_modified: remoteMeta?.last_modified,
-      status: remoteFound ? 200 : 404,
-      cached: true
-    };
+  return out;
+}
+var MailFacade = class extends RpcFacade {
+  send(params2) {
+    return this.call("mail.send", params2);
   }
-  async getGroupIndex(params2) {
-    const merged = stripNil2(params2);
-    const groupId = String(merged.group_id ?? "").trim();
-    if (!groupId) throw new Error("group_id is required");
-    const result = await this.getSettings({ group_id: groupId, keys: [GROUP_INDEX_KEY] });
-    const resultMap = result;
-    const groupAid = String(resultMap.group_aid ?? "").trim();
-    if (!groupAid) throw new Error("group.get_settings response group_aid is required");
-    let groupIndex = null;
-    for (const item of result.settings ?? []) {
-      if (item?.key !== GROUP_INDEX_KEY) continue;
-      groupIndex = item.value;
-      break;
-    }
-    if (!groupIndex) {
-      return { group_id: resultMap.group_id, group_aid: groupAid, group_index: null, meta: {}, entries: [], settings: {} };
-    }
-    const parsed = parseGroupIndex(groupIndex);
-    this.validateGroupIndexEntries(parsed.entries);
-    await this.verifyPulledGroupIndex(groupId, groupAid, groupIndex, parsed);
-    const etag = String(parsed.meta.etag ?? "");
-    const settings = await this.hydrateGroupIndexSettings(groupId, groupAid, parsed.entries, etag, groupIndex);
-    return {
-      group_id: resultMap.group_id,
-      group_aid: groupAid,
-      group_index: groupIndex,
-      meta: parsed.meta,
-      entries: parsed.entries,
-      settings
-    };
+  get(params2) {
+    return this.call("mail.get", params2);
   }
-  async verifyPulledGroupIndex(groupId, groupAid, groupIndex, parsed) {
-    if (String(parsed.meta?.group_aid ?? "").trim() !== groupAid) throw new Error("group.index group_aid does not match group.get_settings response");
-    const signedBy = String(parsed.meta?.signed_by ?? "").trim();
-    if (!signedBy) throw new Error("group.index signed_by is required");
-    const certFingerprint = String(parsed.meta?.cert_fingerprint ?? "").trim();
-    const clientAny = this.client;
-    const currentAid = clientAny.currentAid;
-    let signer = currentAid?.aid === signedBy && !certFingerprint ? currentAid : null;
-    if (currentAid?.aid === signedBy && certFingerprint && typeof currentAid.certPem === "string" && currentAid.certPem) {
-      try {
-        if (await certMatchesFingerprint(currentAid.certPem, certFingerprint)) signer = currentAid;
-      } catch {
-        signer = null;
-      }
-    }
-    if (!signer && typeof clientAny.lookupPeer === "function") {
-      signer = await clientAny.lookupPeer(signedBy, certFingerprint || void 0);
-    }
-    if (!signer) throw new Error(`group.index signer is unavailable: ${signedBy}`);
-    const verified = await verifyGroupIndex(groupIndex, signer);
-    if (!verified.ok) throw new Error(verified.error.message || "group.index verification failed");
-    if (!verified.data.valid) throw new Error(`group.index verification failed: ${verified.data.reason || "invalid signature"}`);
-    const adminsResult = await this.call("group.get_admins", { group_id: groupId });
-    const adminsMap = adminsResult;
-    if (String(adminsMap.group_aid ?? "").trim() !== groupAid) throw new Error("group.get_admins response group_aid does not match group.get_settings response");
-    const authorized = Array.isArray(adminsMap.admins) && adminsMap.admins.some(
-      (item) => String(item?.aid ?? "").trim() === signedBy && ["owner", "admin"].includes(String(item?.role ?? "").trim().toLowerCase())
-    );
-    if (!authorized) throw new Error(`group.index signer is not a current owner or admin: ${signedBy}`);
+  list(params2) {
+    return this.call("mail.list", params2);
   }
-  async updateGroupIndex(params2) {
-    const merged = stripNil2(params2);
-    const groupId = String(merged.group_id ?? "").trim();
-    const settings = merged.settings;
-    if (!groupId) throw new Error("group_id is required");
-    if (!settings || typeof settings !== "object" || Array.isArray(settings) || Object.keys(settings).length === 0) {
-      throw new Error("settings must be a non-empty object");
-    }
-    const signer = merged.signer ?? this.client.currentAid;
-    if (!signer) throw new Error("signer is required");
-    const lastModified = Math.trunc(Number(merged.last_modified ?? Date.now()));
-    const maxAttempts = Math.max(1, Math.trunc(Number(merged.max_attempts ?? 2)));
-    let lastError = null;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const current = await this.getGroupIndex({ group_id: groupId });
-      const groupAid = String(current.group_aid ?? "").trim();
-      const currentIndex = current.group_index ?? null;
-      const expectedEtag = currentIndex ? String(parseGroupIndex(currentIndex).meta.etag ?? "") : "";
-      const baseSettings = current.settings && typeof current.settings === "object" && !Array.isArray(current.settings) ? current.settings : {};
-      const signedSettings = await prepareGroupSettingsWithIndex({
-        groupAid,
-        settings,
-        signer,
-        lastModified,
-        baseIndex: currentIndex
-      });
-      try {
-        const result = await this.setSettings({
-          group_id: groupId,
-          settings: signedSettings,
-          expected_index_etag: expectedEtag
-        });
-        const pushedEtag = String(parseGroupIndex(signedSettings[GROUP_INDEX_KEY]).meta.etag ?? "");
-        const clientAny = this.client;
-        if (typeof clientAny.cacheGroupIndexSettings === "function") {
-          const parsed = parseGroupIndex(signedSettings[GROUP_INDEX_KEY]);
-          await clientAny.cacheGroupIndexSettings(groupAid, { ...baseSettings, ...settings }, {
-            entries: parsed.entries,
-            etag: pushedEtag,
-            groupIndex: signedSettings[GROUP_INDEX_KEY]
-          });
-        }
-        return result;
-      } catch (exc) {
-        if (!String(exc?.message ?? exc).includes("etag conflict")) throw exc;
-        lastError = exc;
-      }
-    }
-    if (lastError) throw lastError;
-    throw new Error("updateGroupIndex failed");
+  delete(params2) {
+    return this.call("mail.delete", params2);
   }
-  async getIndexedSettings(groupId, keys) {
-    const clientAny = this.client;
-    if (typeof clientAny.getGroupIndexCachedSettings === "function") {
-      const cached = await clientAny.getGroupIndexCachedSettings(groupId, keys);
-      if (cached && typeof cached === "object") return { groupId, settings: cached };
-    }
-    const result = await this.getGroupIndex({ group_id: groupId });
-    const resultMap = result;
-    const allSettings = resultMap.settings && typeof resultMap.settings === "object" && !Array.isArray(resultMap.settings) ? resultMap.settings : {};
-    const settings = Object.fromEntries(keys.filter((key) => key in allSettings).map((key) => [key, allSettings[key]]));
-    const groupAid = String(resultMap.group_aid ?? "").trim();
-    if (groupAid && groupAid !== groupId && typeof clientAny.cacheGroupIndexSettings === "function" && resultMap.group_index) {
-      await clientAny.cacheGroupIndexSettings(groupId, allSettings, { entries: resultMap.entries, etag: String(resultMap.meta?.etag ?? ""), groupIndex: resultMap.group_index });
-    }
-    return { groupId: String(resultMap.group_id ?? groupId), settings };
+  move(params2) {
+    return this.call("mail.move", params2);
   }
-  async hydrateGroupIndexSettings(groupId, groupAid, entries, etag, groupIndex) {
-    const keys = entries.map((item) => String(item.key));
-    const clientAny = this.client;
-    const settings = {};
-    if (keys.length > 0) {
-      const fetchedResult = await this.getSettings({ group_id: groupId, keys });
-      const fetchedMap = fetchedResult;
-      if (String(fetchedMap.group_aid ?? "").trim() !== groupAid) throw new Error("group settings response group_aid does not match verified group.index");
-      const seen = /* @__PURE__ */ new Set();
-      for (const item of fetchedMap.settings ?? []) {
-        const key = String(item?.key ?? "").trim();
-        if (!key || seen.has(key)) throw new Error(`group settings response contains duplicate or empty key: ${key}`);
-        seen.add(key);
-        settings[key] = item?.value;
-      }
-      for (const entry of entries) {
-        const key = String(entry.key);
-        if (!seen.has(key)) throw new Error(`group.index setting is missing: ${key}`);
-        if (await groupIndexSettingEtag(settings[key]) !== String(entry.etag)) throw new Error(`group.index setting etag mismatch: ${key}`);
-      }
-    }
-    if (typeof clientAny.cacheGroupIndexSettings === "function") {
-      await clientAny.cacheGroupIndexSettings(groupAid, settings, { entries, etag, groupIndex });
-    }
-    return settings;
+  mark(params2) {
+    return this.call("mail.mark", params2);
+  }
+  search(params2) {
+    return this.call("mail.search", params2);
   }
-  validateGroupIndexEntries(entries) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const entry of entries) {
-      const key = String(entry?.key ?? "").trim();
-      const source = String(entry?.source ?? "").trim();
-      const etag = String(entry?.etag ?? "").trim();
-      if (!key) throw new Error("group.index entry key is required");
-      if (seen.has(key)) throw new Error(`group.index contains duplicate key: ${key}`);
-      if (source !== "db") throw new Error(`group.index entry source is unsupported: ${source || "<empty>"}`);
-      if (!etag) throw new Error(`group.index entry etag is required: ${key}`);
-      seen.add(key);
-    }
+  getAttachment(params2) {
+    return this.call("mail.get_attachment", params2);
   }
-  send(params2) {
-    validateGroupIDFormat(params2?.group_id, "group_id");
-    return this.call("group.send", params2);
+  getQuota(params2) {
+    return this.call("mail.get_quota", params2);
   }
-  recall(params2) {
-    return this.call("group.recall", params2);
+  health(params2) {
+    return this.call("mail.health", params2);
   }
-  pull(params2) {
-    validateGroupIDFormat(params2?.group_id, "group_id");
-    return this.call("group.pull", params2);
+  status(params2) {
+    return this.call("mail.status", params2);
   }
-  history(params2) {
-    return this.call("group.history", params2);
+};
+var GroupThoughtFacade = class extends RpcFacade {
+  put(params2) {
+    return this.call("group.thought.put", params2);
   }
-  pullEvents(params2) {
-    return this.call("group.pull_events", params2);
+  get(params2) {
+    return this.call("group.thought.get", params2);
   }
-  ackMessages(params2) {
-    return this.call("group.ack_messages", params2);
+};
+var GroupFacade = class extends RpcFacade {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_fs");
+    __publicField(this, "_thought");
   }
-  ackEvents(params2) {
-    return this.call("group.ack_events", params2);
+  get fs() {
+    if (!this._fs) this._fs = new GroupFSVFS(this.client);
+    return this._fs;
   }
-  documentSettingResult(groupId, keyName, settings) {
-    const contentKey = `${keyName}.content`;
-    const attachmentsKey = `${keyName}.attachments`;
-    return {
-      group_id: groupId,
-      setting: {
-        group_id: groupId,
-        key_name: keyName,
-        content: settings[contentKey] ?? "",
-        attachments: settings[attachmentsKey] ?? [],
-        updated_by: settings[`${contentKey}.updated_by`] ?? "",
-        updated_at: settings[`${contentKey}.updated_at`] ?? 0
-      }
-    };
+  get thought() {
+    if (!this._thought) this._thought = new GroupThoughtFacade(this.client);
+    return this._thought;
   }
-  async getSettingWithIndex(params2) {
-    const merged = params2 || {};
-    const groupId = merged.group_id;
-    if (!groupId) throw new Error("group_id is required");
-    const keyName = indexedDocumentKeyName(merged);
-    const { groupId: resultGroupId, settings } = await this.getIndexedSettings(
-      String(groupId),
-      [`${keyName}.content`, `${keyName}.attachments`]
-    );
-    return this.documentSettingResult(resultGroupId, keyName, settings);
+  create(params2) {
+    const split = splitAidStore(params2);
+    if (split.params.group_name === void 0 && split.params.groupName !== void 0) {
+      split.params.group_name = split.params.groupName;
+      delete split.params.groupName;
+    }
+    if (split.aidStore && typeof this.client.createGroup === "function") {
+      return this.client.createGroup(split.params, { aidStore: split.aidStore });
+    }
+    return this.call("group.create", split.params);
   }
-  async updateSettingWithIndex(params2) {
-    const merged = params2 || {};
-    const groupId = merged.group_id;
-    if (!groupId) throw new Error("group_id is required");
-    const keyName = indexedDocumentKeyName(merged);
-    if (!("content" in merged)) throw new Error("content is required");
-    const content = merged.content;
-    const attachments = merged.attachments ?? [];
-    const settingsUpdate = { [`${keyName}.content`]: content };
-    if ("attachments" in merged) {
-      settingsUpdate[`${keyName}.attachments`] = attachments;
+  bindAid(params2) {
+    return this.call("group.bind_aid", splitAidStore(params2).params);
+  }
+  bindGroupAid(params2) {
+    const split = splitAidStore(params2);
+    if (split.aidStore && typeof this.client.bindGroupAid === "function") {
+      return this.client.bindGroupAid(split.params, { aidStore: split.aidStore });
     }
-    const result = await this.updateGroupIndex(indexUpdateParams(groupId, settingsUpdate, merged));
-    const resultGroupId = String(result.group_id ?? groupId);
-    return {
-      group_id: resultGroupId,
-      setting: {
-        group_id: resultGroupId,
-        key_name: keyName,
-        content,
-        attachments,
-        updated_by: "",
-        updated_at: 0
-      }
-    };
+    return this.call("group.bind_group_aid", split.params);
   }
-  async getAnnouncement(params2) {
-    const merged = params2 || {};
-    const result = await this.getSettingWithIndex({ ...merged, keyName: "announcement" });
-    const resultMap = result;
-    const setting = resultMap.setting;
-    return {
-      group_id: resultMap.group_id,
-      announcement: {
-        group_id: setting.group_id,
-        content: setting.content,
-        attachments: setting.attachments,
-        updated_by: setting.updated_by,
-        updated_at: setting.updated_at
-      }
-    };
+  renewGroupAid(params2) {
+    const split = splitAidStore(params2);
+    if (typeof this.client.renewGroupAid === "function") {
+      return this.client.renewGroupAid(split.params, { aidStore: split.aidStore });
+    }
+    return this.call("group.renew_group_aid", split.params);
   }
-  async updateAnnouncement(params2) {
-    const merged = params2 || {};
-    const result = await this.updateSettingWithIndex({ ...merged, keyName: "announcement" });
-    const resultMap = result;
-    const setting = resultMap.setting;
-    return {
-      group_id: resultMap.group_id,
-      announcement: {
-        group_id: resultMap.group_id,
-        content: setting.content,
-        attachments: setting.attachments
-      }
-    };
+  getInfo(params2) {
+    return this.call("group.get_info", params2);
   }
-  async getRules(params2) {
-    const merged = params2 || {};
-    const result = await this.getSettingWithIndex({ ...merged, keyName: "rules" });
-    const resultMap = result;
-    const setting = resultMap.setting;
-    return {
-      group_id: resultMap.group_id,
-      rules: {
-        group_id: setting.group_id,
-        content: setting.content,
-        attachments: setting.attachments,
-        updated_by: setting.updated_by,
-        updated_at: setting.updated_at
-      }
-    };
+  update(params2) {
+    return this.call("group.update", params2);
   }
-  async updateRules(params2) {
-    const merged = params2 || {};
-    const result = await this.updateSettingWithIndex({ ...merged, keyName: "rules" });
-    const resultMap = result;
-    const setting = resultMap.setting;
-    return {
-      group_id: resultMap.group_id,
-      rules: {
-        group_id: resultMap.group_id,
-        content: setting.content,
-        attachments: setting.attachments
-      }
-    };
+  list(params2) {
+    return this.call("group.list", params2);
   }
-  async getJoinRequirements(params2) {
-    const merged = params2 || {};
-    const groupId = merged.group_id;
-    if (!groupId) throw new Error("group_id is required");
-    const { groupId: resultGroupId, settings } = await this.getIndexedSettings(
-      String(groupId),
-      ["join.mode", "join.question", "join.auto_approve_patterns", "join.max_pending", "join.attachments"]
-    );
-    return {
-      group_id: resultGroupId,
-      join_requirements: {
-        group_id: resultGroupId,
-        mode: settings["join.mode"] || "open",
-        question: settings["join.question"] || "",
-        auto_approve_patterns: settings["join.auto_approve_patterns"] || [],
-        max_pending: settings["join.max_pending"] || 100,
-        attachments: settings["join.attachments"] || [],
-        updated_by: settings["join.mode.updated_by"] || "",
-        updated_at: settings["join.mode.updated_at"] || 0
-      }
-    };
+  listMy(params2) {
+    return this.call("group.list_my", params2);
   }
-  async updateJoinRequirements(params2) {
-    const merged = params2 || {};
-    const groupId = merged.group_id;
-    if (!groupId) throw new Error("group_id is required");
-    const settingsUpdate = {};
-    if ("mode" in merged) settingsUpdate["join.mode"] = merged.mode;
-    if ("question" in merged) settingsUpdate["join.question"] = merged.question;
-    if ("auto_approve_patterns" in merged) settingsUpdate["join.auto_approve_patterns"] = merged.auto_approve_patterns;
-    if ("max_pending" in merged) settingsUpdate["join.max_pending"] = merged.max_pending;
-    if ("attachments" in merged) settingsUpdate["join.attachments"] = merged.attachments;
-    if (Object.keys(settingsUpdate).length === 0) {
-      throw new Error("at least one field to update is required");
-    }
-    const result = await this.updateGroupIndex(indexUpdateParams(groupId, settingsUpdate, merged));
-    return {
-      group_id: result.group_id,
-      join_requirements: {
-        group_id: result.group_id,
-        mode: merged.mode,
-        question: merged.question,
-        auto_approve_patterns: merged.auto_approve_patterns,
-        max_pending: merged.max_pending,
-        attachments: merged.attachments || []
-      }
-    };
+  search(params2) {
+    return this.call("group.search", params2);
   }
-  getOnlineMembers(params2) {
-    return this.call("group.get_online_members", params2);
+  suspend(params2) {
+    return this.call("group.suspend", params2);
   }
-};
-var StreamFacade = class extends RpcFacade {
-  create(params2) {
-    return this.call("stream.create", params2);
+  resume(params2) {
+    return this.call("group.resume", params2);
+  }
+  dissolve(params2) {
+    return this.call("group.dissolve", params2);
+  }
+  addMember(params2) {
+    return this.call("group.add_member", params2);
   }
-  close(params2) {
-    return this.call("stream.close", params2);
+  async inviteCall(method, params2) {
+    const normalized = normalizeInviteParams(params2);
+    try {
+      const result = await this.call(method, normalized);
+      await this.client._onGroupInviteActionResult?.(method, normalized, result);
+      return result;
+    } catch (error) {
+      await this.client._onGroupInviteActionResult?.(method, normalized, void 0, error);
+      throw error;
+    }
   }
-  getInfo(params2) {
-    return this.call("stream.get_info", params2);
+  inviteMember(params2) {
+    return this.inviteCall("group.invite_member", params2);
   }
-  listActive(params2) {
-    return this.call("stream.list_active", params2);
+  listMyInvites(params2) {
+    return this.inviteCall("group.list_my_invites", params2);
   }
-};
-
-// src/storage/types.ts
-function text2(value, fallback = "") {
-  if (value === null || value === void 0) return fallback;
-  return String(value);
-}
-function intValue(value, fallback = 0) {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? Math.trunc(parsed) : fallback;
-}
-function boolValue(value, fallback = false) {
-  if (value === null || value === void 0) return fallback;
-  return Boolean(value);
-}
-function mountSourceFromRaw(raw) {
-  const explicit = text2(raw.mount_source);
-  if (explicit) return explicit;
-  const sourceAid = text2(raw.source_aid);
-  if (!sourceAid) return "";
-  return `${sourceAid}:${keyToPath(raw.source_path)}`;
-}
-function normalizePath(path) {
-  let raw = String(path || "/").replace(/\\/g, "/").trim();
-  if (!raw.startsWith("/")) raw = `/${raw}`;
-  raw = raw.replace(/\/+/g, "/");
-  const parts = [];
-  for (const part of raw.split("/")) {
-    if (!part || part === ".") continue;
-    if (part === "..") {
-      parts.pop();
-      continue;
-    }
-    parts.push(part);
+  acceptInvite(params2) {
+    return this.inviteCall("group.accept_invite", params2);
   }
-  return parts.length ? `/${parts.join("/")}` : "/";
-}
-function pathToKey(path) {
-  const normalized = normalizePath(path);
-  return normalized === "/" ? "" : normalized.slice(1);
-}
-function keyToPath(key) {
-  return normalizePath(text2(key));
-}
-function nameFromPath(path) {
-  const cleaned = normalizePath(path).replace(/\/+$/g, "");
-  if (!cleaned || cleaned === "/") return "/";
-  return cleaned.split("/").pop() || "/";
-}
-function baseNode(raw, type, path) {
-  return {
-    type,
-    path,
-    name: text2(raw.name) || nameFromPath(path),
-    owner: text2(raw.owner ?? raw.owner_aid),
-    bucket: text2(raw.bucket, "default") || "default",
-    size: intValue(raw.size ?? raw.size_bytes),
-    mtime: intValue(raw.mtime ?? raw.updated_at),
-    contentType: text2(raw.content_type),
-    version: intValue(raw.version),
-    mode: text2(raw.mode),
-    isPublic: !boolValue(raw.is_private, true),
-    objectId: text2(raw.object_id),
-    folderId: text2(raw.folder_id),
-    target: text2(raw.target),
-    mountSource: mountSourceFromRaw(raw),
-    metadata: raw.metadata && typeof raw.metadata === "object" && !Array.isArray(raw.metadata) ? raw.metadata : {}
-  };
-}
-function nodeFromAny(input) {
-  const raw = input && typeof input === "object" ? input : {};
-  const nodeType = text2(raw.type ?? raw.node_type).toLowerCase();
-  if (["folder", "dir", "directory"].includes(nodeType)) return baseNode(raw, "dir", keyToPath(raw.path));
-  if (["symlink", "link"].includes(nodeType)) return baseNode(raw, "symlink", keyToPath(raw.path));
-  if (nodeType === "mount") return baseNode(raw, "mount", keyToPath(raw.path));
-  const path = keyToPath(raw.path ?? raw.object_key);
-  return {
-    ...baseNode(raw, "file", path),
-    sha256: text2(raw.sha256),
-    etag: text2(raw.etag)
-  };
-}
-function usageFromAny(input, ownerFallback = "") {
-  const raw = input && typeof input === "object" ? input : {};
-  const quota = intValue(raw.quota_bytes ?? raw.quota_total_bytes);
-  const used = intValue(raw.used_bytes ?? raw.quota_used_bytes);
-  return {
-    owner: text2(raw.owner ?? raw.owner_aid, ownerFallback),
-    quotaBytes: quota,
-    usedBytes: used,
-    availBytes: quota ? Math.max(0, quota - used) : 0,
-    objectCount: intValue(raw.object_count)
-  };
-}
-function unmountFromAny(input, fallback) {
-  const raw = input && typeof input === "object" ? input : {};
-  const path = keyToPath(raw.mount_path ?? raw.path ?? fallback.mountPath);
-  return {
-    unmounted: boolValue(raw.unmounted),
-    owner: text2(raw.owner ?? raw.owner_aid, fallback.owner ?? ""),
-    bucket: text2(raw.bucket, fallback.bucket ?? "default") || (fallback.bucket ?? "default"),
-    path,
-    mountPath: path
-  };
-}
-
-// src/storage/vfs.ts
-async function sha256Hex3(data) {
-  const copy = new Uint8Array(data.byteLength);
-  copy.set(data);
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle?.digest) throw new StorageError("SHA-256 unavailable", "EUNSUPPORTED");
-  const digest = await subtle.digest("SHA-256", copy.buffer);
-  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function toBytes2(data) {
-  if (typeof data === "string") return new TextEncoder().encode(data);
-  if (data instanceof Uint8Array) return data;
-  return new Uint8Array(data);
-}
-function textValue(value) {
-  if (value === void 0 || value === null) return "";
-  return String(value).trim();
-}
-function aidIssuer(aid) {
-  const value = textValue(aid).replace(/^\.+|\.+$/g, "").toLowerCase();
-  const separator = value.indexOf(".");
-  return separator >= 0 ? value.slice(separator + 1).replace(/^\.+|\.+$/g, "") : "";
-}
-function accessTokenFromClient2(client) {
-  const auth = client;
-  return textValue(
-    auth.accessToken ?? auth.access_token ?? auth._identity?.access_token ?? auth._sessionParams?.access_token ?? auth._session_params?.access_token
-  );
-}
-function isInlineFallbackError(error) {
-  const code = String(error.code).toUpperCase();
-  if (["EINLINE", "EINLINE_LIMIT", "ERR_INLINE_LIMIT", "INLINE_LIMIT", "-32033"].includes(code)) return true;
-  return error.code === -32602 && error.message.toLowerCase().includes("inline");
-}
-function parsePathLike(input, fallbackOwner) {
-  if (typeof input !== "string") {
-    return { owner: input.owner ?? fallbackOwner ?? null, path: input.path };
+  rejectInvite(params2) {
+    return this.inviteCall("group.reject_invite", params2);
   }
-  const match = input.match(/^([^:]+):(\/.*)$/);
-  if (match) {
-    return { owner: match[1], path: match[2] };
+  revokeInvite(params2) {
+    return this.inviteCall("group.revoke_invite", params2);
   }
-  return { owner: fallbackOwner ?? null, path: input };
-}
-var StorageVFS = class {
-  constructor(client, options = {}) {
-    __publicField(this, "lowlevel");
-    __publicField(this, "useFsRpc");
-    __publicField(this, "client");
-    this.client = client;
-    this.lowlevel = options.lowlevel ?? new StorageLowLevel(client);
-    this.useFsRpc = options.useFsRpc ?? true;
+  getMembers(params2) {
+    return this.call("group.get_members", params2);
   }
-  get defaultOwner() {
-    return this.client.aid ?? null;
+  kick(params2) {
+    return this.call("group.kick", params2);
   }
-  owner(owner) {
-    return owner || this.defaultOwner;
+  leave(params2) {
+    return this.call("group.leave", params2);
   }
-  downloadUrlAndHeaders(ticket, owner) {
-    const url = textValue(ticket.logical_url ?? ticket.download_url ?? ticket.url);
-    const currentAid = textValue(this.defaultOwner);
-    const targetAid = textValue(ticket.owner_aid ?? owner);
-    const currentIssuer = aidIssuer(currentAid);
-    const targetIssuer = aidIssuer(targetAid);
-    const sameIssuer = Boolean(currentAid && targetAid && (currentAid.toLowerCase() === targetAid.toLowerCase() || currentIssuer && targetIssuer && currentIssuer === targetIssuer));
-    const token = sameIssuer ? accessTokenFromClient2(this.client) : "";
-    return { url, headers: token ? { Authorization: `Bearer ${token}` } : void 0 };
+  setRole(params2) {
+    return this.call("group.set_role", params2);
   }
-  async writeBytes(path, input, options = {}) {
-    const data = toBytes2(input);
-    const owner = this.owner(options.owner);
-    const bucket = options.bucket ?? "default";
-    const objectKey = pathToKey(path);
-    const sha2566 = await sha256Hex3(data);
-    const overwrite = options.overwrite ?? false;
-    try {
-      const check = await this.lowlevel.checkUpload({ owner, bucket, objectKey, size: data.length, sha256: sha2566 });
-      if (check.within_limit === false) {
-        throw new StorageError(`file size exceeds max_file_size_bytes: ${data.length}`, "E2BIG", path, check);
-      }
-      if (check.target_exists && !overwrite && options.expectedVersion === void 0) {
-        throw new StorageExistsError(`remote path already exists: ${path}`, "EEXIST", path, check.target);
-      }
-      if (check.dedup_hit || check.skip_upload) {
-        const completed = await this.lowlevel.completeUpload({
-          owner,
-          bucket,
-          objectKey,
-          size: data.length,
-          sha256: sha2566,
-          contentType: options.contentType ?? "application/octet-stream",
-          metadata: options.metadata,
-          isPublic: options.public ?? false,
-          expectedVersion: options.expectedVersion,
-          skipBlob: true,
-          overwrite
-        });
-        return nodeFromAny(completed);
-      }
-      if (check.inline === true) {
-        return nodeFromAny(await this.lowlevel.putObject({
-          owner,
-          bucket,
-          objectKey,
-          content: data,
-          contentType: options.contentType ?? "application/octet-stream",
-          metadata: options.metadata,
-          isPublic: options.public ?? false,
-          expectedVersion: options.expectedVersion,
-          overwrite
-        }));
-      }
-      const session = await this.lowlevel.createUploadSession({
-        owner,
-        bucket,
-        objectKey,
-        size: data.length,
-        contentType: options.contentType,
-        expectedVersion: options.expectedVersion,
-        overwrite
-      });
-      const uploadUrl = String(session.upload_url ?? "");
-      if (!uploadUrl) throw new StorageError(`create_upload_session did not return upload_url`, "ESTORAGE", path);
-      await this.lowlevel.httpPut(uploadUrl, data, session.headers);
-      return nodeFromAny(await this.lowlevel.completeUpload({
-        owner,
-        bucket,
-        objectKey,
-        sessionId: String(session.session_id ?? ""),
-        size: data.length,
-        sha256: sha2566,
-        contentType: options.contentType,
-        metadata: options.metadata,
-        isPublic: options.public ?? false,
-        expectedVersion: options.expectedVersion,
-        overwrite
-      }));
-    } catch (exc) {
-      throw mapStorageError(exc, path);
+  transferOwner(params2) {
+    const split = splitAidStore(params2);
+    if (split.aidStore && typeof this.client.startGroupTransfer === "function") {
+      return this.client.startGroupTransfer(split.params, { aidStore: split.aidStore });
+    }
+    return this.call("group.transfer_owner", split.params);
+  }
+  completeTransfer(params2) {
+    const split = splitAidStore(params2);
+    if (split.aidStore && typeof this.client.completeGroupTransfer === "function") {
+      return this.client.completeGroupTransfer(split.params, { aidStore: split.aidStore });
     }
+    return this.call("group.complete_transfer", split.params);
   }
-  async readBytes(path, options = {}) {
-    return (await this.readBytesWithMetadata(path, options)).data;
+  ban(params2) {
+    return this.call("group.ban", params2);
   }
-  async readBytesWithMetadata(path, options = {}) {
-    const owner = this.owner(options.owner);
-    const bucket = options.bucket ?? "default";
-    const objectKey = pathToKey(path);
-    try {
-      const result = await this.lowlevel.getObject({ owner, bucket, objectKey, token: options.token, offset: options.offset, limit: options.limit });
-      return {
-        data: base64ToBytes(String(result.content ?? "")),
-        sha256: textValue(result.sha256)
-      };
-    } catch (exc) {
-      const mapped = mapStorageError(exc, path);
-      if (options.offset !== void 0 || options.limit !== void 0) throw mapped;
-      if (!isInlineFallbackError(mapped)) throw mapped;
-    }
-    const ticket = await this.lowlevel.createDownloadTicket({ owner, bucket, objectKey, token: options.token });
-    const { url: downloadUrl, headers } = this.downloadUrlAndHeaders(ticket, owner);
-    if (!downloadUrl) throw new StorageError(`create_download_ticket did not return download_url`, "ESTORAGE", path);
+  unban(params2) {
+    return this.call("group.unban", params2);
+  }
+  getBanlist(params2) {
+    return this.call("group.get_banlist", params2);
+  }
+  block(params2) {
+    return this.call("group.block", params2);
+  }
+  unblock(params2) {
+    return this.call("group.unblock", params2);
+  }
+  getBlocklist(params2) {
+    return this.call("group.get_blocklist", params2);
+  }
+  reportStatus(params2) {
+    return this.call("group.report_status", params2);
+  }
+  getMemberStatuses(params2) {
+    return this.call("group.get_member_statuses", params2);
+  }
+  requestJoin(params2) {
+    return this.call("group.request_join", params2);
+  }
+  listJoinRequests(params2) {
+    return this.call("group.list_join_requests", params2);
+  }
+  reviewJoinRequest(params2) {
+    return this.call("group.review_join_request", params2);
+  }
+  batchReviewJoinRequest(params2) {
+    return this.call("group.batch_review_join_request", params2);
+  }
+  createInviteCode(params2) {
+    return this.call("group.create_invite_code", params2);
+  }
+  listInviteCodes(params2) {
+    return this.call("group.list_invite_codes", params2);
+  }
+  useInviteCode(params2) {
+    return this.call("group.use_invite_code", params2);
+  }
+  revokeInviteCode(params2) {
+    return this.call("group.revoke_invite_code", params2);
+  }
+  setSettings(params2) {
+    return this.call("group.set_settings", params2);
+  }
+  getSettings(params2) {
+    return this.call("group.get_settings", params2);
+  }
+  async checkGroupIndex(params2) {
+    const merged = stripNil2(params2);
+    const groupAid = String(merged.group_aid ?? merged.group_id ?? "").trim();
+    if (!groupAid) throw new Error("group_aid is required");
+    const clientAny = this.client;
+    const stale = typeof clientAny.isGroupIndexStale === "function" ? Boolean(clientAny.isGroupIndexStale(groupAid)) : false;
+    const remoteMeta = typeof clientAny.getGroupIndexRemoteMeta === "function" ? clientAny.getGroupIndexRemoteMeta(groupAid) ?? {} : {};
+    const localEtag = typeof clientAny.getGroupIndexLocalEtag === "function" ? String(clientAny.getGroupIndexLocalEtag(groupAid) ?? "") : "";
+    const remoteEtag = String(remoteMeta?.etag ?? "");
+    const localFound = Boolean(localEtag);
+    const remoteFound = Boolean(remoteEtag);
+    const inSync = localFound && remoteFound && localEtag === remoteEtag;
     return {
-      data: headers ? await this.lowlevel.httpGet(downloadUrl, headers) : await this.lowlevel.httpGet(downloadUrl),
-      sha256: textValue(ticket.sha256)
+      group_aid: groupAid,
+      local_found: localFound,
+      remote_found: remoteFound,
+      local_etag: localEtag,
+      remote_etag: remoteEtag,
+      in_sync: inSync,
+      needs_update: Boolean(stale || remoteFound && !inSync),
+      last_modified: remoteMeta?.last_modified,
+      status: remoteFound ? 200 : 404,
+      cached: true
     };
   }
-  async downloadFile(path, options = {}) {
-    const { data, sha256: expectedSha } = await this.readBytesWithMetadata(path, options);
-    const actualSha = await sha256Hex3(data);
-    const expected = expectedSha.toLowerCase();
-    const verified = Boolean(expected) && actualSha.toLowerCase() === expected;
-    if (!verified && expected && (options.verifyHash ?? true)) {
-      throw new StorageError(
-        `hash mismatch: expected=${expected} actual=${actualSha.toLowerCase()}`,
-        "EHASH",
-        path
-      );
+  async getGroupIndex(params2) {
+    const merged = stripNil2(params2);
+    const groupId = String(merged.group_id ?? "").trim();
+    if (!groupId) throw new Error("group_id is required");
+    const result = await this.getSettings({ group_id: groupId, keys: [GROUP_INDEX_KEY] });
+    const resultMap = result;
+    const groupAid = String(resultMap.group_aid ?? "").trim();
+    if (!groupAid) throw new Error("group.get_settings response group_aid is required");
+    let groupIndex = null;
+    for (const item of result.settings ?? []) {
+      if (item?.key !== GROUP_INDEX_KEY) continue;
+      groupIndex = item.value;
+      break;
     }
+    if (!groupIndex) {
+      return { group_id: resultMap.group_id, group_aid: groupAid, group_index: null, meta: {}, entries: [], settings: {} };
+    }
+    const parsed = parseGroupIndex(groupIndex);
+    this.validateGroupIndexEntries(parsed.entries);
+    await this.verifyPulledGroupIndex(groupId, groupAid, groupIndex, parsed);
+    const etag = String(parsed.meta.etag ?? "");
+    const settings = await this.hydrateGroupIndexSettings(groupId, groupAid, parsed.entries, etag, groupIndex);
     return {
-      path,
-      size: data.length,
-      sha256: expectedSha || actualSha,
-      verified,
-      data
+      group_id: resultMap.group_id,
+      group_aid: groupAid,
+      group_index: groupIndex,
+      meta: parsed.meta,
+      entries: parsed.entries,
+      settings
     };
   }
-  async list(path, options = {}) {
-    if (options.recursive) {
-      const result = [];
-      const pending = [path];
-      while (pending.length) {
-        const current = pending.shift();
-        const children = await this.list(current, { ...options, recursive: false });
-        result.push(...children);
-        pending.push(...children.filter((node) => node.type === "dir").map((node) => node.path));
+  async verifyPulledGroupIndex(groupId, groupAid, groupIndex, parsed) {
+    if (String(parsed.meta?.group_aid ?? "").trim() !== groupAid) throw new Error("group.index group_aid does not match group.get_settings response");
+    const signedBy = String(parsed.meta?.signed_by ?? "").trim();
+    if (!signedBy) throw new Error("group.index signed_by is required");
+    const certFingerprint = String(parsed.meta?.cert_fingerprint ?? "").trim();
+    const clientAny = this.client;
+    const currentAid = clientAny.currentAid;
+    let signer = currentAid?.aid === signedBy && !certFingerprint ? currentAid : null;
+    if (currentAid?.aid === signedBy && certFingerprint && typeof currentAid.certPem === "string" && currentAid.certPem) {
+      try {
+        if (await certMatchesFingerprint(currentAid.certPem, certFingerprint)) signer = currentAid;
+      } catch {
+        signer = null;
+      }
+    }
+    if (!signer && typeof clientAny.lookupPeer === "function") {
+      signer = await clientAny.lookupPeer(signedBy, certFingerprint || void 0);
+    }
+    if (!signer) throw new Error(`group.index signer is unavailable: ${signedBy}`);
+    const verified = await verifyGroupIndex(groupIndex, signer);
+    if (!verified.ok) throw new Error(verified.error.message || "group.index verification failed");
+    if (!verified.data.valid) throw new Error(`group.index verification failed: ${verified.data.reason || "invalid signature"}`);
+    const adminsResult = await this.call("group.get_admins", { group_id: groupId });
+    const adminsMap = adminsResult;
+    if (String(adminsMap.group_aid ?? "").trim() !== groupAid) throw new Error("group.get_admins response group_aid does not match group.get_settings response");
+    const authorized = Array.isArray(adminsMap.admins) && adminsMap.admins.some(
+      (item) => String(item?.aid ?? "").trim() === signedBy && ["owner", "admin"].includes(String(item?.role ?? "").trim().toLowerCase())
+    );
+    if (!authorized) throw new Error(`group.index signer is not a current owner or admin: ${signedBy}`);
+  }
+  async updateGroupIndex(params2) {
+    const merged = stripNil2(params2);
+    const groupId = String(merged.group_id ?? "").trim();
+    const settings = merged.settings;
+    if (!groupId) throw new Error("group_id is required");
+    if (!settings || typeof settings !== "object" || Array.isArray(settings) || Object.keys(settings).length === 0) {
+      throw new Error("settings must be a non-empty object");
+    }
+    const signer = merged.signer ?? this.client.currentAid;
+    if (!signer) throw new Error("signer is required");
+    const lastModified = Math.trunc(Number(merged.last_modified ?? Date.now()));
+    const maxAttempts = Math.max(1, Math.trunc(Number(merged.max_attempts ?? 2)));
+    let lastError = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const current = await this.getGroupIndex({ group_id: groupId });
+      const groupAid = String(current.group_aid ?? "").trim();
+      const currentIndex = current.group_index ?? null;
+      const expectedEtag = currentIndex ? String(parseGroupIndex(currentIndex).meta.etag ?? "") : "";
+      const baseSettings = current.settings && typeof current.settings === "object" && !Array.isArray(current.settings) ? current.settings : {};
+      const signedSettings = await prepareGroupSettingsWithIndex({
+        groupAid,
+        settings,
+        signer,
+        lastModified,
+        baseIndex: currentIndex
+      });
+      try {
+        const result = await this.setSettings({
+          group_id: groupId,
+          settings: signedSettings,
+          expected_index_etag: expectedEtag
+        });
+        const pushedEtag = String(parseGroupIndex(signedSettings[GROUP_INDEX_KEY]).meta.etag ?? "");
+        const clientAny = this.client;
+        if (typeof clientAny.cacheGroupIndexSettings === "function") {
+          const parsed = parseGroupIndex(signedSettings[GROUP_INDEX_KEY]);
+          await clientAny.cacheGroupIndexSettings(groupAid, { ...baseSettings, ...settings }, {
+            entries: parsed.entries,
+            etag: pushedEtag,
+            groupIndex: signedSettings[GROUP_INDEX_KEY]
+          });
+        }
+        return result;
+      } catch (exc) {
+        if (!String(exc?.message ?? exc).includes("etag conflict")) throw exc;
+        lastError = exc;
+      }
+    }
+    if (lastError) throw lastError;
+    throw new Error("updateGroupIndex failed");
+  }
+  async getIndexedSettings(groupId, keys) {
+    const clientAny = this.client;
+    if (typeof clientAny.getGroupIndexCachedSettings === "function") {
+      const cached = await clientAny.getGroupIndexCachedSettings(groupId, keys);
+      if (cached && typeof cached === "object") return { groupId, settings: cached };
+    }
+    const result = await this.getGroupIndex({ group_id: groupId });
+    const resultMap = result;
+    const allSettings = resultMap.settings && typeof resultMap.settings === "object" && !Array.isArray(resultMap.settings) ? resultMap.settings : {};
+    const settings = Object.fromEntries(keys.filter((key) => key in allSettings).map((key) => [key, allSettings[key]]));
+    const groupAid = String(resultMap.group_aid ?? "").trim();
+    if (groupAid && groupAid !== groupId && typeof clientAny.cacheGroupIndexSettings === "function" && resultMap.group_index) {
+      await clientAny.cacheGroupIndexSettings(groupId, allSettings, { entries: resultMap.entries, etag: String(resultMap.meta?.etag ?? ""), groupIndex: resultMap.group_index });
+    }
+    return { groupId: String(resultMap.group_id ?? groupId), settings };
+  }
+  async hydrateGroupIndexSettings(groupId, groupAid, entries, etag, groupIndex) {
+    const keys = entries.map((item) => String(item.key));
+    const clientAny = this.client;
+    const settings = {};
+    if (keys.length > 0) {
+      const fetchedResult = await this.getSettings({ group_id: groupId, keys });
+      const fetchedMap = fetchedResult;
+      if (String(fetchedMap.group_aid ?? "").trim() !== groupAid) throw new Error("group settings response group_aid does not match verified group.index");
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of fetchedMap.settings ?? []) {
+        const key = String(item?.key ?? "").trim();
+        if (!key || seen.has(key)) throw new Error(`group settings response contains duplicate or empty key: ${key}`);
+        seen.add(key);
+        settings[key] = item?.value;
+      }
+      for (const entry of entries) {
+        const key = String(entry.key);
+        if (!seen.has(key)) throw new Error(`group.index setting is missing: ${key}`);
+        if (await groupIndexSettingEtag(settings[key]) !== String(entry.etag)) throw new Error(`group.index setting etag mismatch: ${key}`);
       }
-      return result;
     }
-    const owner = this.owner(options.owner);
-    const bucket = options.bucket ?? "default";
-    const key = pathToKey(path);
-    const raw = await this.lowlevel.fsList({
-      owner,
-      bucket,
-      path: key,
-      page: options.page,
-      size: options.size,
-      marker: options.marker,
-      token: options.token
-    });
-    const items = raw.nodes ?? raw.items ?? [];
-    return items.map((item) => nodeFromAny(item));
-  }
-  async stat(path, options = {}) {
-    const owner = this.owner(options.owner);
-    const raw = await this.lowlevel.fsStat({ owner, bucket: options.bucket ?? "default", path: pathToKey(path), token: options.token });
-    return nodeFromAny(raw);
+    if (typeof clientAny.cacheGroupIndexSettings === "function") {
+      await clientAny.cacheGroupIndexSettings(groupAid, settings, { entries, etag, groupIndex });
+    }
+    return settings;
   }
-  async lstat(path, options = {}) {
-    const owner = this.owner(options.owner);
-    const raw = await this.lowlevel.fsLstat({ owner, bucket: options.bucket ?? "default", path: pathToKey(path), token: options.token });
-    return nodeFromAny(raw);
+  validateGroupIndexEntries(entries) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const key = String(entry?.key ?? "").trim();
+      const source = String(entry?.source ?? "").trim();
+      const etag = String(entry?.etag ?? "").trim();
+      if (!key) throw new Error("group.index entry key is required");
+      if (seen.has(key)) throw new Error(`group.index contains duplicate key: ${key}`);
+      if (source !== "db") throw new Error(`group.index entry source is unsupported: ${source || "<empty>"}`);
+      if (!etag) throw new Error(`group.index entry etag is required: ${key}`);
+      seen.add(key);
+    }
   }
-  async mkdir(path, options = {}) {
-    const raw = await this.lowlevel.fsMkdir({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), parents: options.parents });
-    return nodeFromAny(raw.node ?? raw);
+  send(params2) {
+    validateGroupIDFormat(params2?.group_id, "group_id");
+    return this.call("group.send", params2);
   }
-  async touch(path, options = {}) {
-    const raw = await this.lowlevel.fsTouch({
-      owner: this.owner(options.owner),
-      bucket: options.bucket ?? "default",
-      path: pathToKey(path),
-      parents: options.parents,
-      noCreate: options.noCreate,
-      mtime: options.mtime,
-      followSymlinks: options.followSymlinks
-    });
-    return nodeFromAny(raw.node ?? raw);
+  recall(params2) {
+    return this.call("group.recall", params2);
   }
-  async remove(path, options = {}) {
-    const raw = await this.lowlevel.fsRemove({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), recursive: options.recursive });
-    return { path, removedCount: Number(raw.removed_count ?? raw.deleted_count ?? 0) };
+  pull(params2) {
+    validateGroupIDFormat(params2?.group_id, "group_id");
+    return this.call("group.pull", params2);
   }
-  async rename(src, dst, options = {}) {
-    const raw = await this.lowlevel.fsRename({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", src: pathToKey(src), dst: pathToKey(dst), overwrite: options.overwrite, expectedVersion: options.expectedVersion });
-    return nodeFromAny(raw.node ?? raw);
+  history(params2) {
+    return this.call("group.history", params2);
   }
-  async copy(src, dst, options = {}) {
-    const raw = await this.lowlevel.fsCopy({
-      owner: this.owner(options.owner),
-      bucket: options.bucket ?? "default",
-      src: pathToKey(src),
-      dst: pathToKey(dst),
-      overwrite: options.overwrite,
-      followSymlinks: options.followSymlinks,
-      recursive: options.recursive,
-      dstOwner: options.dstOwner,
-      dstBucket: options.dstBucket
-    });
-    return nodeFromAny(raw.node ?? raw);
+  pullEvents(params2) {
+    return this.call("group.pull_events", params2);
   }
-  async find(path, options = {}) {
-    const raw = await this.lowlevel.fsFind({
-      owner: this.owner(options.owner),
-      bucket: options.bucket ?? "default",
-      path: pathToKey(path),
-      name: options.name,
-      nodeType: options.nodeType,
-      size: options.size,
-      mtime: options.mtime,
-      page: options.page,
-      pageSize: options.pageSize,
-      token: options.token
-    });
-    const items = raw.nodes ?? raw.items ?? [];
-    return items.map((item) => nodeFromAny(item));
+  ackMessages(params2) {
+    return this.call("group.ack_messages", params2);
   }
-  async df(options = {}) {
-    const owner = this.owner(options.owner);
-    const raw = await this.lowlevel.fsDf({ owner, bucket: options.bucket ?? "default" });
-    return usageFromAny(raw, owner ?? void 0);
+  ackEvents(params2) {
+    return this.call("group.ack_events", params2);
   }
-  async du(path, options = {}) {
-    const nodes = await this.find(path, {
-      owner: options.owner,
-      bucket: options.bucket,
-      page: 1,
-      pageSize: options.pageSize ?? 1e3,
-      token: options.token
-    });
-    const rootParts = pathToKey(path).split("/").filter(Boolean);
-    let sizeBytes = 0;
-    let fileCount = 0;
-    let dirCount = 0;
-    let symlinkCount = 0;
-    let truncated = false;
-    for (const node of nodes) {
-      const nodeParts = pathToKey(node.path).split("/").filter(Boolean);
-      const depth = Math.max(0, nodeParts.length - rootParts.length);
-      if (options.maxDepth !== void 0 && depth > options.maxDepth) {
-        truncated = true;
-        continue;
-      }
-      if (node.type === "file") {
-        fileCount += 1;
-        sizeBytes += node.size;
-      } else if (node.type === "dir") {
-        dirCount += 1;
-      } else if (node.type === "symlink") {
-        symlinkCount += 1;
-      }
-    }
+  documentSettingResult(groupId, keyName, settings) {
+    const contentKey = `${keyName}.content`;
+    const attachmentsKey = `${keyName}.attachments`;
     return {
-      path,
-      sizeBytes,
-      fileCount,
-      dirCount,
-      symlinkCount,
-      maxDepth: options.maxDepth,
-      truncated
+      group_id: groupId,
+      setting: {
+        group_id: groupId,
+        key_name: keyName,
+        content: settings[contentKey] ?? "",
+        attachments: settings[attachmentsKey] ?? [],
+        updated_by: settings[`${contentKey}.updated_by`] ?? "",
+        updated_at: settings[`${contentKey}.updated_at`] ?? 0
+      }
     };
   }
-  async mount(source, mountPath, options = {}) {
-    const owner = this.owner(options.owner);
-    const mountRef = parsePathLike(mountPath, owner);
-    const sourceRef = parsePathLike(source, options.sourceOwner ?? this.defaultOwner);
-    const raw = await this.lowlevel.fsMount({
-      owner: mountRef.owner,
-      bucket: options.bucket ?? "default",
-      mountPath: pathToKey(mountRef.path),
-      sourceAid: String(sourceRef.owner ?? ""),
-      sourceBucket: options.sourceBucket,
-      sourcePath: pathToKey(sourceRef.path),
-      readonly: options.readonly,
-      expiresAt: options.expiresAt ?? options.expires,
-      requireApproval: options.requireApproval
-    });
-    return nodeFromAny(raw.node ?? raw.mount ?? raw);
-  }
-  async mountVolume(volumeId, mountPath, options = {}) {
-    const owner = this.owner(options.owner);
-    const mountRef = parsePathLike(mountPath, owner);
-    const raw = await this.lowlevel.fsMount({
-      owner: mountRef.owner,
-      bucket: options.bucket ?? "default",
-      mountPath: pathToKey(mountRef.path),
-      readonly: options.readonly,
-      expiresAt: options.expiresAt ?? options.expires,
-      requireApproval: options.requireApproval,
-      volumeId
-    });
-    return nodeFromAny(raw.node ?? raw.mount ?? raw);
-  }
-  approveMount(mountPath, options = {}) {
-    const owner = this.owner(options.owner);
-    const mountRef = parsePathLike(mountPath, owner);
-    return this.lowlevel.fsApprove({
-      owner: mountRef.owner,
-      bucket: options.bucket ?? "default",
-      mountPath: pathToKey(mountRef.path),
-      mountId: options.mountId,
-      requestId: options.requestId
-    });
-  }
-  rejectMount(mountPath, options = {}) {
-    const owner = this.owner(options.owner);
-    const mountRef = parsePathLike(mountPath, owner);
-    return this.lowlevel.fsReject({
-      owner: mountRef.owner,
-      bucket: options.bucket ?? "default",
-      mountPath: pathToKey(mountRef.path),
-      mountId: options.mountId,
-      requestId: options.requestId
-    });
-  }
-  async unmount(mountPath, options = {}) {
-    const owner = this.owner(options.owner);
-    const mountRef = parsePathLike(mountPath, owner);
-    const raw = await this.lowlevel.fsUnmount({
-      owner: mountRef.owner,
-      bucket: options.bucket ?? "default",
-      mountPath: pathToKey(mountRef.path)
-    });
-    return unmountFromAny(raw, {
-      owner: mountRef.owner,
-      bucket: options.bucket ?? "default",
-      mountPath: pathToKey(mountRef.path)
-    });
-  }
-  async symlink(target, linkPath, options = {}) {
-    const raw = await this.lowlevel.createSymlink({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(linkPath), target, overwrite: options.overwrite });
-    return nodeFromAny(raw.symlink ?? raw);
+  async getSettingWithIndex(params2) {
+    const merged = params2 || {};
+    const groupId = merged.group_id;
+    if (!groupId) throw new Error("group_id is required");
+    const keyName = indexedDocumentKeyName(merged);
+    const { groupId: resultGroupId, settings } = await this.getIndexedSettings(
+      String(groupId),
+      [`${keyName}.content`, `${keyName}.attachments`]
+    );
+    return this.documentSettingResult(resultGroupId, keyName, settings);
   }
-  async readlink(path, options = {}) {
-    const raw = await this.lowlevel.readlink({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path) });
-    return nodeFromAny(raw.symlink ?? raw);
+  async updateSettingWithIndex(params2) {
+    const merged = params2 || {};
+    const groupId = merged.group_id;
+    if (!groupId) throw new Error("group_id is required");
+    const keyName = indexedDocumentKeyName(merged);
+    if (!("content" in merged)) throw new Error("content is required");
+    const content = merged.content;
+    const attachments = merged.attachments ?? [];
+    const settingsUpdate = { [`${keyName}.content`]: content };
+    if ("attachments" in merged) {
+      settingsUpdate[`${keyName}.attachments`] = attachments;
+    }
+    const result = await this.updateGroupIndex(indexUpdateParams(groupId, settingsUpdate, merged));
+    const resultGroupId = String(result.group_id ?? groupId);
+    return {
+      group_id: resultGroupId,
+      setting: {
+        group_id: resultGroupId,
+        key_name: keyName,
+        content,
+        attachments,
+        updated_by: "",
+        updated_at: 0
+      }
+    };
   }
-  async repoint(path, newTarget, options = {}) {
-    const raw = await this.lowlevel.atomicRepoint({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), newTarget, expectedVersion: options.expectedVersion });
-    if (raw.ok === false) throw new StorageConflictError("symlink version conflict", "ECONFLICT", path, raw);
-    return nodeFromAny(raw.symlink ?? raw);
+  async getAnnouncement(params2) {
+    const merged = params2 || {};
+    const result = await this.getSettingWithIndex({ ...merged, keyName: "announcement" });
+    const resultMap = result;
+    const setting = resultMap.setting;
+    return {
+      group_id: resultMap.group_id,
+      announcement: {
+        group_id: setting.group_id,
+        content: setting.content,
+        attachments: setting.attachments,
+        updated_by: setting.updated_by,
+        updated_at: setting.updated_at
+      }
+    };
   }
-  async renameSymlink(src, dst, options = {}) {
-    const raw = await this.lowlevel.renameSymlink({
-      owner: this.owner(options.owner),
-      bucket: options.bucket ?? "default",
-      path: pathToKey(src),
-      newPath: pathToKey(dst),
-      overwrite: options.overwrite,
-      expectedVersion: options.expectedVersion
-    });
-    if (raw.ok === false) throw new StorageConflictError("symlink version conflict", "ECONFLICT", src, raw);
-    return nodeFromAny(raw.symlink ?? raw);
+  async updateAnnouncement(params2) {
+    const merged = params2 || {};
+    const result = await this.updateSettingWithIndex({ ...merged, keyName: "announcement" });
+    const resultMap = result;
+    const setting = resultMap.setting;
+    return {
+      group_id: resultMap.group_id,
+      announcement: {
+        group_id: resultMap.group_id,
+        content: setting.content,
+        attachments: setting.attachments
+      }
+    };
   }
-  setAcl(path, options) {
-    return this.lowlevel.setAcl({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), granteeAid: options.granteeAid, perms: options.perms, expiresAt: options.expiresAt, maxUses: options.maxUses });
+  async getRules(params2) {
+    const merged = params2 || {};
+    const result = await this.getSettingWithIndex({ ...merged, keyName: "rules" });
+    const resultMap = result;
+    const setting = resultMap.setting;
+    return {
+      group_id: resultMap.group_id,
+      rules: {
+        group_id: setting.group_id,
+        content: setting.content,
+        attachments: setting.attachments,
+        updated_by: setting.updated_by,
+        updated_at: setting.updated_at
+      }
+    };
   }
-  removeAcl(path, options) {
-    return this.lowlevel.removeAcl({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), granteeAid: options.granteeAid });
+  async updateRules(params2) {
+    const merged = params2 || {};
+    const result = await this.updateSettingWithIndex({ ...merged, keyName: "rules" });
+    const resultMap = result;
+    const setting = resultMap.setting;
+    return {
+      group_id: resultMap.group_id,
+      rules: {
+        group_id: resultMap.group_id,
+        content: setting.content,
+        attachments: setting.attachments
+      }
+    };
   }
-  listAcl(path, options = {}) {
-    return this.lowlevel.listAcl({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path) });
+  async getJoinRequirements(params2) {
+    const merged = params2 || {};
+    const groupId = merged.group_id;
+    if (!groupId) throw new Error("group_id is required");
+    const { groupId: resultGroupId, settings } = await this.getIndexedSettings(
+      String(groupId),
+      ["join.mode", "join.question", "join.auto_approve_patterns", "join.max_pending", "join.attachments"]
+    );
+    return {
+      group_id: resultGroupId,
+      join_requirements: {
+        group_id: resultGroupId,
+        mode: settings["join.mode"] || "open",
+        question: settings["join.question"] || "",
+        auto_approve_patterns: settings["join.auto_approve_patterns"] || [],
+        max_pending: settings["join.max_pending"] || 100,
+        attachments: settings["join.attachments"] || [],
+        updated_by: settings["join.mode.updated_by"] || "",
+        updated_at: settings["join.mode.updated_at"] || 0
+      }
+    };
   }
-  async setVisibility(path, options) {
-    const raw = await this.lowlevel.setVisibility({
-      owner: this.owner(options.owner),
-      bucket: options.bucket ?? "default",
-      path: pathToKey(path),
-      visibility: options.visibility,
-      allowRoles: options.allowRoles
-    });
-    return nodeFromAny(raw.node ?? raw);
+  async updateJoinRequirements(params2) {
+    const merged = params2 || {};
+    const groupId = merged.group_id;
+    if (!groupId) throw new Error("group_id is required");
+    const settingsUpdate = {};
+    if ("mode" in merged) settingsUpdate["join.mode"] = merged.mode;
+    if ("question" in merged) settingsUpdate["join.question"] = merged.question;
+    if ("auto_approve_patterns" in merged) settingsUpdate["join.auto_approve_patterns"] = merged.auto_approve_patterns;
+    if ("max_pending" in merged) settingsUpdate["join.max_pending"] = merged.max_pending;
+    if ("attachments" in merged) settingsUpdate["join.attachments"] = merged.attachments;
+    if (Object.keys(settingsUpdate).length === 0) {
+      throw new Error("at least one field to update is required");
+    }
+    const result = await this.updateGroupIndex(indexUpdateParams(groupId, settingsUpdate, merged));
+    return {
+      group_id: result.group_id,
+      join_requirements: {
+        group_id: result.group_id,
+        mode: merged.mode,
+        question: merged.question,
+        auto_approve_patterns: merged.auto_approve_patterns,
+        max_pending: merged.max_pending,
+        attachments: merged.attachments || []
+      }
+    };
   }
-  checkAccess(path, options = {}) {
-    return this.lowlevel.checkAccess({
-      owner: this.owner(options.owner),
-      bucket: options.bucket ?? "default",
-      path: pathToKey(path),
-      operation: options.operation ?? "read",
-      token: options.token,
-      followSymlinks: options.followSymlinks ?? true
-    });
+  getOnlineMembers(params2) {
+    return this.call("group.get_online_members", params2);
   }
-  issueToken(path, options = {}) {
-    return this.lowlevel.issueToken({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), expiresAt: options.expiresAt, maxReads: options.maxReads });
+};
+var StreamFacade = class extends RpcFacade {
+  create(params2) {
+    return this.call("stream.create", params2);
   }
-  revokeToken(path, options) {
-    return this.lowlevel.revokeToken({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path), token: options.token });
+  close(params2) {
+    return this.call("stream.close", params2);
   }
-  listTokens(path, options = {}) {
-    return this.lowlevel.listTokens({ owner: this.owner(options.owner), bucket: options.bucket ?? "default", path: pathToKey(path) });
+  getInfo(params2) {
+    return this.call("stream.get_info", params2);
   }
-  async getUsage(options = {}) {
-    const owner = this.owner(options.owner);
-    const raw = await this.lowlevel.getQuota({ owner, bucket: options.bucket ?? "default" });
-    return usageFromAny(raw, owner ?? "");
+  listActive(params2) {
+    return this.call("stream.list_active", params2);
   }
 };
 
@@ -24945,6 +25172,12 @@ var V2E2EECoordinator = class {
           await client._publishAppEvent(eventName, safeEvent, "pending_retry");
           continue;
         }
+        if (!entry.groupId && String(entry.msg.storage ?? "") === "volatile") {
+          await this.publishPendingV2VolatileMessage(entry.msg, plaintext, "pending_retry");
+          client._v2SenderIKPending.delete(key);
+          client._clientLog.debug(`V2 sender IK pending retry delivered: key=${key}`);
+          continue;
+        }
         client._v2SenderIKPending.delete(key);
         const seq2 = Number(entry.msg.seq ?? 0);
         if (entry.groupId) {
@@ -24961,6 +25194,27 @@ var V2E2EECoordinator = class {
       client._v2SenderIKFetching.delete(fetchKey);
     }
   }
+  async publishPendingV2VolatileMessage(rawMessage, plaintext, source) {
+    const delivery = this.client._delivery;
+    const claim = delivery.beginVolatileDelivery(rawMessage);
+    if (claim === "inflight") return;
+    if (claim === "seen") {
+      await delivery.ackVolatileMessages([rawMessage], true, false);
+      return;
+    }
+    try {
+      const publicMessage = delivery.publicVolatileMessage(plaintext);
+      for (const key of ["storage", "volatile_cursor", "created_at", "expires_at", "persist"]) {
+        if (key in rawMessage) publicMessage[key] = rawMessage[key];
+      }
+      const appEvent = delivery.p2pAppEventForMessage(publicMessage);
+      await this.client._publishAppEvent(appEvent.event, appEvent.payload, source);
+      delivery.markVolatileSeen(rawMessage);
+    } finally {
+      delivery.finishVolatileDelivery(rawMessage);
+    }
+    await delivery.ackVolatileMessages([rawMessage], true, false);
+  }
   async sendV2(to, payload, opts) {
     const client = this.client;
     await client._ensureV2SessionReady(
@@ -24968,6 +25222,7 @@ var V2E2EECoordinator = class {
       "V2 session not initialized; encrypted message.send requires V2 (V1 E2EE removed)"
     );
     const toAid = String(to ?? "").trim();
+    const targetDeviceId = String(opts?.deviceId ?? "").trim();
     if (!toAid) throw new ValidationError("message.send requires 'to'");
     if (!isJsonObject(payload)) throw new ValidationError("message.send payload must be a dict for V2 encryption");
     const attempt = async (useCache) => {
@@ -24976,6 +25231,7 @@ var V2E2EECoordinator = class {
         payload,
         messageId: opts?.messageId,
         timestamp: opts?.timestamp,
+        deviceId: targetDeviceId || void 0,
         protectedHeaders: opts?.protectedHeaders,
         context: opts?.context,
         useCache
@@ -24984,6 +25240,8 @@ var V2E2EECoordinator = class {
         to: toAid,
         payload: envelope,
         message_id: opts?.messageId,
+        ...opts?.ttl !== void 0 ? { ttl: opts.ttl } : {},
+        ...targetDeviceId ? { device_id: targetDeviceId } : {},
         encrypt: false,
         _skip_send_result_envelope: true
       });
@@ -25242,6 +25500,7 @@ var V2E2EECoordinator = class {
     const client = this.client;
     await client._ensureV2SessionReady("message.pull");
     const ns = client._aid ? `p2p:${client._aid}` : "";
+    let volatileCursor = String(opts?.afterVolatileCursor ?? client._delivery.volatilePullCursor() ?? "").trim();
     if (ns) client._delivery.onPullStarted?.(ns);
     if (opts?.windowMode === "tail") {
       if (!opts.gateLocked) {
@@ -25261,6 +25520,7 @@ var V2E2EECoordinator = class {
     if (ns && !opts?.gateLocked) {
       const key = pullGateKeyForClient(client, "message.v2.pull", {
         after_seq: afterSeq,
+        after_volatile_cursor: volatileCursor,
         force: opts?.force === true,
         limit
       }, `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`);
@@ -25273,6 +25533,7 @@ var V2E2EECoordinator = class {
     let nextAfterSeq = opts?.force ? afterSeq : afterSeq || (ns ? client._seqTracker.getContiguousSeq(ns) : 0);
     let pullGateKey = ns ? pullGateKeyForClient(client, "message.v2.pull", {
       after_seq: afterSeq,
+      after_volatile_cursor: volatileCursor,
       force: opts?.force === true,
       limit
     }, `${ns}|forward|after=${afterSeq}|force=${String(Boolean(opts?.force))}|limit=${limit}`) : "";
@@ -25284,14 +25545,26 @@ var V2E2EECoordinator = class {
     const maxPages = Math.max(1, Math.min(100, Math.trunc(Number(opts?.maxPages ?? 100) || 100)));
     while (pageCount < maxPages) {
       pageCount += 1;
+      const volatileCursorBeforePage = volatileCursor;
       const ackUpToSeq = pendingAckSeq;
       const pendingInlineGeneration = ackUpToSeq > 0 ? client._delivery?.pendingP2PInlineAckGeneration?.(ns) ?? null : null;
-      const result = await client._callRawV2Rpc("message.v2.pull", {
-        after_seq: nextAfterSeq,
-        limit,
-        ...opts?.force ? { force: true } : {},
-        ...ackUpToSeq > 0 ? { ack_up_to_seq: ackUpToSeq } : {}
-      }, pullGateKey);
+      let result;
+      try {
+        result = await client._callRawV2Rpc("message.v2.pull", {
+          after_seq: nextAfterSeq,
+          limit,
+          ...volatileCursor ? { after_volatile_cursor: volatileCursor } : {},
+          ...opts?.force ? { force: true } : {},
+          ...ackUpToSeq > 0 ? { ack_up_to_seq: ackUpToSeq } : {}
+        }, pullGateKey);
+      } catch (exc) {
+        const text3 = exc instanceof Error ? exc.message : String(exc);
+        if (!volatileCursor || !text3.toLowerCase().includes("volatile cursor epoch mismatch")) throw exc;
+        client._delivery.resetVolatilePullCursor();
+        volatileCursor = "";
+        pageCount -= 1;
+        continue;
+      }
       if (ackUpToSeq > 0) {
         const actualAckSeq = client._delivery?.resolveP2PPullAckSeq?.(result, ackUpToSeq) ?? 0;
         if (actualAckSeq >= ackUpToSeq) {
@@ -25309,6 +25582,12 @@ var V2E2EECoordinator = class {
         }
       }
       const pageMessages = Array.isArray(result?.messages) ? result.messages : [];
+      const volatileMessages = client._delivery.volatileMessages(pageMessages);
+      if (volatileMessages.length > 0) {
+        decrypted.push(...await this.publishV2VolatileMessages(volatileMessages, "pull", true));
+        volatileCursor = client._delivery.volatilePullCursor();
+      }
+      const volatileAdvanced = Boolean(volatileCursor) && volatileCursor !== volatileCursorBeforePage;
       const messages = deduplicateForwardPageMessages(pageMessages, nextAfterSeq);
       const cursor = isJsonObject(result.cursor) ? result.cursor : null;
       const hasMoreField = Object.prototype.hasOwnProperty.call(result, "has_more");
@@ -25485,7 +25764,7 @@ var V2E2EECoordinator = class {
       const nextAfter = Math.max(pageContiguousSeq, nextAfterSeq);
       const rawCount = messages.length;
       if (blockedSeq > 0) break;
-      const shouldContinue = shouldContinueForwardPage({
+      let shouldContinue = shouldContinueForwardPage({
         rawCount,
         nextAfterSeq,
         nextAfter,
@@ -25496,10 +25775,16 @@ var V2E2EECoordinator = class {
         pendingAckSeq,
         observedUpper: typeof client._seqTracker.getMaxSeenSeq === "function" ? client._seqTracker.getMaxSeenSeq(ns) : nextAfter
       });
+      const volatileHasMoreField = Object.prototype.hasOwnProperty.call(result, "volatile_has_more");
+      const volatileHasMore = result.volatile_has_more === true;
+      if (!shouldContinue && volatileAdvanced && (volatileHasMore || hasMore || !volatileHasMoreField && limit > 0 && pageMessages.length >= limit)) {
+        shouldContinue = true;
+      }
       if (!shouldContinue) break;
       if (pullGateKey && opts?.gateLocked && client._rpcPipeline?.yieldPullGate) {
         const nextKey = pullGateKeyForClient(client, "message.v2.pull", {
           after_seq: nextAfter,
+          after_volatile_cursor: volatileCursor,
           force: opts?.force === true,
           limit
         }, `${ns}|forward|after=${nextAfter}|force=${String(Boolean(opts?.force))}|limit=${limit}`);
@@ -25520,6 +25805,69 @@ var V2E2EECoordinator = class {
     client._delivery.onPullWorkSettled?.();
     return deduplicatePulledResults(decrypted);
   }
+  async publishV2VolatileMessages(messages, source, advanceCursor) {
+    const client = this.client;
+    if (!client._v2Session) return [];
+    const processed = [];
+    const plaintextMessages = [];
+    let complete = true;
+    for (const rawMessage of messages) {
+      const claim = client._delivery.beginVolatileDelivery(rawMessage);
+      if (claim === "seen") {
+        processed.push(rawMessage);
+        continue;
+      }
+      if (claim === "inflight") {
+        complete = false;
+        continue;
+      }
+      let plaintext;
+      try {
+        if (client._isEncryptedPushMessage(rawMessage)) {
+          plaintext = await client._decryptV2Message(rawMessage, true, true, true, true, void 0, false, source);
+        } else {
+          const legacy = isJsonObject(rawMessage.legacy_v1) ? rawMessage.legacy_v1 : {};
+          plaintext = {
+            message_id: String(rawMessage.message_id ?? ""),
+            from: String(rawMessage.from_aid ?? rawMessage.from ?? ""),
+            to: String(legacy.to ?? rawMessage.to ?? client._aid ?? ""),
+            type: String(rawMessage.type ?? ""),
+            timestamp: rawMessage.t_server ?? rawMessage.timestamp,
+            payload: legacy.payload !== void 0 ? legacy.payload : rawMessage.payload,
+            encrypted: false
+          };
+          for (const key of ["context", "protected_headers", "headers", "client_signature"]) {
+            if (key in rawMessage) plaintext[key] = rawMessage[key];
+          }
+          if (rawMessage.sender_device_id !== void 0) plaintext.sender_device_id = rawMessage.sender_device_id;
+          attachGatewayProximity(plaintext, rawMessage);
+        }
+        if (!plaintext) {
+          complete = false;
+          continue;
+        }
+        const publicMessage = client._delivery.publicVolatileMessage(plaintext);
+        for (const key of ["storage", "volatile_cursor", "created_at", "expires_at", "persist"]) {
+          if (key in rawMessage) publicMessage[key] = rawMessage[key];
+        }
+        const appEvent = client._delivery.p2pAppEventForMessage(publicMessage);
+        await client._publishAppEvent(appEvent.event, appEvent.payload, source);
+        client._delivery.markVolatileSeen(rawMessage);
+        processed.push(rawMessage);
+        plaintextMessages.push(publicMessage);
+      } finally {
+        client._delivery.finishVolatileDelivery(rawMessage);
+      }
+    }
+    if (processed.length > 0) {
+      await client._delivery.ackVolatileMessages(
+        processed,
+        true,
+        advanceCursor && complete && processed.length === messages.length
+      );
+    }
+    return plaintextMessages;
+  }
   async confirmForwardP2PAck(upToSeq, inlineGeneration) {
     const ns = this.client._aid ? `p2p:${this.client._aid}` : "";
     try {
@@ -25534,34 +25882,41 @@ var V2E2EECoordinator = class {
       throw exc;
     }
   }
-  async ackV2(upToSeq, inlineGeneration) {
-    return this.ackV2WithConfirmation(upToSeq, inlineGeneration, false);
+  async ackV2(upToSeq, inlineGeneration, volatileCursors = [], volatileIds = []) {
+    return this.ackV2WithConfirmation(upToSeq, inlineGeneration, false, volatileCursors, volatileIds);
   }
   async ackV2ForForward(upToSeq, inlineGeneration) {
     return this.ackV2WithConfirmation(upToSeq, inlineGeneration, true);
   }
-  async ackV2WithConfirmation(upToSeq, inlineGeneration, requireServerWatermark) {
+  async ackV2WithConfirmation(upToSeq, inlineGeneration, requireServerWatermark, volatileCursors = [], volatileIds = []) {
     const client = this.client;
     const ns = client._aid ? `p2p:${client._aid}` : "";
     let seq2 = upToSeq ?? (ns ? client._seqTracker.getContiguousSeq(ns) : 0);
-    if (typeof seq2 !== "number" || !Number.isSafeInteger(seq2) || seq2 <= 0) return { acked: 0 };
-    seq2 = client._clampAckSeq("message.v2.ack", "up_to_seq", ns, seq2);
-    if (!Number.isSafeInteger(seq2) || seq2 <= 0) return { acked: 0 };
+    if (typeof seq2 !== "number" || !Number.isSafeInteger(seq2) || seq2 <= 0) seq2 = 0;
+    if (seq2 <= 0 && volatileCursors.length === 0 && volatileIds.length === 0) return { acked: 0 };
+    if (seq2 > 0) seq2 = client._clampAckSeq("message.v2.ack", "up_to_seq", ns, seq2);
+    if ((!Number.isSafeInteger(seq2) || seq2 <= 0) && volatileCursors.length === 0 && volatileIds.length === 0) {
+      return { acked: 0 };
+    }
     const ackGeneration = inlineGeneration ?? client._delivery?.pendingP2PInlineAckGeneration?.(ns) ?? null;
     const v2SessionAtStart = client._v2Session;
     const v2RuntimeGenerationAtStart = Number(client._v2RuntimeGeneration ?? 0);
-    const raw = await client._callRawV2Rpc("message.v2.ack", { up_to_seq: seq2 });
+    const raw = await client._callRawV2Rpc("message.v2.ack", {
+      ...seq2 > 0 ? { up_to_seq: seq2 } : {},
+      ...volatileCursors.length > 0 ? { volatile_cursors: volatileCursors } : {},
+      ...volatileIds.length > 0 ? { volatile_ids: volatileIds } : {}
+    });
     const result = isJsonObject(raw) ? { ...raw } : { result: raw };
-    const actualAckSeq = requireServerWatermark ? client._delivery?.resolveForwardAckSeq?.(result, seq2) ?? 0 : client._delivery?.resolveActualAckSeq?.(result, seq2) ?? seq2;
-    if (requireServerWatermark && actualAckSeq < seq2) {
+    const actualAckSeq = seq2 > 0 ? requireServerWatermark ? client._delivery?.resolveForwardAckSeq?.(result, seq2) ?? 0 : client._delivery?.resolveActualAckSeq?.(result, seq2) ?? seq2 : 0;
+    if (seq2 > 0 && requireServerWatermark && actualAckSeq < seq2) {
       throw new E2EEError(`message.v2.ack server ACK watermark ${actualAckSeq} is below requested ${seq2}`);
     }
     result.ack_seq = actualAckSeq;
     result.success = true;
-    if (ackGeneration !== null) {
+    if (seq2 > 0 && ackGeneration !== null) {
       client._delivery?.completePendingP2PInlineAckUpTo?.(ns, actualAckSeq, ackGeneration);
     }
-    if (v2SessionAtStart && client._v2Session === v2SessionAtStart && Number(client._v2RuntimeGeneration ?? 0) === v2RuntimeGenerationAtStart) {
+    if (seq2 > 0 && v2SessionAtStart && client._v2Session === v2SessionAtStart && Number(client._v2RuntimeGeneration ?? 0) === v2RuntimeGenerationAtStart) {
       try {
         const destroyed = await v2SessionAtStart.maybeDestroyOldSPKs(actualAckSeq);
         if (client._v2Session === v2SessionAtStart && Number(client._v2RuntimeGeneration ?? 0) === v2RuntimeGenerationAtStart && destroyed.length > 0) {
@@ -26525,7 +26880,6 @@ var V2E2EECoordinator = class {
       seq: msg.seq ?? null,
       timestamp: msg.timestamp ?? msg.t_server ?? null,
       device_id: msg.device_id ?? null,
-      slot_id: msg.slot_id ?? null,
       _decrypt_error: "encrypted push payload is not decryptable on raw push path",
       _decrypt_stage: "push_envelope"
     };
@@ -26566,10 +26920,11 @@ var V2E2EECoordinator = class {
       encrypted: true,
       e2ee: e2eeMeta
     };
+    const senderDeviceId = String(aad.from_device ?? "").trim();
+    if (senderDeviceId) result.sender_device_id = senderDeviceId;
     result.direction = fromAid && fromAid === client._aid ? "outbound_sync" : "inbound";
     if (msg.t_server !== void 0) result.t_server = msg.t_server;
     if (msg.device_id !== void 0) result.device_id = msg.device_id;
-    if (msg.slot_id !== void 0) result.slot_id = msg.slot_id;
     attachGatewayProximity(result, msg);
     if (group) {
       result.group_id = msg.group_id ?? aad.group_id ?? envelope.group_id ?? null;
@@ -26643,6 +26998,10 @@ var V2E2EECoordinator = class {
     if (peerDevices.length === 0) {
       throw new E2EEError(`V2 bootstrap: no devices found for ${to}`);
     }
+    const targetDeviceId = String(opts.deviceId ?? "").trim();
+    if (targetDeviceId && !peerDevices.some((dev) => String(dev.device_id ?? "").trim() === targetDeviceId)) {
+      throw new E2EEError(`V2 bootstrap: target device ${targetDeviceId} not found for ${to}`);
+    }
     let targetSet = useCache ? this.getTargetSetCache(to) : void 0;
     if (targetSet) {
       targetSet = this.cloneP2PTargetSet(targetSet);
@@ -26713,6 +27072,17 @@ var V2E2EECoordinator = class {
       });
       targetSet = this.cloneP2PTargetSet(targetSet);
     }
+    if (targetDeviceId) {
+      let peerTargetFound = false;
+      targetSet.targets = targetSet.targets.filter((target) => {
+        const isPeerTarget = target.aid === to && (target.deviceId === targetDeviceId || wrapPolicy?.scope === "aid" && !target.deviceId) && target.role !== "self_sync";
+        if (isPeerTarget) peerTargetFound = true;
+        return isPeerTarget || target.role === "self_sync";
+      });
+      if (!peerTargetFound) {
+        throw new E2EEError(`V2 bootstrap: target device ${targetDeviceId} not found for ${to}`);
+      }
+    }
     const sender = await session.getSenderIdentity();
     const envelope = await encryptP2PMessage(
       sender,
@@ -27070,6 +27440,9 @@ function groupCacheIds(raw, groupId, explicitGroupAid) {
 var GroupStateCoordinator = class {
   constructor(runtime) {
     __publicField(this, "runtime");
+    __publicField(this, "ownerTransferInflight", /* @__PURE__ */ new Set());
+    __publicField(this, "ownerTransferCompletedSeq", /* @__PURE__ */ new Map());
+    __publicField(this, "ownerTransferCompletedLegacy", /* @__PURE__ */ new Set());
     this.runtime = runtime;
   }
   get client() {
@@ -27102,6 +27475,7 @@ var GroupStateCoordinator = class {
     if (!groupId) {
       return;
     }
+    this.handleOwnerTransferEvent(data, groupId, action);
     for (const cacheGroupId of groupCacheIds(rawGroupId, groupId, data.group_aid ?? data.groupAid)) {
       client._v2E2EE?.deleteBootstrapCacheEntry?.(`group:${cacheGroupId}`);
     }
@@ -27111,6 +27485,60 @@ var GroupStateCoordinator = class {
     }
     client._v2E2EE?.handleGroupChangedSpk?.(data, groupId, action);
   }
+  handleOwnerTransferEvent(data, groupId, action) {
+    const status = String(data.status ?? "").trim();
+    if (action !== "owner_transfer_rekey_pending" && action !== "owner_transferred") return;
+    const eventSeq = Number(data.event_seq ?? 0);
+    const normalizedEventSeq = Number.isSafeInteger(eventSeq) && eventSeq > 0 ? eventSeq : 0;
+    const transferKey = [groupId, data.old_owner, data.new_owner].map((value) => String(value ?? "").trim().toLowerCase()).join("|");
+    if (action === "owner_transferred" && status === "transferred") {
+      if (normalizedEventSeq > 0) {
+        this.ownerTransferCompletedSeq.set(
+          groupId,
+          Math.max(normalizedEventSeq, this.ownerTransferCompletedSeq.get(groupId) ?? 0)
+        );
+      } else {
+        this.ownerTransferCompletedLegacy.add(transferKey);
+      }
+      return;
+    }
+    if (action !== "owner_transfer_rekey_pending" || status !== "pending_rekey") return;
+    const client = this.client;
+    const currentAid = String(client._aid ?? "").trim();
+    const newOwner = String(data.new_owner ?? "").trim();
+    const store = client._aidStore;
+    if (!currentAid || currentAid.toLowerCase() !== newOwner.toLowerCase() || !store) return;
+    if (this.ownerTransferInflight.has(groupId)) return;
+    if (normalizedEventSeq > 0) {
+      if ((this.ownerTransferCompletedSeq.get(groupId) ?? 0) >= normalizedEventSeq) return;
+    } else if (this.ownerTransferCompletedLegacy.has(transferKey)) {
+      return;
+    }
+    this.ownerTransferInflight.add(groupId);
+    const params2 = { group_id: groupId };
+    const groupAid = String(data.group_aid ?? "").trim();
+    if (groupAid) params2.group_aid = groupAid;
+    const task = (async () => {
+      try {
+        await client.completeGroupTransfer(params2, { aidStore: store });
+        if (normalizedEventSeq > 0) {
+          this.ownerTransferCompletedSeq.set(
+            groupId,
+            Math.max(normalizedEventSeq, this.ownerTransferCompletedSeq.get(groupId) ?? 0)
+          );
+        } else {
+          this.ownerTransferCompletedLegacy.add(transferKey);
+        }
+      } catch (exc) {
+        client._clientLog.debug(
+          `automatic group owner transfer completion failed: group=${groupId} err=${String(formatCaughtError(exc))}`
+        );
+      } finally {
+        this.ownerTransferInflight.delete(groupId);
+      }
+    })();
+    client._safeAsync(task);
+  }
   async onV2StateProposed(data) {
     const client = this.client;
     if (!isJsonObject(data) || !client._v2Session) return;
@@ -28822,6 +29250,7 @@ var AgentMdManager = class _AgentMdManager {
     __publicField(this, "_uploadViaGatewayHost");
     __publicField(this, "_tokenStore");
     __publicField(this, "_log");
+    __publicField(this, "_onChanged");
     __publicField(this, "_ownerAidGetter");
     __publicField(this, "_currentAidGetter");
     __publicField(this, "_gatewayResolver");
@@ -28839,6 +29268,7 @@ var AgentMdManager = class _AgentMdManager {
     this._uploadViaGatewayHost = opts.uploadViaGatewayHost ?? false;
     this._tokenStore = opts.tokenStore;
     this._log = opts.logger ?? noopLogger;
+    this._onChanged = opts.onChanged;
     this._ownerAidGetter = opts.ownerAidGetter;
     this._currentAidGetter = opts.currentAidGetter;
     this._gatewayResolver = opts.gatewayResolver;
@@ -29042,6 +29472,9 @@ var AgentMdManager = class _AgentMdManager {
     let before = this._cache.get(target);
     if (!before || typeof before !== "object") before = await this.loadRecord(target) ?? {};
     const same = (!remoteEtag || String(before.remote_etag ?? "").trim() === remoteEtag) && (!remoteLastModified || String(before.last_modified ?? "").trim() === remoteLastModified);
+    const hadRemoteVersion = Boolean(
+      String(before.remote_etag ?? "").trim() || String(before.last_modified ?? "").trim()
+    );
     let record = { ...before };
     if (!same || Object.keys(before).length === 0) {
       const fields = {
@@ -29050,7 +29483,9 @@ var AgentMdManager = class _AgentMdManager {
       };
       if (remoteEtag) fields.remote_etag = remoteEtag;
       if (remoteLastModified) fields.last_modified = remoteLastModified;
-      record = await this.saveRecord(target, fields) || record;
+      const saved = await this.saveRecord(target, fields);
+      record = saved || record;
+      if (Object.keys(saved).length > 0 && hadRemoteVersion && !same) this._onChanged?.(target);
     }
     await this._scheduleFetchIfMissing(target, record, source);
     this._log.debug(`agent.md meta observed: aid=${target} etag=${remoteEtag || "-"} last_modified=${remoteLastModified || "-"} source=${source || "-"}`);
@@ -29606,6 +30041,7 @@ function createAgentMdManagerForRuntime(opts) {
   return new AgentMdManager({
     aunPath: opts.config().aunPath,
     tokenStore: opts.tokenStore(),
+    onChanged: (aid) => opts.dispatcher().enqueue("agentmd.changed", aid),
     uploadViaGatewayHost: true,
     logger: opts.logger(),
     ownerAidGetter: opts.ownerAid,
@@ -30018,6 +30454,7 @@ var _AUNClient = class _AUNClient {
     this._agentMdManager = createAgentMdManagerForRuntime({
       config: () => this.configModel,
       logger: () => this._logger.for("aun_core.agent_md"),
+      dispatcher: () => this._dispatcher,
       ownerAid: () => this._aid,
       currentAid: () => this._currentAid,
       gateway: {
@@ -30418,6 +30855,7 @@ var _AUNClient = class _AUNClient {
     this._agentMdManager = createAgentMdManagerForRuntime({
       config: () => this.configModel,
       logger: () => this._logger.for("aun_core.agent_md"),
+      dispatcher: () => this._dispatcher,
       ownerAid: () => this._aid,
       currentAid: () => this._currentAid,
       gateway: {
@@ -30602,12 +31040,18 @@ var _AUNClient = class _AUNClient {
     for (const raw of groups) {
       if (!isJsonObject(raw)) continue;
       const role = String(raw.role ?? raw.my_role ?? "").trim().toLowerCase();
-      if (role !== "owner") continue;
       const groupId = String(raw.group_id ?? raw.groupId ?? raw.group_aid ?? raw.groupAid ?? "").trim();
       const groupAid = String(raw.group_aid ?? raw.groupAid ?? groupId).trim();
       if (!groupId || !groupAid) continue;
+      const keystore = store._keystore;
+      const pendingTransfer = keystore && typeof keystore.loadPendingGroupBind === "function" ? await keystore.loadPendingGroupBind(`complete:${groupId}`) : null;
+      if (role !== "owner" && !pendingTransfer) continue;
       try {
         await this._runGroupIdentityOperation(groupId, async () => {
+          if (pendingTransfer) {
+            await this.completeGroupTransfer({ group_id: groupId, group_aid: groupAid }, { aidStore: store });
+            return;
+          }
           const loaded = await store.load(groupAid);
           if (!loaded.ok || !loaded.data?.aid?.isPrivateKeyValid()) {
             await this.bindGroupAid({ group_id: groupId, group_aid: groupAid }, { aidStore: store });
@@ -30660,6 +31104,36 @@ var _AUNClient = class _AUNClient {
     if (!isNamed) {
       delete payload.public_key;
       delete payload.curve;
+      const keystore2 = store._keystore;
+      const pendingName = String(payload.name ?? "").trim().toLowerCase();
+      const pendingNameHash = bytesToHex8(new Uint8Array(await globalThis.crypto.subtle.digest(
+        "SHA-256",
+        new TextEncoder().encode(pendingName)
+      )));
+      const pendingKey2 = `create-anonymous:${pendingNameHash}`;
+      let keyPair2 = null;
+      if (keystore2 && typeof keystore2.loadPendingGroupBind === "function") {
+        keyPair2 = await keystore2.loadPendingGroupBind(pendingKey2);
+      }
+      if (!keyPair2 || !keyPair2.public_key_der_b64 || !keyPair2.private_key_pem) {
+        const generated = await new CryptoProvider().generateIdentity();
+        keyPair2 = {
+          private_key_pem: generated.private_key_pem,
+          public_key_der_b64: generated.public_key_der_b64,
+          curve: generated.curve
+        };
+        if (keystore2 && typeof keystore2.savePendingGroupBind === "function") {
+          await keystore2.savePendingGroupBind(pendingKey2, keyPair2);
+        }
+      }
+      if (!keyPair2?.public_key_der_b64 || !keyPair2.private_key_pem) {
+        throw new ValidationError("createGroup: failed to generate or load key pair");
+      }
+      const requestHash = bytesToHex8(new Uint8Array(await globalThis.crypto.subtle.digest(
+        "SHA-256",
+        new TextEncoder().encode(keyPair2.public_key_der_b64)
+      )));
+      payload._create_request_id = `anon:${requestHash}`;
       const created = await this.call("group.create", payload);
       const createdMap = isJsonObject(created) ? created : {};
       const createdGroup = isJsonObject(createdMap.group) ? createdMap.group : {};
@@ -30667,6 +31141,9 @@ var _AUNClient = class _AUNClient {
       if (!groupId) {
         throw new ValidationError("group.create response missing group.group_id");
       }
+      if (keystore2 && typeof keystore2.savePendingGroupBind === "function") {
+        await keystore2.savePendingGroupBind(`bind:${groupId}`, keyPair2);
+      }
       const bindParams = { group_id: groupId };
       for (const key of ["name", "description", "group_description", "avatar", "group_agent_md", "groupAgentMd", "content"]) {
         if (key in payload) bindParams[key] = payload[key];
@@ -30680,15 +31157,26 @@ var _AUNClient = class _AUNClient {
       const result2 = { ...createdMap, ...boundMap, group: { ...createdGroup, ...boundGroup } };
       const postprocessParams2 = { ...payload };
       delete postprocessParams2._defer_group_ready_postprocess;
+      delete postprocessParams2._create_request_id;
       const processed2 = await this._groupState.postprocessResult("group.create", postprocessParams2, result2);
-      return await this._inviteInitialGroupMembers(processed2, groupId, initialMembers);
+      const completed = await this._inviteInitialGroupMembers(processed2, groupId, initialMembers);
+      if (keystore2 && typeof keystore2.clearPendingGroupBind === "function") {
+        await keystore2.clearPendingGroupBind(pendingKey2);
+      }
+      return completed;
     }
-    const pendingKey = `create:${String(payload.group_name).trim().toLowerCase()}`;
+    const groupName = String(payload.group_name).trim().toLowerCase();
+    const pendingKey = `create:${groupName}`;
     const keystore = store._keystore;
     let keyPair = null;
     if (keystore && typeof keystore.loadPendingGroupBind === "function") {
       keyPair = await keystore.loadPendingGroupBind(pendingKey);
     }
+    if ((!keyPair || !keyPair.public_key_der_b64 || !keyPair.private_key_pem) && keystore && typeof keystore.loadIdentity === "function") {
+      const ownerAid = String(this._aid ?? "").trim();
+      const dot = ownerAid.indexOf(".");
+      if (dot >= 0) keyPair = await keystore.loadIdentity(`${groupName}.${ownerAid.slice(dot + 1).toLowerCase()}`);
+    }
     if (!keyPair || !keyPair.public_key_der_b64 || !keyPair.private_key_pem) {
       const generated = await new CryptoProvider().generateIdentity();
       keyPair = {
@@ -32785,8 +33273,8 @@ ${invitee}` : "";
    *
    * @param upToSeq 确认到此 seq；省略则用当前 contiguous
    */
-  async _ackV2(upToSeq, inlineGeneration) {
-    return await this._v2E2EE.ackV2(upToSeq, inlineGeneration);
+  async _ackV2(upToSeq, inlineGeneration, volatileCursors = [], volatileIds = []) {
+    return await this._v2E2EE.ackV2(upToSeq, inlineGeneration, volatileCursors, volatileIds);
   }
   /**
    * 解密单条 V2 消息（与 Python `_decrypt_v2_message` 对齐）。
@@ -32878,7 +33366,6 @@ ${invitee}` : "";
             seq: msg.seq,
             timestamp: msg.t_server ?? msg.timestamp,
             device_id: String(msg.device_id ?? ""),
-            slot_id: String(msg.slot_id ?? ""),
             _decrypt_error: String(exc),
             _decrypt_stage: "spk_lookup",
             _envelope_type: String(envelope.type ?? ""),
@@ -32921,7 +33408,6 @@ ${invitee}` : "";
             seq: msg.seq,
             timestamp: msg.t_server ?? msg.timestamp,
             device_id: String(msg.device_id ?? ""),
-            slot_id: String(msg.slot_id ?? ""),
             _decrypt_error: "sender_ik_not_found",
             _decrypt_stage: "sender_ik",
             _envelope_type: String(envelope.type ?? ""),
@@ -32958,7 +33444,6 @@ ${invitee}` : "";
             seq: msg.seq,
             timestamp: msg.t_server ?? msg.timestamp,
             device_id: String(msg.device_id ?? ""),
-            slot_id: String(msg.slot_id ?? ""),
             _decrypt_error: String(exc),
             _decrypt_stage: "decrypt",
             _envelope_type: String(envelope.type ?? ""),
@@ -32985,10 +33470,10 @@ ${invitee}` : "";
       encrypted: true,
       e2ee
     };
+    if (senderDeviceId) result.sender_device_id = senderDeviceId;
     const explicitDirection = String(msg.direction ?? "").trim();
     result.direction = explicitDirection || (fromAid && fromAid === this._aid ? "outbound_sync" : "inbound");
     if (msg.device_id !== void 0) result.device_id = msg.device_id;
-    if (msg.slot_id !== void 0) result.slot_id = msg.slot_id;
     attachGatewayProximity2(result, msg);
     attachV2EnvelopeMetadata2(result, e2ee);
     if (groupIdForKeys) result = normalizeGroupMentionMode(result, msg, envelope);