@tool-bridge/server 0.14.0 → 0.16.0

package/dist/{chunk-ABHHWYEV.js → chunk-YB2FLNWI.js}

@@ -16037,8 +16037,233 @@ function createPluginModule(deps) {
   };
 }
 
+// ../core/src/builtin/store.ts
+var STORE_SCOPE_BY_CMD = {
+  create_upload: "write",
+  complete_upload: "write",
+  abort_upload: "write",
+  stat: "read",
+  read: "read",
+  share: "write",
+  revoke_share: "write",
+  delete: "write",
+  list: "read"
+};
+var DESCRIPTION3 = "Deployment-level private object Store for uploads, reads and short-lived sharing";
+function storeCmds(nodePath) {
+  const path = cmdPath(nodePath);
+  const objectFields = {
+    contentType: { type: "string", description: "object MIME type" },
+    filename: { type: "string", description: "display-only filename; never used as a storage key" },
+    size: { type: "number", description: "expected byte size" },
+    checksum: {
+      type: "object",
+      description: "optional sha256 checksum declaration",
+      properties: {
+        algorithm: { type: "string", enum: ["sha256"] },
+        value: { type: "string" }
+      }
+    },
+    idempotencyKey: { type: "string", description: "owner-scoped create retry key" }
+  };
+  const uriField = { uri: { type: "string", description: "store://default/<objectId>" } };
+  const specs = [
+    {
+      name: "create_upload",
+      method: "POST",
+      path,
+      h: "create a new opaque Store object and bounded upload session",
+      inputSchema: {
+        type: "object",
+        properties: objectFields,
+        required: ["contentType"]
+      },
+      returns: "StoreUploadGrant"
+    },
+    {
+      name: "complete_upload",
+      method: "POST",
+      path,
+      h: "verify a direct upload and atomically mark its object ready; idempotent",
+      inputSchema: {
+        type: "object",
+        properties: {
+          uploadId: { type: "string" }
+        },
+        required: ["uploadId"]
+      },
+      returns: "StoreObject"
+    },
+    {
+      name: "abort_upload",
+      method: "POST",
+      path,
+      h: "abandon an unfinished upload; idempotent until the object is ready",
+      inputSchema: {
+        type: "object",
+        properties: {
+          uploadId: { type: "string" }
+        },
+        required: ["uploadId"]
+      },
+      returns: "void"
+    },
+    {
+      name: "stat",
+      method: "POST",
+      path,
+      h: "return metadata for a ready object owned by the current principal",
+      inputSchema: {
+        type: "object",
+        properties: uriField,
+        required: ["uri"]
+      },
+      returns: "StoreObject"
+    },
+    {
+      name: "read",
+      method: "POST",
+      path,
+      h: "authorize an object read and return a short-lived $ref",
+      inputSchema: {
+        type: "object",
+        properties: uriField,
+        required: ["uri"]
+      },
+      returns: "{ $ref, contentType, size, expiresAt }"
+    },
+    {
+      name: "share",
+      method: "POST",
+      path,
+      h: "create a short-lived, revocable read share for an owned object",
+      inputSchema: {
+        type: "object",
+        properties: { ...uriField, ttlSec: { type: "number" } },
+        required: ["uri"]
+      },
+      returns: "StoreShare"
+    },
+    {
+      name: "revoke_share",
+      method: "POST",
+      path,
+      h: "revoke a Store share grant",
+      inputSchema: {
+        type: "object",
+        properties: { shareId: { type: "string" } },
+        required: ["shareId"]
+      },
+      returns: "void"
+    },
+    {
+      name: "delete",
+      method: "POST",
+      path,
+      h: "make an owned Store object immediately unreadable and delete its bytes",
+      inputSchema: { type: "object", properties: uriField, required: ["uri"] },
+      returns: "void"
+    },
+    {
+      name: "list",
+      method: "POST",
+      path,
+      h: "list ready Store objects owned by the current principal",
+      inputSchema: { type: "object", properties: { opts: LIST_OPTS_SCHEMA } },
+      returns: "Page<StoreObject>"
+    }
+  ];
+  return withCommandPaths(nodePath, specs.map((spec) => ({
+    ...spec,
+    scope: STORE_SCOPE_BY_CMD[spec.name]
+  })));
+}
+function optionalPositiveInt(args, field) {
+  const value = args[field];
+  if (value === void 0) return void 0;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TBError("invalid_argument", `${field} \u5FC5\u987B\u662F\u6B63\u6574\u6570`);
+  }
+  return value;
+}
+function rejectUnknown(args, allowed) {
+  const unknown2 = Object.keys(args).filter((key) => !allowed.includes(key));
+  if (unknown2.length > 0) {
+    throw new TBError("invalid_argument", `\u672A\u77E5\u5B57\u6BB5:${unknown2.join(",")}`);
+  }
+}
+function createStoreModule(deps) {
+  return {
+    module: "store",
+    description: DESCRIPTION3,
+    help(nodePath) {
+      return {
+        node: { path: nodePath, kind: "builtin", description: DESCRIPTION3 },
+        cmds: storeCmds(nodePath)
+      };
+    },
+    async dispatch(cmd, args, ctx, runtime) {
+      switch (cmd) {
+        case "create_upload": {
+          rejectUnknown(args, ["contentType", "filename", "size", "checksum", "idempotencyKey"]);
+          const input = {
+            contentType: requireString(args, "contentType"),
+            ...args.filename !== void 0 ? { filename: args.filename } : {},
+            ...args.size !== void 0 ? { size: args.size } : {},
+            ...args.checksum !== void 0 ? { checksum: args.checksum } : {},
+            ...args.idempotencyKey !== void 0 ? { idempotencyKey: args.idempotencyKey } : {}
+          };
+          const start = await deps.service.beginUpload(input, {
+            owner: ctx.owner,
+            producer: ctx.owner
+          });
+          return deps.callbacks.createUpload(start, runtime);
+        }
+        case "complete_upload":
+          rejectUnknown(args, ["uploadId"]);
+          return deps.service.completeUpload(requireString(args, "uploadId"), ctx.owner);
+        case "abort_upload":
+          rejectUnknown(args, ["uploadId"]);
+          return deps.service.abortUpload(requireString(args, "uploadId"), ctx.owner);
+        case "stat":
+          rejectUnknown(args, ["uri"]);
+          return deps.service.stat(requireString(args, "uri"), { owner: ctx.owner });
+        case "read": {
+          rejectUnknown(args, ["uri"]);
+          const object2 = await deps.service.authorizeRead(requireString(args, "uri"), {
+            owner: ctx.owner
+          });
+          return deps.callbacks.read(object2, runtime);
+        }
+        case "share": {
+          rejectUnknown(args, ["uri", "ttlSec"]);
+          const ttlSec = optionalPositiveInt(args, "ttlSec");
+          const result = ttlSec === void 0 ? await deps.service.share(requireString(args, "uri"), ctx.owner) : await deps.service.share(requireString(args, "uri"), ctx.owner, ttlSec);
+          return deps.callbacks.share(result, runtime);
+        }
+        case "revoke_share":
+          rejectUnknown(args, ["shareId"]);
+          return deps.service.revokeShare(requireString(args, "shareId"), ctx.owner);
+        case "delete":
+          rejectUnknown(args, ["uri"]);
+          return deps.service.delete(requireString(args, "uri"), { owner: ctx.owner });
+        case "list": {
+          rejectUnknown(args, ["opts"]);
+          const raw = args.opts;
+          if (raw !== void 0 && (typeof raw !== "object" || raw === null || Array.isArray(raw))) {
+            throw new TBError("invalid_argument", "opts \u5FC5\u987B\u662F\u5BF9\u8C61");
+          }
+          return deps.service.list(ctx.owner, raw ?? {});
+        }
+        default:
+          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/store`);
+      }
+    }
+  };
+}
+
 // ../core/src/builtin/annotation.ts
-var DESCRIPTION3 = "Path annotations: admin-curated notes shown in ~help of the annotated path (set / get / remove / list)";
+var DESCRIPTION4 = "Path annotations: admin-curated notes shown in ~help of the annotated path (set / get / remove / list)";
 function annotationCmds(nodePath) {
   const path = cmdPath(nodePath);
   const cmds = [
@@ -16114,10 +16339,10 @@ function requireRootablePath(args) {
 function createAnnotationModule(deps) {
   return {
     module: "annotation",
-    description: DESCRIPTION3,
+    description: DESCRIPTION4,
     help(nodePath) {
       return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION3 },
+        node: { path: nodePath, kind: "builtin", description: DESCRIPTION4 },
         cmds: annotationCmds(nodePath)
       };
     },
@@ -16217,7 +16442,7 @@ var RemoteAllowlistStore = class {
 };
 
 // ../core/src/builtin/federation.ts
-var DESCRIPTION4 = "Remote federation host allowlist: which hosts kind=remote nodes may connect to (env baseline is read-only; admin only)";
+var DESCRIPTION5 = "Remote federation host allowlist: which hosts kind=remote nodes may connect to (env baseline is read-only; admin only)";
 function federationCmds(nodePath) {
   const path = cmdPath(nodePath);
   const cmds = [
@@ -16280,10 +16505,10 @@ function mergedView(base, entries) {
 function createFederationModule(deps) {
   return {
     module: "federation",
-    description: DESCRIPTION4,
+    description: DESCRIPTION5,
     help(nodePath) {
       return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION4 },
+        node: { path: nodePath, kind: "builtin", description: DESCRIPTION5 },
         cmds: federationCmds(nodePath)
       };
     },
@@ -16319,7 +16544,7 @@ function createFederationModule(deps) {
 }
 
 // ../core/src/builtin/registry.ts
-var DESCRIPTION5 = "Node registry: the single mount surface \u2014 everything on the tree (mcp/http/context/device/remote nodes) is mounted, listed and unmounted here";
+var DESCRIPTION6 = "Node registry: the single mount surface \u2014 everything on the tree (mcp/http/context/device/remote nodes) is mounted, listed and unmounted here";
 var NODE_FIELD_SCHEMAS = {
   path: { type: "string", description: 'tree path to mount at, e.g. "docs/context7"' },
   kind: {
@@ -16432,10 +16657,10 @@ function parseNodeInput(args) {
 function createRegistryModule(store, now, visibility) {
   return {
     module: "registry",
-    description: DESCRIPTION5,
+    description: DESCRIPTION6,
     help(nodePath) {
       return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION5 },
+        node: { path: nodePath, kind: "builtin", description: DESCRIPTION6 },
         cmds: registryCmds(nodePath)
       };
     },
@@ -16476,7 +16701,7 @@ function createRegistryModule(store, now, visibility) {
 }
 
 // ../core/src/builtin/secret.ts
-var DESCRIPTION6 = "Upstream credential vault: write-only; mounts reference entries by name (authRef), values can never be read back (admin only)";
+var DESCRIPTION7 = "Upstream credential vault: write-only; mounts reference entries by name (authRef), values can never be read back (admin only)";
 function assertUserSecretName(name) {
   if (name.includes(":")) {
     throw new TBError(
@@ -16538,10 +16763,10 @@ function secretCmds(nodePath) {
 function createSecretModule(store, now) {
   return {
     module: "secret",
-    description: DESCRIPTION6,
+    description: DESCRIPTION7,
     help(nodePath) {
       return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION6 },
+        node: { path: nodePath, kind: "builtin", description: DESCRIPTION7 },
         cmds: secretCmds(nodePath)
       };
     },
@@ -16569,7 +16794,7 @@ function createSecretModule(store, now) {
 }
 
 // ../core/src/builtin/status.ts
-var DESCRIPTION7 = "Gateway health and summary (readable without admin)";
+var DESCRIPTION8 = "Gateway health and summary (readable without admin)";
 function statusCmds(nodePath) {
   return withCommandPaths(nodePath, [
     {
@@ -16586,10 +16811,10 @@ function statusCmds(nodePath) {
 function createStatusModule(deps) {
   return {
     module: "status",
-    description: DESCRIPTION7,
+    description: DESCRIPTION8,
     help(nodePath) {
       return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION7 },
+        node: { path: nodePath, kind: "builtin", description: DESCRIPTION8 },
         cmds: statusCmds(nodePath)
       };
     },
@@ -16608,7 +16833,7 @@ function createStatusModule(deps) {
 }
 
 // ../core/src/builtin/sk.ts
-var DESCRIPTION8 = "Secret Key registry: issue / list / update / revoke access keys (the only credential form; admin only)";
+var DESCRIPTION9 = "Secret Key registry: issue / list / update / revoke access keys (the only credential form; admin only)";
 var SK_FIELD_SCHEMAS = {
   owner: {
     type: "string",
@@ -16742,10 +16967,10 @@ function asSkUpdatePatch(args) {
 function createSkModule(store, now) {
   return {
     module: "sk",
-    description: DESCRIPTION8,
+    description: DESCRIPTION9,
     help(nodePath) {
       return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION8 },
+        node: { path: nodePath, kind: "builtin", description: DESCRIPTION9 },
         cmds: skCmds(nodePath)
       };
     },
@@ -16817,18 +17042,23 @@ function createBuiltins(deps) {
       createAnnotationModule({ store: deps.annotation.store, registry: deps.registry, now })
     );
   }
+  if (deps.store !== void 0) {
+    modules.set("store", createStoreModule(deps.store));
+  }
   return modules;
 }
 
 // ../core/src/context/help.ts
 var CONTEXT_CAPABILITIES = ["search", "delete"];
+var CONTEXT_DIRECT_UPLOAD_CAPABILITY = "direct-upload";
 var SCOPE_BY_CMD = {
   list: "read",
   get: "read",
   search: "read",
   write: "write",
   update: "write",
-  delete: "write"
+  delete: "write",
+  create_upload: "write"
 };
 function contextScopeForCmd(command) {
   return SCOPE_BY_CMD[command] ?? null;
@@ -16976,6 +17206,29 @@ function contextCmds(nodePath) {
   ];
   return withCommandPaths(nodePath, cmds);
 }
+function contextUploadCmd(nodePath) {
+  return withCommandPaths(nodePath, [{
+    name: "create_upload",
+    method: "POST",
+    path: cmdPath(nodePath),
+    h: "create a short-lived, path-scoped direct-upload grant; persist the returned uri, not url",
+    inputSchema: {
+      type: "object",
+      required: ["path", "contentType"],
+      properties: {
+        path: { type: "string", description: "target entry path inside the namespace" },
+        contentType: { type: "string", description: "media type signed into the PUT request" },
+        overwrite: {
+          type: "boolean",
+          description: "allow replacing an existing object; default false"
+        }
+      }
+    },
+    returns: "ContextUploadGrant",
+    scope: "write",
+    effect: "write"
+  }])[0];
+}
 function contextHelpModel(node, opts = {}) {
   const all = contextCmds(node.path);
   const present = opts.methods === void 0 ? all : all.filter((c) => opts.methods?.has(c.name));
@@ -17041,6 +17294,10 @@ function bytesToObjectStream(bytes) {
   };
 }
 
+// ../core/src/objectStoreService/types.ts
+var DEFAULT_STORE_NAME = "default";
+var DEFAULT_STORE_DRIVER_KEY_ROOT = "__tool_bridge_internal__/store/v1";
+
 // ../core/src/context/path.ts
 function hasControlChar(s) {
   for (let i = 0; i < s.length; i++) {
@@ -17075,8 +17332,79 @@ function normalizeEntryPath(path) {
 // ../core/src/context/objectProvider.ts
 var REF_THRESHOLD_BYTES_DEFAULT = 1024 * 1024;
 var PRESIGN_TTL_SEC_DEFAULT = 900;
+var PRESIGN_TTL_SEC_MAX = 604800;
+var DEFAULT_STORE_RESERVED_KEY_ROOT = DEFAULT_STORE_DRIVER_KEY_ROOT;
+function normalizeKeyPrefix(keyPrefix) {
+  return keyPrefix?.replace(/^\/+|\/+$/g, "") ?? "";
+}
+function isDefaultStoreReservedKey(key) {
+  return key === DEFAULT_STORE_RESERVED_KEY_ROOT || key.startsWith(`${DEFAULT_STORE_RESERVED_KEY_ROOT}/`);
+}
+function assertContextKeyPrefixAllowed(keyPrefixBare) {
+  if (keyPrefixBare === "") return;
+  if (keyPrefixBare === DEFAULT_STORE_RESERVED_KEY_ROOT || keyPrefixBare.startsWith(`${DEFAULT_STORE_RESERVED_KEY_ROOT}/`) || DEFAULT_STORE_RESERVED_KEY_ROOT.startsWith(`${keyPrefixBare}/`)) {
+    throw new TBError("invalid_argument", "\u5BF9\u8C61 Context keyPrefix \u4E0E Store \u4FDD\u7559 namespace \u51B2\u7A81");
+  }
+}
+function assertContextKeyAllowed(key, path, writable) {
+  if (!isDefaultStoreReservedKey(key)) return;
+  if (!writable) throw TBError.notFound(`context entry \u4E0D\u5B58\u5728:'${path}'`);
+  throw new TBError("permission_denied", "\u5BF9\u8C61 Context \u4E0D\u5F97\u4FEE\u6539 Store \u4FDD\u7559 namespace");
+}
+function assertPresignTtlSec(ttlSec) {
+  if (!Number.isInteger(ttlSec) || ttlSec < 1 || ttlSec > PRESIGN_TTL_SEC_MAX) {
+    throw new TBError(
+      "invalid_argument",
+      `presign TTL \u5FC5\u987B\u662F 1..${PRESIGN_TTL_SEC_MAX} \u7684\u6574\u6570\u79D2`
+    );
+  }
+  return ttlSec;
+}
 var SEARCH_METADATA_HEAD_MAX = 200;
 var DIRECTORY_CONTENT_TYPE = "application/x-directory";
+async function createObjectContextUploadGrant(store, opts, input) {
+  const keyPrefixBare = normalizeKeyPrefix(opts.keyPrefix);
+  assertContextKeyPrefixAllowed(keyPrefixBare);
+  if (opts.readOnly === true) {
+    throw new TBError("permission_denied", "readOnly \u6302\u8F7D\u62D2\u7EDD create_upload");
+  }
+  if (typeof input?.path !== "string") {
+    throw new TBError("invalid_argument", "create_upload \u9700\u8981\u5B57\u7B26\u4E32 'path'");
+  }
+  if (input.overwrite !== void 0 && typeof input.overwrite !== "boolean") {
+    throw new TBError("invalid_argument", "create_upload \u7684 'overwrite' \u5FC5\u987B\u662F boolean");
+  }
+  const unknownKeys = Object.keys(input).filter(
+    (key2) => key2 !== "path" && key2 !== "contentType" && key2 !== "overwrite"
+  );
+  if (unknownKeys.length > 0) {
+    throw new TBError("invalid_argument", `create_upload \u542B\u672A\u77E5\u5B57\u6BB5:${unknownKeys.join(",")}`);
+  }
+  if (typeof input?.contentType !== "string" || input.contentType.trim() === "" || input.contentType.length > 255 || !input.contentType.includes("/") || /[\r\n\0]/.test(input.contentType)) {
+    throw new TBError("invalid_argument", "create_upload \u9700\u8981\u5408\u6CD5\u7684 'contentType'");
+  }
+  const nsPath = normalizePath(opts.nsPath);
+  const entryPath = normalizeEntryPath(input.path);
+  const key = `${keyPrefixBare === "" ? "" : `${keyPrefixBare}/`}${entryPath}`;
+  assertContextKeyAllowed(key, entryPath, true);
+  if (store.presignPut === void 0) {
+    throw new TBError("unavailable", "\u5BF9\u8C61\u5B58\u50A8\u672A\u914D\u7F6E\u76F4\u4F20\u7B7E\u540D\u80FD\u529B", { retryable: false });
+  }
+  const ttlSec = assertPresignTtlSec(opts.uploadGrantTtlSec ?? PRESIGN_TTL_SEC_DEFAULT);
+  const contentType = input.contentType.trim();
+  const expiresAt = new Date(Date.now() + ttlSec * 1e3).toISOString();
+  const signed = await store.presignPut(key, ttlSec, {
+    contentType,
+    ...input.overwrite === true ? {} : { ifNoneMatch: "*" }
+  });
+  return {
+    uri: `node://${nsPath}/${entryPath}`,
+    method: "PUT",
+    url: signed.url,
+    headers: signed.headers,
+    expiresAt
+  };
+}
 function clampLimit3(limit) {
   if (limit === void 0) return LIST_LIMIT_DEFAULT;
   if (!Number.isInteger(limit) || limit < 1) {
@@ -17111,12 +17439,18 @@ function serializeInput(entry) {
 }
 function createObjectContextProvider(store, opts) {
   const nsPath = normalizePath(opts.nsPath);
-  const keyPrefixBare = opts.keyPrefix?.replace(/^\/+|\/+$/g, "") ?? "";
+  const keyPrefixBare = normalizeKeyPrefix(opts.keyPrefix);
+  assertContextKeyPrefixAllowed(keyPrefixBare);
   const keyPrefix = keyPrefixBare === "" ? "" : `${keyPrefixBare}/`;
   const readOnly = opts.readOnly ?? false;
   const refThreshold = opts.refThresholdBytes ?? REF_THRESHOLD_BYTES_DEFAULT;
   const presignTtlSec = opts.presignTtlSec ?? PRESIGN_TTL_SEC_DEFAULT;
-  const keyFor = (path) => keyPrefix + normalizeEntryPath(path);
+  const keyFor = (path, writable) => {
+    const entryPath = normalizeEntryPath(path);
+    const key = keyPrefix + entryPath;
+    assertContextKeyAllowed(key, entryPath, writable);
+    return key;
+  };
   const entryPathOf = (key) => key.slice(keyPrefix.length);
   const uriFor = (entryPath) => `node://${nsPath}/${entryPath}`;
   const toMeta = (m) => ({
@@ -17148,25 +17482,41 @@ function createObjectContextProvider(store, opts) {
       const limit = clampLimit3(listOpts?.limit);
       const rel = path === "" ? "" : `${normalizeEntryPath(path)}/`;
       const full = keyPrefix + rel;
-      const res = await store.list(full, { delimiter: "/", cursor: listOpts?.cursor, limit });
+      assertContextKeyAllowed(full.slice(0, -1), path, false);
       const items = [];
-      for (const item of res.items) {
-        if ("prefix" in item) {
-          items.push({
-            uri: uriFor(entryPathOf(item.prefix)),
-            contentType: DIRECTORY_CONTENT_TYPE,
-            version: "",
-            updatedAt: "",
-            metadata: {}
-          });
-        } else if (item.key !== full) {
-          items.push(toMeta(item));
+      let storeCursor = listOpts?.cursor;
+      for (; ; ) {
+        const previousCursor = storeCursor;
+        const res = await store.list(full, {
+          delimiter: "/",
+          cursor: storeCursor,
+          limit: Math.max(1, limit - items.length)
+        });
+        for (const item of res.items) {
+          const itemKey = "prefix" in item ? item.prefix.replace(/\/$/, "") : item.key;
+          if (isDefaultStoreReservedKey(itemKey)) continue;
+          if ("prefix" in item) {
+            items.push({
+              uri: uriFor(entryPathOf(item.prefix)),
+              contentType: DIRECTORY_CONTENT_TYPE,
+              version: "",
+              updatedAt: "",
+              metadata: {}
+            });
+          } else if (item.key !== full) {
+            items.push(toMeta(item));
+          }
+        }
+        storeCursor = res.cursor;
+        if (items.length >= limit || storeCursor === void 0) break;
+        if (storeCursor === previousCursor) {
+          throw new TBError("internal", "\u5BF9\u8C61\u5B58\u50A8 list cursor \u672A\u524D\u8FDB");
         }
       }
-      return res.cursor !== void 0 ? { items, cursor: res.cursor } : { items };
+      return storeCursor !== void 0 ? { items, cursor: storeCursor } : { items };
     },
     async get(path) {
-      const key = keyFor(path);
+      const key = keyFor(path, false);
       const head = await store.head(key);
       if (!head) throw notFound(path);
       const meta3 = toMeta(head);
@@ -17186,7 +17536,7 @@ function createObjectContextProvider(store, opts) {
     },
     async write(path, entry) {
       assertWritable("write");
-      const key = keyFor(path);
+      const key = keyFor(path, true);
       const { body, contentType } = serializeInput(entry);
       const meta3 = await store.put(key, body, {
         contentType,
@@ -17197,7 +17547,7 @@ function createObjectContextProvider(store, opts) {
     },
     async update(path, patch) {
       assertWritable("update");
-      const key = keyFor(path);
+      const key = keyFor(path, true);
       if (patch.content === void 0 && patch.metadata === void 0) {
         throw new TBError("invalid_argument", "patch \u81F3\u5C11\u63D0\u4F9B content \u6216 metadata \u4E4B\u4E00");
       }
@@ -17225,7 +17575,7 @@ function createObjectContextProvider(store, opts) {
     },
     async delete(path) {
       assertWritable("delete");
-      await store.delete(keyFor(path));
+      await store.delete(keyFor(path, true));
     },
     async search(query, searchOpts) {
       const mode = searchOpts?.mode ?? "keyword";
@@ -17251,6 +17601,7 @@ function createObjectContextProvider(store, opts) {
         const page = await store.list(keyPrefix, { cursor: storeCursor, limit: LIST_LIMIT_MAX });
         for (const item of page.items) {
           if ("prefix" in item) continue;
+          if (isDefaultStoreReservedKey(item.key)) continue;
           if (after !== void 0 && item.key <= after) continue;
           const entryPath = entryPathOf(item.key);
           let meta3 = item;
@@ -17332,7 +17683,13 @@ var deviceCallContextSchema = external_exports.object({
   }).passthrough(),
   traceId: external_exports.string().min(1),
   createdAt: external_exports.string().min(1),
-  expiresAt: external_exports.string().min(1)
+  expiresAt: external_exports.string().min(1),
+  upload: external_exports.object({
+    token: external_exports.string().min(1),
+    expiresAt: external_exports.iso.datetime({ offset: true }),
+    maxBytes: external_exports.number().int().positive(),
+    maxObjects: external_exports.number().int().positive()
+  }).strict().optional()
 }).passthrough();
 var schemaByType = {
   hello: external_exports.object({
@@ -18106,6 +18463,1290 @@ async function buildTree(opts) {
   return build(rootEntry, opts.depth);
 }
 
+// ../core/src/objectStoreService/uri.ts
+var STORE_OBJECT_ID_RE = /^[A-Za-z0-9_-]{22,64}$/;
+function storeUri(objectId) {
+  if (!STORE_OBJECT_ID_RE.test(objectId)) {
+    throw new TBError("invalid_argument", "\u975E\u6CD5 Store object id");
+  }
+  return `store://${DEFAULT_STORE_NAME}/${objectId}`;
+}
+function parseStoreUri(uri) {
+  if (typeof uri !== "string") {
+    throw new TBError("invalid_argument", "Store URI \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  }
+  const prefix = `store://${DEFAULT_STORE_NAME}/`;
+  if (!uri.startsWith(prefix)) {
+    throw new TBError("invalid_argument", "Store URI \u5FC5\u987B\u4F7F\u7528 store://default/<objectId>");
+  }
+  const objectId = uri.slice(prefix.length);
+  if (!STORE_OBJECT_ID_RE.test(objectId)) {
+    throw new TBError("invalid_argument", "\u975E\u6CD5 Store URI");
+  }
+  return { store: DEFAULT_STORE_NAME, objectId };
+}
+
+// ../core/src/objectStoreService/service.ts
+var KEY_STORE_OBJECT = "store:object:";
+var KEY_STORE_UPLOAD = "store:upload:";
+var KEY_STORE_CALL_CAPABILITY = "store:call-capability:";
+var KEY_STORE_SHARE = "store:share:";
+var KEY_STORE_IDEMPOTENCY = "store:idempotency:";
+var UPLOAD_TTL_SEC_DEFAULT = 15 * 60;
+var SHARE_TTL_SEC_DEFAULT = 15 * 60;
+var MAX_OBJECT_BYTES_DEFAULT = 256 * 1024 * 1024;
+var MAX_CAS_ATTEMPTS = 32;
+var CAPABILITY_TTL_SEC_MAX = 7 * 24 * 60 * 60;
+var TOKEN_PREFIX = {
+  call: "tbc",
+  share: "tbs",
+  upload: "tbu"
+};
+function stateCorrupt(kind) {
+  return new TBError("internal", `Store ${kind} \u72B6\u6001\u635F\u574F`, { retryable: false });
+}
+function asRecord2(value, kind) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw stateCorrupt(kind);
+  }
+  return value;
+}
+function assertRevisioned(value, kind) {
+  const record2 = asRecord2(value, kind);
+  if (!Number.isInteger(record2.revision) || record2.revision < 1) {
+    throw stateCorrupt(kind);
+  }
+  return record2;
+}
+function parseObject(value) {
+  const record2 = assertRevisioned(value, "object");
+  if (typeof record2.id !== "string" || record2.store !== DEFAULT_STORE_NAME || typeof record2.driverKey !== "string" || typeof record2.owner !== "string" || typeof record2.contentType !== "string" || typeof record2.uploadId !== "string" || typeof record2.status !== "string") throw stateCorrupt("object");
+  return value;
+}
+function parseSession(value) {
+  const record2 = assertRevisioned(value, "upload session");
+  if (typeof record2.id !== "string" || typeof record2.objectId !== "string" || typeof record2.capabilityHash !== "string" || typeof record2.status !== "string") throw stateCorrupt("upload session");
+  return value;
+}
+function parseCallCapability(value) {
+  const record2 = assertRevisioned(value, "call capability");
+  if (typeof record2.id !== "string" || typeof record2.tokenHash !== "string" || typeof record2.owner !== "string" || typeof record2.producer !== "string" || typeof record2.callId !== "string" || !Array.isArray(record2.reservations)) throw stateCorrupt("call capability");
+  return value;
+}
+function parseShare(value) {
+  const record2 = assertRevisioned(value, "share grant");
+  if (typeof record2.id !== "string" || typeof record2.objectId !== "string" || typeof record2.tokenHash !== "string" || typeof record2.createdBy !== "string") throw stateCorrupt("share grant");
+  return value;
+}
+function parseIdempotencyBinding(value) {
+  const record2 = assertRevisioned(value, "idempotency binding");
+  if (typeof record2.owner !== "string" || record2.domain !== "owner" && record2.domain !== "call" || typeof record2.producer !== "string" || typeof record2.fingerprint !== "string" || typeof record2.objectId !== "string" || typeof record2.uploadId !== "string") throw stateCorrupt("idempotency binding");
+  return value;
+}
+function requireOwner(owner, field = "owner") {
+  if (typeof owner !== "string" || owner.trim() === "" || /[\r\n\0]/.test(owner)) {
+    throw new TBError("invalid_argument", `${field} \u5FC5\u987B\u662F\u975E\u7A7A OwnerRef`);
+  }
+  return owner;
+}
+function requirePositiveInt(value, field) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TBError("invalid_argument", `${field} \u5FC5\u987B\u662F\u6B63\u6574\u6570`);
+  }
+  return value;
+}
+function requireCapabilityTtl(value, field) {
+  const ttl = requirePositiveInt(value, field);
+  if (ttl > CAPABILITY_TTL_SEC_MAX) {
+    throw new TBError("invalid_argument", `${field} \u4E0D\u80FD\u8D85\u8FC7 ${CAPABILITY_TTL_SEC_MAX} \u79D2`);
+  }
+  return ttl;
+}
+function normalizeTimestamp(value, field) {
+  try {
+    return normalizeExpiresAt(value);
+  } catch (error51) {
+    if (error51 instanceof TBError && error51.code === "invalid_argument") {
+      throw new TBError("invalid_argument", `${field} \u5FC5\u987B\u662F\u5E26\u65F6\u533A\u7684 ISO 8601 timestamp`);
+    }
+    throw error51;
+  }
+}
+function normalizeContentType(value) {
+  if (typeof value !== "string" || value.trim() === "" || value.length > 255 || !value.includes("/") || /[\r\n\0]/.test(value)) {
+    throw new TBError("invalid_argument", "contentType \u4E0D\u5408\u6CD5");
+  }
+  return value.trim().toLowerCase();
+}
+function normalizeChecksum(value) {
+  if (value === void 0) return void 0;
+  const record2 = asRecord2(value, "checksum");
+  if (record2.algorithm !== "sha256" || typeof record2.value !== "string") {
+    throw new TBError("invalid_argument", "checksum \u4EC5\u652F\u6301 sha256");
+  }
+  const digest = record2.value.toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(digest)) {
+    throw new TBError("invalid_argument", "sha256 checksum \u5FC5\u987B\u662F 64 \u4F4D\u5341\u516D\u8FDB\u5236");
+  }
+  return { algorithm: "sha256", value: digest };
+}
+function normalizeUploadInput(input) {
+  const contentType = normalizeContentType(input?.contentType);
+  let filename;
+  if (input.filename !== void 0) {
+    if (typeof input.filename !== "string" || input.filename.trim() === "" || input.filename.length > 1024 || /[\r\n\0]/.test(input.filename)) throw new TBError("invalid_argument", "filename \u4E0D\u5408\u6CD5");
+    filename = input.filename;
+  }
+  let size;
+  if (input.size !== void 0) {
+    if (!Number.isSafeInteger(input.size) || input.size < 0) {
+      throw new TBError("invalid_argument", "size \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+    }
+    size = input.size;
+  }
+  let idempotencyKey;
+  if (input.idempotencyKey !== void 0) {
+    if (typeof input.idempotencyKey !== "string" || input.idempotencyKey.length < 1 || input.idempotencyKey.length > 255 || /[\r\n\0]/.test(input.idempotencyKey)) throw new TBError("invalid_argument", "idempotencyKey \u4E0D\u5408\u6CD5");
+    idempotencyKey = input.idempotencyKey;
+  }
+  const checksum = normalizeChecksum(input.checksum);
+  return {
+    contentType,
+    ...filename !== void 0 ? { filename } : {},
+    ...size !== void 0 ? { size } : {},
+    ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+    ...checksum !== void 0 ? { checksum } : {}
+  };
+}
+function constantTimeEqual(left, right) {
+  let diff = left.length ^ right.length;
+  const length = Math.max(left.length, right.length);
+  for (let i = 0; i < length; i++) {
+    diff |= (left.charCodeAt(i % Math.max(1, left.length)) || 0) ^ (right.charCodeAt(i % Math.max(1, right.length)) || 0);
+  }
+  return diff === 0;
+}
+function contentTypeAllowed(contentType, patterns) {
+  return patterns.some((pattern) => {
+    const normalized = pattern.toLowerCase();
+    if (normalized === "*/*") return true;
+    if (normalized.endsWith("/*")) return contentType.startsWith(normalized.slice(0, -1));
+    return normalized === contentType;
+  });
+}
+function normalizeContentTypePattern(value) {
+  if (value === "*/*") return value;
+  if (typeof value === "string" && value.endsWith("/*")) {
+    const prefix = value.slice(0, -1);
+    if (prefix.length > 1 && !/[\r\n\0]/.test(value)) return value.toLowerCase();
+  }
+  return normalizeContentType(value);
+}
+function descriptorOf(object2) {
+  if (object2.status !== "ready" || object2.readyAt === void 0 || object2.size === void 0) throw stateCorrupt("ready object");
+  return {
+    uri: storeUri(object2.id),
+    status: "ready",
+    contentType: object2.contentType,
+    size: object2.size,
+    owner: object2.owner,
+    createdAt: object2.createdAt,
+    updatedAt: object2.updatedAt,
+    readyAt: object2.readyAt,
+    ...object2.etag !== void 0 ? { etag: object2.etag } : {},
+    ...object2.filename !== void 0 ? { filename: object2.filename } : {},
+    ...object2.producer !== void 0 ? { producer: object2.producer } : {},
+    ...object2.originCallId !== void 0 ? { originCallId: object2.originCallId } : {},
+    ...object2.checksum !== void 0 ? { checksum: object2.checksum } : {},
+    ...object2.expiresAt !== void 0 ? { expiresAt: object2.expiresAt } : {}
+  };
+}
+var StoreService = class {
+  constructor(state, objects, opts) {
+    this.state = state;
+    this.objects = objects;
+    if (state.compareAndSwap === void 0) {
+      throw new TBError("unavailable", "StoreService \u8981\u6C42 StateStore.compareAndSwap", {
+        retryable: false
+      });
+    }
+    if (typeof opts?.tokenSecret !== "string" || opts.tokenSecret.length < 16) {
+      throw new TBError("invalid_argument", "Store tokenSecret \u81F3\u5C11\u9700\u8981 16 \u4E2A\u5B57\u7B26");
+    }
+    this.cas = state.compareAndSwap.bind(state);
+    this.tokenSecret = opts.tokenSecret;
+    this.now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.maxObjectBytes = requirePositiveInt(
+      opts.maxObjectBytes ?? MAX_OBJECT_BYTES_DEFAULT,
+      "maxObjectBytes"
+    );
+    this.relayMaxBytes = Math.min(
+      requirePositiveInt(opts.relayMaxBytes ?? this.maxObjectBytes, "relayMaxBytes"),
+      this.maxObjectBytes
+    );
+    this.uploadTtlSec = requireCapabilityTtl(
+      opts.uploadTtlSec ?? UPLOAD_TTL_SEC_DEFAULT,
+      "uploadTtlSec"
+    );
+    this.shareTtlSec = requireCapabilityTtl(
+      opts.shareTtlSec ?? SHARE_TTL_SEC_DEFAULT,
+      "shareTtlSec"
+    );
+  }
+  state;
+  objects;
+  maxObjectBytes;
+  now;
+  relayMaxBytes;
+  shareTtlSec;
+  tokenSecret;
+  uploadTtlSec;
+  cas;
+  async issueCallUploadCapability(input) {
+    const now = this.nowIso();
+    const expiresAt = normalizeTimestamp(input.expiresAt, "expiresAt");
+    if (Date.parse(expiresAt) <= Date.parse(now)) {
+      throw new TBError("invalid_argument", "call capability expiresAt \u5FC5\u987B\u5728\u672A\u6765");
+    }
+    const owner = requireOwner(input.owner);
+    const producer = requireOwner(input.producer, "producer");
+    const callId = requireOwner(input.callId, "callId");
+    const maxObjects = requirePositiveInt(input.maxObjects, "maxObjects");
+    const maxBytes = requirePositiveInt(input.maxBytes, "maxBytes");
+    const maxObjectBytes = Math.min(
+      requirePositiveInt(input.maxObjectBytes, "maxObjectBytes"),
+      maxBytes,
+      this.maxObjectBytes
+    );
+    if (!Array.isArray(input.allowedContentTypes) || input.allowedContentTypes.length === 0) {
+      throw new TBError("invalid_argument", "allowedContentTypes \u4E0D\u80FD\u4E3A\u7A7A");
+    }
+    const allowedContentTypes = input.allowedContentTypes.map(normalizeContentTypePattern);
+    const id = this.randomId();
+    const token = await this.tokenFor("call", id);
+    const capability = {
+      id,
+      revision: 1,
+      tokenHash: await sha256Hex(token),
+      status: "active",
+      owner,
+      producer,
+      callId,
+      expiresAt,
+      maxObjects,
+      maxBytes,
+      maxObjectBytes,
+      allowedContentTypes,
+      reservations: [],
+      reservedBytes: 0,
+      createdAt: now
+    };
+    if (!await this.cas(`${KEY_STORE_CALL_CAPABILITY}${id}`, null, capability)) {
+      throw new TBError("conflict", "call capability id \u51B2\u7A81");
+    }
+    return { capability: omit2(capability, "tokenHash"), token };
+  }
+  async verifyCallUploadCapability(token) {
+    const id = this.tokenId(token, "call");
+    const raw = await this.state.get(`${KEY_STORE_CALL_CAPABILITY}${id}`);
+    if (raw === null) throw new TBError("permission_denied", "call upload capability \u65E0\u6548");
+    const capability = parseCallCapability(raw);
+    await this.assertTokenHash(token, capability.tokenHash, "call upload capability \u65E0\u6548");
+    if (Date.parse(capability.expiresAt) <= Date.parse(this.nowIso())) {
+      await this.expireCallCapability(capability);
+      throw new TBError("permission_denied", "call upload capability \u5DF2\u8FC7\u671F");
+    }
+    if (capability.status === "revoked" || capability.status === "expired") {
+      throw new TBError("permission_denied", "call upload capability \u5DF2\u5931\u6548");
+    }
+    return capability;
+  }
+  async revokeCallUploadCapability(token) {
+    const id = this.tokenId(token, "call");
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const raw = await this.state.get(`${KEY_STORE_CALL_CAPABILITY}${id}`);
+      if (raw === null) throw new TBError("permission_denied", "call upload capability \u65E0\u6548");
+      const capability = parseCallCapability(raw);
+      await this.assertTokenHash(token, capability.tokenHash, "call upload capability \u65E0\u6548");
+      if (capability.status === "revoked") return;
+      const next = {
+        ...capability,
+        status: "revoked",
+        terminalAt: this.nowIso(),
+        revision: capability.revision + 1
+      };
+      if (await this.cas(`${KEY_STORE_CALL_CAPABILITY}${capability.id}`, capability.revision, next)) {
+        return;
+      }
+    }
+    throw new TBError("conflict", "call capability \u5E76\u53D1\u66F4\u65B0\u51B2\u7A81");
+  }
+  async beginUpload(input, identity) {
+    const owner = requireOwner(identity.owner);
+    const producer = requireOwner(identity.producer ?? identity.owner, "producer");
+    return this.beginNormalized(normalizeUploadInput(input), { owner, producer });
+  }
+  async beginCallUpload(input, capabilityToken) {
+    const capability = await this.verifyCallUploadCapability(capabilityToken);
+    return this.beginNormalized(normalizeUploadInput(input), {
+      owner: capability.owner,
+      producer: capability.producer,
+      originCallId: capability.callId,
+      callCapabilityToken: capabilityToken
+    });
+  }
+  async verifyUploadToken(token) {
+    const id = this.tokenId(token, "upload");
+    const raw = await this.state.get(`${KEY_STORE_UPLOAD}${id}`);
+    if (raw === null) throw new TBError("permission_denied", "upload capability \u65E0\u6548");
+    const session = parseSession(raw);
+    await this.assertTokenHash(token, session.capabilityHash, "upload capability \u65E0\u6548");
+    if (Date.parse(session.expiresAt) <= Date.parse(this.nowIso())) {
+      if (session.status !== "completed") await this.expireUpload(session);
+      throw new TBError("permission_denied", "upload capability \u5DF2\u8FC7\u671F");
+    }
+    if (session.status === "aborted" || session.status === "expired" || session.status === "failed") {
+      throw new TBError("permission_denied", "upload capability \u5DF2\u5931\u6548");
+    }
+    return session;
+  }
+  /** relay PUT 成功即在同一调用内把对象推进 ready；后续 complete 仅作幂等确认。 */
+  async commitRelayUpload(input) {
+    const session = await this.verifyUploadToken(input.uploadToken);
+    if (session.status === "completed") return this.readyDescriptor(session.objectId);
+    if (session.transport !== "relay") {
+      throw new TBError("invalid_argument", "\u8BE5 upload session \u4E0D\u662F relay transport");
+    }
+    const object2 = await this.requireObject(session.objectId);
+    if (object2.status === "ready") {
+      await this.completeSessionBestEffort(session);
+      return descriptorOf(object2);
+    }
+    if (object2.status !== "pending") {
+      throw new TBError("conflict", `\u5BF9\u8C61\u72B6\u6001\u4E0D\u5141\u8BB8\u4E0A\u4F20:${object2.status}`);
+    }
+    let meta3;
+    try {
+      meta3 = await this.objects.put(object2.driverKey, this.boundedBody(input.body, session.maxBytes), {
+        contentType: object2.contentType,
+        ifNoneMatch: "*"
+      });
+    } catch (error51) {
+      if (error51 instanceof TBError && error51.code === "conflict") {
+        const existing = await this.objects.head(object2.driverKey);
+        if (existing === null) throw error51;
+        meta3 = existing;
+      } else {
+        if (error51 instanceof TBError && error51.code === "rate_limited") {
+          await this.objects.delete(object2.driverKey);
+          await this.failUpload(session, object2);
+        }
+        throw error51;
+      }
+    }
+    try {
+      this.assertObserved(session, meta3);
+    } catch (error51) {
+      await this.objects.delete(object2.driverKey);
+      await this.failUpload(session, object2);
+      throw error51;
+    }
+    return this.markReady(session, object2, meta3);
+  }
+  /** 普通管理面 complete：只接受稳定 owner，不接受 capability body 字段。 */
+  async completeUpload(uploadId, actor) {
+    const { session, object: object2 } = await this.authorizeOwnerUploadMutation(uploadId, actor);
+    return this.completeAuthorizedUpload(session, object2);
+  }
+  /** capability-only complete：宿主从 Authorization header 取 token 后调用。 */
+  async completeUploadWithToken(uploadId, uploadToken) {
+    const session = await this.verifyUploadToken(uploadToken);
+    if (session.id !== uploadId) {
+      throw new TBError("permission_denied", "upload capability \u4E0E session \u4E0D\u5339\u914D");
+    }
+    return this.completeAuthorizedUpload(session, await this.requireObject(session.objectId));
+  }
+  async completeAuthorizedUpload(session, object2) {
+    if (session.status === "completed" || object2.status === "ready") {
+      if (object2.status !== "ready") return this.readyDescriptor(object2.id);
+      await this.completeSessionBestEffort(session);
+      return descriptorOf(object2);
+    }
+    if (Date.parse(session.expiresAt) <= Date.parse(this.nowIso())) {
+      await this.expireUpload(session);
+      throw new TBError("conflict", "upload session \u5DF2\u8FC7\u671F");
+    }
+    if (session.transport !== "presigned-put") {
+      throw new TBError("conflict", "relay upload \u5C1A\u672A\u6210\u529F\u63D0\u4EA4\u5B57\u8282");
+    }
+    if (object2.status !== "pending") {
+      throw new TBError("conflict", `\u5BF9\u8C61\u72B6\u6001\u4E0D\u5141\u8BB8 complete:${object2.status}`);
+    }
+    const meta3 = await this.objects.head(object2.driverKey);
+    if (meta3 === null) throw new TBError("conflict", "\u76F4\u4F20\u5BF9\u8C61\u5C1A\u4E0D\u5B58\u5728");
+    try {
+      this.assertObserved(session, meta3);
+    } catch (error51) {
+      await this.objects.delete(object2.driverKey);
+      await this.failUpload(session, object2);
+      throw error51;
+    }
+    return this.markReady(session, object2, meta3);
+  }
+  /** 普通管理面 abort：owner 路径。 */
+  async abortUpload(uploadId, actor) {
+    const { object: object2, session } = await this.authorizeOwnerUploadMutation(uploadId, actor);
+    return this.abortAuthorizedUpload(session, object2);
+  }
+  /** capability-only abort：token 只应来自 Authorization header。 */
+  async abortUploadWithToken(uploadId, uploadToken) {
+    const id = this.tokenId(uploadToken, "upload");
+    const session = await this.requireSession(id);
+    await this.assertTokenHash(uploadToken, session.capabilityHash, "upload capability \u65E0\u6548");
+    if (session.id !== uploadId) {
+      throw new TBError("permission_denied", "upload capability \u4E0E session \u4E0D\u5339\u914D");
+    }
+    return this.abortAuthorizedUpload(session, await this.requireObject(session.objectId));
+  }
+  async abortAuthorizedUpload(sessionInput, objectInput) {
+    let object2 = objectInput;
+    let session = sessionInput;
+    if (object2.status === "ready" || session.status === "completed") {
+      throw new TBError("conflict", "ready \u5BF9\u8C61\u4E0D\u80FD abort");
+    }
+    if (object2.status === "pending") {
+      const next = {
+        ...object2,
+        status: "abandoned",
+        updatedAt: this.nowIso(),
+        revision: object2.revision + 1
+      };
+      if (await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, next)) object2 = next;
+      else object2 = await this.requireObject(object2.id);
+    }
+    if (object2.status === "ready") throw new TBError("conflict", "ready \u5BF9\u8C61\u4E0D\u80FD abort");
+    if (session.status === "created") {
+      const terminalAt = this.nowIso();
+      const next = {
+        ...session,
+        status: "aborted",
+        terminalAt,
+        revision: session.revision + 1
+      };
+      if (await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, session.revision, next)) session = next;
+      else session = await this.requireSession(session.id);
+    }
+    if (session.status === "completed") throw new TBError("conflict", "ready \u5BF9\u8C61\u4E0D\u80FD abort");
+    await this.objects.delete(object2.driverKey);
+    await this.markBytesDeleted(object2.id, object2.driverKey);
+    return { ok: true };
+  }
+  async stat(uri, access) {
+    const object2 = await this.authorizeReadyObject(uri, access);
+    return descriptorOf(object2);
+  }
+  /** 宿主 read callback 在拿到此结果后签发 relay/presigned GET；core 不构造网络 URL。 */
+  async authorizeRead(uri, access) {
+    return this.authorizeReadyObject(uri, access);
+  }
+  /** share token 由宿主从 header 取出，不进入普通 builtin arguments。 */
+  async authorizeSharedRead(uri, shareToken) {
+    await this.verifyShareToken(shareToken, uri);
+    const object2 = await this.requireObject(parseStoreUri(uri).objectId);
+    if (object2.status !== "ready") throw new TBError("not_found", "Store \u5BF9\u8C61\u4E0D\u5B58\u5728");
+    return object2;
+  }
+  async list(owner, opts = {}) {
+    const wantedOwner = requireOwner(owner);
+    const limit = Math.min(Math.max(1, opts.limit ?? LIST_LIMIT_DEFAULT), LIST_LIMIT_MAX);
+    const page = await this.state.list(KEY_STORE_OBJECT, {
+      limit: Math.min(LIST_LIMIT_MAX, limit * 4),
+      ...opts.cursor !== void 0 ? { cursor: opts.cursor } : {}
+    });
+    const items = [];
+    for (let index = 0; index < page.items.length; index++) {
+      const item = page.items[index];
+      if (item === void 0) continue;
+      const object2 = parseObject(item.value);
+      if (object2.owner !== wantedOwner || object2.status !== "ready") continue;
+      items.push(descriptorOf(object2));
+      if (items.length >= limit) {
+        const hasUnscanned = index < page.items.length - 1 || page.cursor !== void 0;
+        return hasUnscanned ? { items, cursor: item.key } : { items };
+      }
+    }
+    return page.cursor !== void 0 ? { items, cursor: page.cursor } : { items };
+  }
+  async delete(uri, actor) {
+    const { objectId } = parseStoreUri(uri);
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const object2 = await this.requireObject(objectId);
+      if (!actor.admin && object2.owner !== actor.owner) {
+        throw new TBError("not_found", "Store \u5BF9\u8C61\u4E0D\u5B58\u5728");
+      }
+      if (object2.status === "deleted") return { ok: true };
+      const next = {
+        ...object2,
+        status: "deleted",
+        updatedAt: this.nowIso(),
+        revision: object2.revision + 1
+      };
+      if (!await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, next)) continue;
+      await this.objects.delete(object2.driverKey);
+      await this.markBytesDeleted(object2.id, object2.driverKey);
+      return { ok: true };
+    }
+    throw new TBError("conflict", "Store \u5BF9\u8C61\u5E76\u53D1\u5220\u9664\u51B2\u7A81");
+  }
+  async share(uri, actor, ttlSec = this.shareTtlSec) {
+    const owner = requireOwner(actor);
+    const object2 = await this.authorizeReadyObject(uri, { owner });
+    const ttl = requireCapabilityTtl(ttlSec, "ttlSec");
+    if (ttl > this.shareTtlSec) {
+      throw new TBError("invalid_argument", `ttlSec \u4E0D\u80FD\u8D85\u8FC7 ${this.shareTtlSec}`);
+    }
+    const now = this.nowIso();
+    const id = this.randomId();
+    const token = await this.tokenFor("share", id);
+    const grant = {
+      id,
+      objectId: object2.id,
+      tokenHash: await sha256Hex(token),
+      status: "active",
+      createdBy: owner,
+      createdAt: now,
+      expiresAt: this.afterSeconds(now, ttl),
+      revision: 1
+    };
+    if (!await this.cas(`${KEY_STORE_SHARE}${id}`, null, grant)) {
+      throw new TBError("conflict", "share id \u51B2\u7A81");
+    }
+    return { shareId: id, token, uri: storeUri(object2.id), expiresAt: grant.expiresAt };
+  }
+  async verifyShareToken(token, expectedUri) {
+    const id = this.tokenId(token, "share");
+    const raw = await this.state.get(`${KEY_STORE_SHARE}${id}`);
+    if (raw === null) throw new TBError("permission_denied", "share capability \u65E0\u6548");
+    const grant = parseShare(raw);
+    await this.assertTokenHash(token, grant.tokenHash, "share capability \u65E0\u6548");
+    if (expectedUri !== void 0 && parseStoreUri(expectedUri).objectId !== grant.objectId) {
+      throw new TBError("permission_denied", "share capability \u4E0E\u5BF9\u8C61\u4E0D\u5339\u914D");
+    }
+    if (Date.parse(grant.expiresAt) <= Date.parse(this.nowIso())) {
+      await this.expireShare(grant);
+      throw new TBError("permission_denied", "share capability \u5DF2\u8FC7\u671F");
+    }
+    if (grant.status !== "active") {
+      throw new TBError("permission_denied", "share capability \u5DF2\u5931\u6548");
+    }
+    return grant;
+  }
+  async revokeShare(shareId, actor) {
+    const owner = requireOwner(actor);
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const raw = await this.state.get(`${KEY_STORE_SHARE}${shareId}`);
+      if (raw === null) throw new TBError("not_found", "share grant \u4E0D\u5B58\u5728");
+      const grant = parseShare(raw);
+      const object2 = await this.requireObject(grant.objectId);
+      if (object2.owner !== owner) throw new TBError("not_found", "share grant \u4E0D\u5B58\u5728");
+      if (grant.status === "revoked") return { ok: true };
+      const next = {
+        ...grant,
+        status: "revoked",
+        terminalAt: this.nowIso(),
+        revision: grant.revision + 1
+      };
+      if (await this.cas(`${KEY_STORE_SHARE}${grant.id}`, grant.revision, next)) {
+        return { ok: true };
+      }
+    }
+    throw new TBError("conflict", "share grant \u5E76\u53D1\u64A4\u9500\u51B2\u7A81");
+  }
+  /**
+   * 宿主定时器/Cron 调用的幂等清理步。终态记录先保留一个 capability TTL 窗口，
+   * 再以 CAS 物理删除；无 metadata 的 driver 对象可能属于 legacy Context，绝不猜测为 orphan。
+   * 返回 cursor 时宿主必须续调，直到 cursor 缺省。
+   */
+  async cleanup(opts = {}) {
+    const pageLimit = Math.min(Math.max(1, opts.limit ?? LIST_LIMIT_MAX), LIST_LIMIT_MAX);
+    const result = {
+      expiredUploads: 0,
+      abandonedObjects: 0,
+      deletedBytes: 0,
+      deletedOrphans: 0,
+      deletedStaging: 0,
+      expiredCallCapabilities: 0,
+      expiredIdempotencyBindings: 0,
+      expiredShares: 0
+    };
+    const now = this.nowIso();
+    const nowMs = Date.parse(now);
+    const olderThan = new Date(nowMs - this.uploadTtlSec * 1e3).toISOString();
+    if (opts.runDriverMaintenance !== false && this.objects.cleanupStaging !== void 0) {
+      result.deletedStaging = await this.objects.cleanupStaging(
+        `${DEFAULT_STORE_DRIVER_KEY_ROOT}/`,
+        olderThan
+      );
+    }
+    const uploads = opts.cursors?.uploads === null ? { items: [] } : await this.state.list(KEY_STORE_UPLOAD, {
+      limit: pageLimit,
+      ...opts.cursors?.uploads !== void 0 ? { cursor: opts.cursors.uploads } : {}
+    });
+    for (const item of uploads.items) {
+      let session = parseSession(item.value);
+      if (session.status === "created" && Date.parse(session.expiresAt) <= nowMs) {
+        await this.expireUpload(session);
+        const currentRaw = await this.state.get(item.key);
+        if (currentRaw === null) continue;
+        session = parseSession(currentRaw);
+        if (session.status === "expired") result.expiredUploads++;
+      }
+      if (this.uploadSessionIsTerminal(session) && this.retentionElapsed(this.uploadSessionTerminalAt(session), this.uploadTtlSec, nowMs)) {
+        await this.cas(item.key, session.revision, null);
+      }
+    }
+    const shares = opts.cursors?.shares === null ? { items: [] } : await this.state.list(KEY_STORE_SHARE, {
+      limit: pageLimit,
+      ...opts.cursors?.shares !== void 0 ? { cursor: opts.cursors.shares } : {}
+    });
+    for (const item of shares.items) {
+      let grant = parseShare(item.value);
+      if (grant.status === "active" && Date.parse(grant.expiresAt) <= nowMs) {
+        await this.expireShare(grant);
+        const currentRaw = await this.state.get(item.key);
+        if (currentRaw === null) continue;
+        grant = parseShare(currentRaw);
+        if (grant.status === "expired") result.expiredShares++;
+      }
+      if (grant.status !== "active" && this.retentionElapsed(grant.terminalAt ?? grant.expiresAt, this.shareTtlSec, nowMs)) {
+        await this.cas(item.key, grant.revision, null);
+      }
+    }
+    const capabilities = opts.cursors?.callCapabilities === null ? { items: [] } : await this.state.list(KEY_STORE_CALL_CAPABILITY, {
+      limit: pageLimit,
+      ...opts.cursors?.callCapabilities !== void 0 ? { cursor: opts.cursors.callCapabilities } : {}
+    });
+    for (const item of capabilities.items) {
+      let capability = parseCallCapability(item.value);
+      if ((capability.status === "active" || capability.status === "exhausted") && Date.parse(capability.expiresAt) <= nowMs) {
+        await this.expireCallCapability(capability);
+        const currentRaw = await this.state.get(item.key);
+        if (currentRaw === null) continue;
+        capability = parseCallCapability(currentRaw);
+        if (capability.status === "expired") result.expiredCallCapabilities++;
+      }
+      if ((capability.status === "expired" || capability.status === "revoked") && this.retentionElapsed(
+        capability.terminalAt ?? capability.expiresAt,
+        this.uploadTtlSec,
+        nowMs
+      )) {
+        await this.cas(item.key, capability.revision, null);
+      }
+    }
+    const idempotencyBindings = opts.cursors?.idempotencyBindings === null ? { items: [] } : await this.state.list(KEY_STORE_IDEMPOTENCY, {
+      limit: pageLimit,
+      ...opts.cursors?.idempotencyBindings !== void 0 ? { cursor: opts.cursors.idempotencyBindings } : {}
+    });
+    for (const item of idempotencyBindings.items) {
+      const binding = parseIdempotencyBinding(item.value);
+      if (Date.parse(binding.expiresAt) > nowMs) continue;
+      if (await this.cas(item.key, binding.revision, null)) {
+        result.expiredIdempotencyBindings++;
+      }
+    }
+    const objectRecords = opts.cursors?.objects === null ? { items: [] } : await this.state.list(KEY_STORE_OBJECT, {
+      limit: pageLimit,
+      ...opts.cursors?.objects !== void 0 ? { cursor: opts.cursors.objects } : {}
+    });
+    for (const item of objectRecords.items) {
+      let object2 = parseObject(item.value);
+      if (object2.status === "ready" && object2.expiresAt !== void 0 && Date.parse(object2.expiresAt) <= nowMs) {
+        const deleted = {
+          ...object2,
+          status: "deleted",
+          updatedAt: now,
+          revision: object2.revision + 1
+        };
+        if (await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, deleted)) {
+          object2 = deleted;
+        } else {
+          const currentRaw = await this.state.get(item.key);
+          if (currentRaw === null) continue;
+          object2 = parseObject(currentRaw);
+        }
+      } else if (object2.status === "pending" && Date.parse(object2.updatedAt) + this.uploadTtlSec * 1e3 <= nowMs) {
+        const sessionRaw = await this.state.get(`${KEY_STORE_UPLOAD}${object2.uploadId}`);
+        const session = sessionRaw === null ? void 0 : parseSession(sessionRaw);
+        const uploadEnded = session === void 0 || session.status !== "created" || Date.parse(session.expiresAt) <= nowMs;
+        if (uploadEnded) {
+          const abandoned = {
+            ...object2,
+            status: "abandoned",
+            updatedAt: now,
+            revision: object2.revision + 1
+          };
+          if (await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, abandoned)) {
+            object2 = abandoned;
+            result.abandonedObjects++;
+          } else {
+            const currentRaw = await this.state.get(item.key);
+            if (currentRaw === null) continue;
+            object2 = parseObject(currentRaw);
+          }
+        }
+      }
+      if (this.objectIsTerminal(object2) && object2.bytesDeletedAt === void 0) {
+        await this.objects.delete(object2.driverKey);
+        result.deletedBytes++;
+        await this.markBytesDeleted(object2.id, object2.driverKey);
+        const currentRaw = await this.state.get(item.key);
+        if (currentRaw === null) continue;
+        object2 = parseObject(currentRaw);
+      }
+      if (this.objectIsTerminal(object2) && object2.bytesDeletedAt !== void 0 && this.retentionElapsed(object2.bytesDeletedAt, this.uploadTtlSec, nowMs)) {
+        await this.cas(item.key, object2.revision, null);
+      }
+    }
+    const cursors = {
+      uploads: uploads.cursor ?? null,
+      shares: shares.cursor ?? null,
+      callCapabilities: capabilities.cursor ?? null,
+      idempotencyBindings: idempotencyBindings.cursor ?? null,
+      objects: objectRecords.cursor ?? null,
+      driverObjects: null
+    };
+    return Object.values(cursors).some((cursor) => cursor !== null) ? { ...result, cursors } : result;
+  }
+  async beginNormalized(input, identity) {
+    if (input.size !== void 0 && input.size > this.maxObjectBytes) {
+      throw new TBError("rate_limited", `\u5BF9\u8C61\u8D85\u8FC7\u90E8\u7F72\u4E0A\u9650 ${this.maxObjectBytes} bytes`);
+    }
+    const resolved = await this.resolveBinding(identity, input);
+    const binding = resolved.binding;
+    const existingRaw = await this.state.get(`${KEY_STORE_UPLOAD}${binding.uploadId}`);
+    if (existingRaw !== null) {
+      const existing = parseSession(existingRaw);
+      if (existing.objectId !== binding.objectId) throw stateCorrupt("idempotent upload");
+      this.assertBindingObject(binding, await this.requireObject(binding.objectId));
+      return this.startFor(existing);
+    }
+    const now = this.nowIso();
+    const driverKey = this.driverKey(binding.objectId);
+    let transport = "relay";
+    let effectiveMaxBytes = this.relayMaxBytes;
+    let signedRequest;
+    if (input.size !== void 0 && this.objects.presignPutExact !== void 0) {
+      try {
+        signedRequest = await this.objects.presignPutExact(driverKey, this.uploadTtlSec, {
+          contentType: input.contentType,
+          contentLength: input.size,
+          ifNoneMatch: "*"
+        });
+        transport = "presigned-put";
+        effectiveMaxBytes = this.maxObjectBytes;
+      } catch {
+      }
+    }
+    let maxBytes = effectiveMaxBytes;
+    if (identity.callCapabilityToken !== void 0) {
+      try {
+        maxBytes = await this.reserveCallCapability(
+          identity.callCapabilityToken,
+          binding.objectId,
+          input,
+          effectiveMaxBytes
+        );
+      } catch (error51) {
+        await this.releaseFreshBinding(resolved);
+        throw error51;
+      }
+    }
+    if (input.size !== void 0 && input.size > maxBytes) {
+      await this.releaseFreshBinding(resolved);
+      throw new TBError("rate_limited", `\u5BF9\u8C61\u8D85\u8FC7\u672C\u6B21\u4E0A\u4F20\u4E0A\u9650 ${maxBytes} bytes`);
+    }
+    const object2 = {
+      id: binding.objectId,
+      store: DEFAULT_STORE_NAME,
+      driverKey,
+      uploadId: binding.uploadId,
+      status: "pending",
+      owner: binding.owner,
+      producer: binding.producer,
+      contentType: input.contentType,
+      createdAt: now,
+      updatedAt: now,
+      revision: 1,
+      ...input.filename !== void 0 ? { filename: input.filename } : {},
+      ...input.size !== void 0 ? { expectedSize: input.size } : {},
+      ...input.checksum !== void 0 ? { expectedChecksum: input.checksum } : {},
+      ...binding.originCallId !== void 0 ? { originCallId: binding.originCallId } : {}
+    };
+    const uploadToken = await this.tokenFor("upload", binding.uploadId);
+    const session = {
+      id: binding.uploadId,
+      objectId: object2.id,
+      status: "created",
+      capabilityHash: await sha256Hex(uploadToken),
+      transport,
+      contentType: input.contentType,
+      maxBytes,
+      expiresAt: this.afterSeconds(now, this.uploadTtlSec),
+      attempts: 0,
+      createdAt: now,
+      revision: 1,
+      ...input.size !== void 0 ? { expectedSize: input.size } : {},
+      ...input.checksum !== void 0 ? { expectedChecksum: input.checksum } : {},
+      ...input.idempotencyKey !== void 0 ? { idempotencyKeyHash: await sha256Hex(input.idempotencyKey) } : {}
+    };
+    const objectCreated = await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, null, object2);
+    if (!objectCreated) {
+      const current = await this.requireObject(object2.id);
+      if (current.owner !== object2.owner || current.producer !== object2.producer || current.originCallId !== object2.originCallId || current.uploadId !== object2.uploadId || current.contentType !== object2.contentType) {
+        throw new TBError("conflict", "Store object id \u51B2\u7A81");
+      }
+    }
+    if (!await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, null, session)) {
+      const current = await this.requireSession(session.id);
+      if (current.objectId !== object2.id) throw new TBError("conflict", "upload id \u51B2\u7A81");
+      this.assertBindingObject(binding, await this.requireObject(current.objectId));
+      return this.startFor(current);
+    }
+    return {
+      uploadId: session.id,
+      objectUri: storeUri(object2.id),
+      uploadToken,
+      transport,
+      expiresAt: session.expiresAt,
+      maxBytes,
+      alreadyCompleted: false,
+      ...signedRequest !== void 0 ? { signedRequest } : {}
+    };
+  }
+  async resolveBinding(identity, input) {
+    const now = this.nowIso();
+    const domain2 = identity.originCallId === void 0 ? "owner" : "call";
+    const fresh = () => ({
+      owner: identity.owner,
+      producer: identity.producer,
+      domain: domain2,
+      objectId: this.randomId(),
+      uploadId: this.randomId(),
+      fingerprint: "",
+      createdAt: now,
+      expiresAt: this.afterSeconds(now, this.uploadTtlSec),
+      revision: 1,
+      ...identity.originCallId !== void 0 ? { originCallId: identity.originCallId } : {}
+    });
+    if (input.idempotencyKey === void 0) return { binding: fresh(), created: false };
+    const fingerprint = await sha256Hex(JSON.stringify([
+      input.contentType,
+      input.filename ?? null,
+      input.size ?? null,
+      input.checksum ?? null
+    ]));
+    const ownerHash = await sha256Hex(identity.owner);
+    const scopeHash = await sha256Hex(JSON.stringify([
+      domain2,
+      ...domain2 === "call" ? [identity.producer, identity.originCallId] : []
+    ]));
+    const keyHash = await sha256Hex(input.idempotencyKey);
+    const key = `${KEY_STORE_IDEMPOTENCY}${ownerHash}:${domain2}:${scopeHash}:${keyHash}`;
+    const candidate = { ...fresh(), fingerprint };
+    if (await this.cas(key, null, candidate)) return { binding: candidate, created: true, key };
+    const raw = await this.state.get(key);
+    if (raw === null) throw new TBError("conflict", "idempotency binding \u5E76\u53D1\u521B\u5EFA\u51B2\u7A81");
+    const existing = parseIdempotencyBinding(raw);
+    if (!this.bindingMatchesIdentity(existing, identity) || existing.fingerprint !== fingerprint) {
+      throw new TBError("conflict", "idempotencyKey \u5DF2\u7ED1\u5B9A\u5230\u4E0D\u540C\u4E0A\u4F20\u58F0\u660E");
+    }
+    if (Date.parse(existing.expiresAt) <= Date.parse(now)) {
+      throw new TBError("conflict", "idempotencyKey \u5BF9\u5E94\u7684 upload session \u5DF2\u8FC7\u671F");
+    }
+    return { binding: existing, created: false, key };
+  }
+  async releaseFreshBinding(resolved) {
+    if (!resolved.created || resolved.key === void 0) return;
+    if (await this.state.get(`${KEY_STORE_UPLOAD}${resolved.binding.uploadId}`) !== null) return;
+    await this.cas(resolved.key, resolved.binding.revision, null);
+  }
+  async reserveCallCapability(token, objectId, input, transportMaxBytes) {
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const capability = await this.verifyCallUploadCapability(token);
+      const previous = capability.reservations.find((r) => r.objectId === objectId);
+      if (previous !== void 0) return previous.maxBytes;
+      if (capability.status !== "active") {
+        throw new TBError("rate_limited", "call upload capability \u914D\u989D\u5DF2\u8017\u5C3D");
+      }
+      if (!contentTypeAllowed(input.contentType, capability.allowedContentTypes)) {
+        throw new TBError("permission_denied", `call \u4E0D\u5141\u8BB8\u4E0A\u4F20 ${input.contentType}`);
+      }
+      if (capability.reservations.length >= capability.maxObjects) {
+        throw new TBError("rate_limited", "call upload object \u6570\u91CF\u5DF2\u8FBE\u4E0A\u9650");
+      }
+      const remaining = capability.maxBytes - capability.reservedBytes;
+      const maxBytes = Math.min(
+        capability.maxObjectBytes,
+        input.size ?? capability.maxObjectBytes,
+        remaining,
+        transportMaxBytes
+      );
+      if (maxBytes < 1 || input.size !== void 0 && input.size > maxBytes) {
+        throw new TBError("rate_limited", "call upload bytes \u914D\u989D\u4E0D\u8DB3");
+      }
+      const reservations = [...capability.reservations, { objectId, maxBytes }];
+      const reservedBytes = capability.reservedBytes + maxBytes;
+      const exhausted = reservations.length >= capability.maxObjects || reservedBytes >= capability.maxBytes;
+      const next = {
+        ...capability,
+        reservations,
+        reservedBytes,
+        status: exhausted ? "exhausted" : "active",
+        revision: capability.revision + 1
+      };
+      if (await this.cas(
+        `${KEY_STORE_CALL_CAPABILITY}${capability.id}`,
+        capability.revision,
+        next
+      )) return maxBytes;
+    }
+    throw new TBError("conflict", "call upload capability \u5E76\u53D1\u6D88\u8D39\u51B2\u7A81");
+  }
+  async startFor(session) {
+    const object2 = await this.requireObject(session.objectId);
+    const uploadToken = await this.tokenFor("upload", session.id);
+    if (session.status === "completed" && object2.status === "ready") {
+      return {
+        uploadId: session.id,
+        objectUri: storeUri(object2.id),
+        uploadToken,
+        transport: session.transport,
+        expiresAt: session.expiresAt,
+        maxBytes: session.maxBytes,
+        alreadyCompleted: true,
+        descriptor: descriptorOf(object2)
+      };
+    }
+    if (session.status !== "created" || object2.status !== "pending") {
+      throw new TBError("conflict", `upload session \u4E0D\u53EF\u6062\u590D:${session.status}/${object2.status}`);
+    }
+    const remainingMs = Date.parse(session.expiresAt) - Date.parse(this.nowIso());
+    if (remainingMs <= 0) {
+      await this.expireUpload(session);
+      throw new TBError("conflict", "upload session \u5DF2\u8FC7\u671F");
+    }
+    let signedRequest;
+    if (session.transport === "presigned-put" && session.expectedSize !== void 0 && this.objects.presignPutExact !== void 0) {
+      signedRequest = await this.objects.presignPutExact(
+        object2.driverKey,
+        Math.max(1, Math.floor(remainingMs / 1e3)),
+        {
+          contentType: object2.contentType,
+          contentLength: session.expectedSize,
+          ifNoneMatch: "*"
+        }
+      );
+    }
+    return {
+      uploadId: session.id,
+      objectUri: storeUri(object2.id),
+      uploadToken,
+      transport: session.transport,
+      expiresAt: session.expiresAt,
+      maxBytes: session.maxBytes,
+      alreadyCompleted: false,
+      ...signedRequest !== void 0 ? { signedRequest } : {}
+    };
+  }
+  bindingMatchesIdentity(binding, identity) {
+    if (binding.owner !== identity.owner) return false;
+    if (binding.domain === "owner") {
+      return identity.originCallId === void 0 && binding.originCallId === void 0 && binding.producer === identity.producer;
+    }
+    return identity.originCallId !== void 0 && binding.producer === identity.producer && binding.originCallId === identity.originCallId;
+  }
+  assertBindingObject(binding, object2) {
+    if (object2.id !== binding.objectId || object2.uploadId !== binding.uploadId || object2.owner !== binding.owner || object2.producer !== binding.producer || object2.originCallId !== binding.originCallId) throw stateCorrupt("idempotent upload identity");
+  }
+  uploadSessionIsTerminal(session) {
+    return session.status === "completed" || session.status === "aborted" || session.status === "expired" || session.status === "failed";
+  }
+  uploadSessionTerminalAt(session) {
+    return session.terminalAt ?? session.completedAt ?? session.expiresAt;
+  }
+  objectIsTerminal(object2) {
+    return object2.status === "failed" || object2.status === "abandoned" || object2.status === "deleted";
+  }
+  retentionElapsed(timestamp, ttlSec, nowMs) {
+    return Date.parse(timestamp) + ttlSec * 1e3 <= nowMs;
+  }
+  /** driver DELETE 成功后持久化证据；后续 cleanup 只收 tombstone，不再重复外部 DELETE。 */
+  async markBytesDeleted(objectId, expectedDriverKey) {
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const raw = await this.state.get(`${KEY_STORE_OBJECT}${objectId}`);
+      if (raw === null) return;
+      const object2 = parseObject(raw);
+      if (object2.driverKey !== expectedDriverKey) throw stateCorrupt("object driver key");
+      if (!this.objectIsTerminal(object2) || object2.bytesDeletedAt !== void 0) return;
+      const next = {
+        ...object2,
+        bytesDeletedAt: this.nowIso(),
+        revision: object2.revision + 1
+      };
+      if (await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, next)) return;
+    }
+    throw new TBError("conflict", "Store \u5BF9\u8C61\u5B57\u8282\u5220\u9664\u72B6\u6001\u5E76\u53D1\u66F4\u65B0\u51B2\u7A81");
+  }
+  async authorizeOwnerUploadMutation(uploadId, actorInput) {
+    const session = await this.requireSession(uploadId);
+    const object2 = await this.requireObject(session.objectId);
+    const actor = requireOwner(actorInput, "actor");
+    if (actor !== object2.owner) {
+      throw new TBError("not_found", "upload session \u4E0D\u5B58\u5728");
+    }
+    return { session, object: object2 };
+  }
+  async authorizeReadyObject(uri, access) {
+    const { objectId } = parseStoreUri(uri);
+    const object2 = await this.requireObject(objectId);
+    if (object2.status !== "ready") throw new TBError("not_found", "Store \u5BF9\u8C61\u4E0D\u5B58\u5728");
+    if (access.admin === true || access.owner !== void 0 && access.owner === object2.owner) {
+      return object2;
+    }
+    throw new TBError("not_found", "Store \u5BF9\u8C61\u4E0D\u5B58\u5728");
+  }
+  assertObserved(session, meta3) {
+    if (!Number.isSafeInteger(meta3.size) || meta3.size < 0 || meta3.size > session.maxBytes) {
+      throw new TBError("rate_limited", `\u4E0A\u4F20\u5BF9\u8C61\u8D85\u8FC7 ${session.maxBytes} bytes`);
+    }
+    if (session.expectedSize !== void 0 && meta3.size !== session.expectedSize) {
+      throw new TBError("conflict", "\u4E0A\u4F20\u5BF9\u8C61 size \u4E0E create_upload \u58F0\u660E\u4E0D\u4E00\u81F4");
+    }
+    if (session.expectedChecksum !== void 0) {
+      const actual = meta3.metadata?.["checksum-sha256"]?.toLowerCase();
+      if (actual !== void 0 && actual !== session.expectedChecksum.value) {
+        throw new TBError("conflict", "\u4E0A\u4F20\u5BF9\u8C61 checksum \u4E0D\u4E00\u81F4");
+      }
+    }
+  }
+  /**
+   * relay 的权威流中限额。已知内存 body 先快速拒绝；未知流逐 chunk 累计，
+   * 越界立刻 cancel。driver 必须在源流抛错时删除自己的临时文件。
+   */
+  boundedBody(body, maxBytes) {
+    let knownBytes;
+    if (typeof body === "string") knownBytes = new TextEncoder().encode(body).byteLength;
+    else if (body instanceof Uint8Array) knownBytes = body.byteLength;
+    else if (body instanceof ArrayBuffer) knownBytes = body.byteLength;
+    if (knownBytes !== void 0) {
+      if (knownBytes > maxBytes) {
+        throw new TBError("rate_limited", `\u4E0A\u4F20\u5BF9\u8C61\u8D85\u8FC7 ${maxBytes} bytes`);
+      }
+      return body;
+    }
+    const source = body;
+    const bounded = {
+      async cancel(reason) {
+        await source.cancel?.(reason);
+      },
+      getReader() {
+        const reader = source.getReader();
+        let consumed = 0;
+        return {
+          async read() {
+            const chunk = await reader.read();
+            if (!chunk.done && chunk.value !== void 0) {
+              consumed += chunk.value.byteLength;
+              if (consumed > maxBytes) {
+                try {
+                  if (reader.cancel !== void 0) await reader.cancel("Store upload size limit");
+                  else await source.cancel?.("Store upload size limit");
+                } catch {
+                }
+                throw new TBError("rate_limited", `\u4E0A\u4F20\u5BF9\u8C61\u8D85\u8FC7 ${maxBytes} bytes`);
+              }
+            }
+            return chunk;
+          },
+          releaseLock() {
+            reader.releaseLock();
+          },
+          async cancel(reason) {
+            if (reader.cancel !== void 0) await reader.cancel(reason);
+            else await source.cancel?.(reason);
+          }
+        };
+      }
+    };
+    return bounded;
+  }
+  async markReady(sessionInput, objectInput, meta3) {
+    let object2 = await this.requireObject(objectInput.id);
+    if (object2.status === "ready") {
+      const currentSession = await this.requireSession(sessionInput.id);
+      await this.completeSessionBestEffort(currentSession);
+      return descriptorOf(object2);
+    }
+    if (object2.status !== "pending") {
+      await this.objects.delete(object2.driverKey);
+      await this.markBytesDeleted(object2.id, object2.driverKey);
+      throw new TBError("conflict", `\u5BF9\u8C61\u72B6\u6001\u4E0D\u5141\u8BB8 ready:${object2.status}`);
+    }
+    const now = this.nowIso();
+    const actualChecksum = sessionInput.expectedChecksum !== void 0 && meta3.metadata?.["checksum-sha256"]?.toLowerCase() === sessionInput.expectedChecksum.value ? sessionInput.expectedChecksum : void 0;
+    const ready = {
+      ...object2,
+      status: "ready",
+      size: meta3.size,
+      etag: meta3.etag,
+      readyAt: now,
+      updatedAt: now,
+      revision: object2.revision + 1,
+      ...actualChecksum !== void 0 ? { checksum: actualChecksum } : {}
+    };
+    if (!await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, ready)) {
+      object2 = await this.requireObject(object2.id);
+      if (object2.status !== "ready") {
+        await this.objects.delete(object2.driverKey);
+        await this.markBytesDeleted(object2.id, object2.driverKey);
+        throw new TBError("conflict", `\u5BF9\u8C61\u5E76\u53D1\u72B6\u6001\u51B2\u7A81:${object2.status}`);
+      }
+    } else {
+      object2 = ready;
+    }
+    const session = await this.requireSession(sessionInput.id);
+    await this.completeSessionBestEffort(session);
+    return descriptorOf(object2);
+  }
+  async completeSessionBestEffort(session) {
+    if (session.status === "completed") return;
+    if (session.status !== "created") return;
+    const completedAt = this.nowIso();
+    const next = {
+      ...session,
+      status: "completed",
+      completedAt,
+      terminalAt: completedAt,
+      revision: session.revision + 1
+    };
+    await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, session.revision, next);
+  }
+  async failUpload(session, object2) {
+    const terminalAt = this.nowIso();
+    if (object2.status === "pending") {
+      const failed = {
+        ...object2,
+        status: "failed",
+        bytesDeletedAt: terminalAt,
+        updatedAt: terminalAt,
+        revision: object2.revision + 1
+      };
+      await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, failed);
+    }
+    if (session.status === "created") {
+      const failed = {
+        ...session,
+        status: "failed",
+        terminalAt,
+        revision: session.revision + 1
+      };
+      await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, session.revision, failed);
+    }
+    await this.markBytesDeleted(object2.id, object2.driverKey);
+  }
+  async expireUpload(session) {
+    if (session.status !== "created") return;
+    const next = {
+      ...session,
+      status: "expired",
+      terminalAt: this.nowIso(),
+      revision: session.revision + 1
+    };
+    if (!await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, session.revision, next)) return;
+    const object2 = await this.requireObject(session.objectId);
+    if (object2.status === "pending") {
+      const abandoned = {
+        ...object2,
+        status: "abandoned",
+        updatedAt: this.nowIso(),
+        revision: object2.revision + 1
+      };
+      await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, abandoned);
+    }
+  }
+  async expireCallCapability(capability) {
+    if (capability.status === "expired" || capability.status === "revoked") return;
+    const next = {
+      ...capability,
+      status: "expired",
+      terminalAt: this.nowIso(),
+      revision: capability.revision + 1
+    };
+    await this.cas(`${KEY_STORE_CALL_CAPABILITY}${capability.id}`, capability.revision, next);
+  }
+  async expireShare(grant) {
+    if (grant.status !== "active") return;
+    const next = {
+      ...grant,
+      status: "expired",
+      terminalAt: this.nowIso(),
+      revision: grant.revision + 1
+    };
+    await this.cas(`${KEY_STORE_SHARE}${grant.id}`, grant.revision, next);
+  }
+  async readyDescriptor(objectId) {
+    return descriptorOf(await this.requireObject(objectId));
+  }
+  async requireObject(id) {
+    const raw = await this.state.get(`${KEY_STORE_OBJECT}${id}`);
+    if (raw === null) throw new TBError("not_found", "Store \u5BF9\u8C61\u4E0D\u5B58\u5728");
+    return parseObject(raw);
+  }
+  async requireSession(id) {
+    const raw = await this.state.get(`${KEY_STORE_UPLOAD}${id}`);
+    if (raw === null) throw new TBError("not_found", "upload session \u4E0D\u5B58\u5728");
+    return parseSession(raw);
+  }
+  async assertTokenHash(token, expected, message) {
+    if (!constantTimeEqual(await sha256Hex(token), expected)) {
+      throw new TBError("permission_denied", message);
+    }
+  }
+  tokenId(token, domain2) {
+    if (typeof token !== "string") throw new TBError("permission_denied", "capability token \u65E0\u6548");
+    const prefix = TOKEN_PREFIX[domain2];
+    const match = new RegExp(`^${prefix}_([A-Za-z0-9_-]{22,64})\\.([A-Za-z0-9_-]{43})$`).exec(token);
+    if (match?.[1] === void 0) {
+      throw new TBError("permission_denied", "capability token \u65E0\u6548");
+    }
+    return match[1];
+  }
+  async tokenFor(domain2, id) {
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey(
+      "raw",
+      encoder.encode(this.tokenSecret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(`store:${domain2}:${id}`));
+    return `${TOKEN_PREFIX[domain2]}_${id}.${base64urlEncode(new Uint8Array(signature))}`;
+  }
+  randomId() {
+    return base64urlEncode(crypto.getRandomValues(new Uint8Array(18)));
+  }
+  driverKey(objectId) {
+    return `${DEFAULT_STORE_DRIVER_KEY_ROOT}/${objectId.slice(0, 2)}/${objectId}`;
+  }
+  nowIso() {
+    return normalizeTimestamp(this.now(), "now");
+  }
+  afterSeconds(now, seconds) {
+    return new Date(Date.parse(now) + seconds * 1e3).toISOString();
+  }
+};
+
 // ../core/src/operation/registry.ts
 function normalizeSchema(input) {
   return input instanceof external_exports.ZodType ? input : external_exports.object(input);
@@ -20293,16 +21934,23 @@ export {
   normalizeUpstreamError,
   assertSecureUrl,
   pluginTokenSecretName,
+  createStoreModule,
   RemoteAllowlistStore,
   parseNodeInput,
   createBuiltins,
   CONTEXT_CAPABILITIES,
+  CONTEXT_DIRECT_UPLOAD_CAPABILITY,
   contextScopeForCmd,
+  contextUploadCmd,
   contextHelpModel,
   objectBodyToBytes,
   bytesToObjectStream,
+  DEFAULT_STORE_DRIVER_KEY_ROOT,
   normalizeEntryPath,
   PRESIGN_TTL_SEC_DEFAULT,
+  PRESIGN_TTL_SEC_MAX,
+  assertPresignTtlSec,
+  createObjectContextUploadGrant,
   createObjectContextProvider,
   isContextExpired,
   decodeDeviceFrame,
@@ -20326,6 +21974,8 @@ export {
   DEFAULT_MAX_NODES,
   clampDepth,
   buildTree,
+  storeUri,
+  StoreService,
   toToolResult,
   OperationRegistry,
   normalizeCanonicalOrigin,