@aigne/afs-did-space 1.12.0-beta.5

package/dist/index.cjs

@@ -0,0 +1,2712 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_blocklet_hook = require('./blocklet-hook.cjs');
+const require_changelog_schema = require('./changelog-schema.cjs');
+const require_cid = require('./cid.cjs');
+const require_did_utils = require('./did-utils.cjs');
+const require_download_actions = require('./download-actions.cjs');
+require('./mime-utils.cjs');
+const require_inline_content = require('./inline-content.cjs');
+const require_share_declaration = require('./share-declaration.cjs');
+const require_share_hook = require('./share-hook.cjs');
+const require_share_virtual_path = require('./share-virtual-path.cjs');
+const require_timestamp = require('./timestamp.cjs');
+const require_tree_index = require('./tree-index.cjs');
+const require_tree_query = require('./tree-query.cjs');
+const require_d1_schema = require('./d1-schema.cjs');
+const require_upload_session_store = require('./upload-session-store.cjs');
+const require_upload_actions = require('./upload-actions.cjs');
+const require_url_normalize = require('./url-normalize.cjs');
+const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
+const require_afs_metadata_context = require('./afs-metadata-context.cjs');
+const require_changelog_write = require('./changelog-write.cjs');
+const require_cid_byte_cache = require('./cid-byte-cache.cjs');
+const require_remote_afs = require('./remote-afs.cjs');
+const require_http = require('./transports/http.cjs');
+const require_static = require('./transports/static.cjs');
+const require_ws = require('./transports/ws.cjs');
+const require_client = require('./client.cjs');
+const require_d1_gc_queue = require('./d1-gc-queue.cjs');
+const require_prefix_range = require('./prefix-range.cjs');
+const require_d1_resolve_store = require('./d1-resolve-store.cjs');
+const require_object_key = require('./object-key.cjs');
+const require_share_resolve = require('./share-resolve.cjs');
+const require_share_store = require('./share-store.cjs');
+const require_d1_share_store = require('./d1-share-store.cjs');
+const require_dirty_path_schema = require('./dirty-path-schema.cjs');
+const require_d1_tree_index = require('./d1-tree-index.cjs');
+const require_data_backend = require('./data-backend.cjs');
+const require_dirty_path_queue = require('./dirty-path-queue.cjs');
+const require_local_changelog = require('./local-changelog.cjs');
+const require_memory_gc_queue = require('./memory-gc-queue.cjs');
+const require_memory_tree_index = require('./memory-tree-index.cjs');
+const require_prefixed_tree_index = require('./prefixed-tree-index.cjs');
+const require_presign_signer = require('./presign-signer.cjs');
+const require_reference_check = require('./reference-check.cjs');
+const require_resolve = require('./resolve.cjs');
+const require_rsync = require('./rsync.cjs');
+const require_run_gc = require('./run-gc.cjs');
+const require_scope_id = require('./scope-id.cjs');
+const require_scope_migration = require('./scope-migration.cjs');
+const require_share_serve = require('./share-serve.cjs');
+const require_sqlite_gc_queue = require('./sqlite-gc-queue.cjs');
+const require_sqlite_resolve_store = require('./sqlite-resolve-store.cjs');
+const require_sqlite_share_store = require('./sqlite-share-store.cjs');
+const require_sync_engine = require('./sync-engine.cjs');
+const require_sync_state = require('./sync-state.cjs');
+const require_versioned_content_backends = require('./versioned-content-backends.cjs');
+const require_versioned_content_index = require('./versioned-content-index.cjs');
+const require_versioned_content_store = require('./versioned-content-store.cjs');
+const require_versioned_scope = require('./versioned-scope.cjs');
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let _aigne_afs_timing = require("@aigne/afs-timing");
+let ufo = require("ufo");
+let zod = require("zod");
+let _aigne_afs_provider_utils = require("@aigne/afs-provider-utils");
+
+//#region src/index.ts
+const log = (0, _aigne_afs.makeNsLog)("provider:did-space");
+const LIST_MAX_LIMIT = 1e3;
+/**
+* AFS entry `id` is the basename (last path segment), matching AFSFS/AFSJSON —
+* NOT the full path. `AFSBaseProvider.buildEntry` defaults `id` to the full
+* normalized path, so the list handlers below MUST pass an explicit basename id;
+* otherwise consumers that labelize `entry.id` (e.g. the auto-surface settings
+* tabs) render the whole path instead of "Input"/"Sort"/"View". The stat handler
+* already does this (`afsPath.split("/").pop()`); the list handlers were the gap.
+*/
+function basenameId(path) {
+	return path.split("/").filter(Boolean).pop() ?? "/";
+}
+/**
+* Provider-reserved meta keys (planning/agent-hub/metadata-foundation.md §
+* 白名单). These are computed by DID Space at write time and overwrite
+* anything the application tries to put under the same name. The application
+* may write any OTHER key into `payload.meta` and it'll be persisted to the
+* `entries.metadata` column.
+*
+* Note: `ctime / mtime` are NOT in `entry.meta` (they live at AFSEntry top
+* level as `createdAt / updatedAt`), so they're not in the reserved set —
+* the application can write `meta.ctime` and it'll be persisted as just
+* another application field, NOT conflated with the entry's timestamp.
+*/
+const PROVIDER_RESERVED_META_KEYS = new Set([
+	"kind",
+	"size",
+	"cid",
+	"mimeType"
+]);
+/**
+* Strip provider-reserved keys from a write payload's meta, leaving only the
+* application-owned fields that should go to `entries.metadata`.
+* Returns undefined when nothing application-owned remains (avoids storing
+* `{}` blobs).
+*/
+function extractApplicationMeta(meta) {
+	if (!meta) return void 0;
+	const out = {};
+	let any = false;
+	for (const [k, v] of Object.entries(meta)) {
+		if (PROVIDER_RESERVED_META_KEYS.has(k)) continue;
+		out[k] = v;
+		any = true;
+	}
+	return any ? out : void 0;
+}
+/**
+* Loose upper bound on serialized application metadata (did-space-metadata
+* NEEDS DECISION 3). `metadata` rides `z.record(z.unknown())` and is NOT
+* digest-checked (it's application data, not bytes — design §5), so the wire
+* imposes no size limit of its own. Aside's real metadata is tiny (a few ISO
+* timestamps, ~50B), but a malicious / buggy client could otherwise stuff a
+* huge JSON blob straight into the D1 `metadata` column (row-size / write-
+* amplification risk, cf. the D1 burn-through lesson). 64KB is far above any
+* legitimate use yet blocks abuse. Shared by the two new server ingress points
+* (batchWrite + upload-plane commit) so the threshold can't drift.
+*/
+const METADATA_MAX_BYTES = 64 * 1024;
+/**
+* Reject abusively large application metadata gracefully (an `AFSValidationError`,
+* which afs-rpc maps to 400 — never an uncaught 500). Call AFTER
+* `extractApplicationMeta` so the reserved-key strip can't be gamed to dodge
+* the bound. No-op for absent metadata.
+*/
+function assertMetadataSize(meta, path) {
+	if (!meta) return;
+	const bytes = new TextEncoder().encode(JSON.stringify(meta)).length;
+	if (bytes > METADATA_MAX_BYTES) throw new _aigne_afs.AFSValidationError(`Application metadata for ${path} is ${bytes} bytes, over the ${METADATA_MAX_BYTES}-byte limit`);
+}
+/** Plain JSON object (not array, not null) — the deep-merge branch. */
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** An incoming scalar that carries no information and must never overwrite. */
+function isEmptyScalar(v) {
+	return v === void 0 || v === null || v === "";
+}
+/** Union two arrays, dedup by structural identity, existing entries first. */
+function unionArrays(existing, incoming) {
+	const seen = new Set(existing.map((x) => JSON.stringify(x)));
+	const out = [...existing];
+	for (const item of incoming) {
+		const key = JSON.stringify(item);
+		if (!seen.has(key)) {
+			out.push(item);
+			seen.add(key);
+		}
+	}
+	return out;
+}
+/**
+* Merge incoming item content into the existing item on a duplicate-key write
+* (#492). A re-save is ADDITIVE and must never DEGRADE the stored item:
+*
+* - keys in `immutable` (always `createdAt`, plus caller-supplied lifecycle
+*   fields like `status`) keep the existing value — a re-clip never resets an
+*   archived item or rewrites its creation time;
+* - arrays union-dedup (existing first) so tags / collections accrete;
+* - plain objects deep-merge recursively, so a partial re-clip of `og` /
+*   `content` keeps fields the new capture omitted;
+* - scalars take the incoming value EXCEPT empty ones (`undefined` / `null` /
+*   `""`), which keep the existing value — a bookmarklet that failed to grab a
+*   title must not wipe the good title already saved;
+* - type conflicts (array↔scalar, object↔scalar) take the incoming value.
+*/
+function mergeItemContent(existing, incoming, immutable = new Set(["createdAt"])) {
+	const merged = { ...existing };
+	for (const [k, v] of Object.entries(incoming)) {
+		if (immutable.has(k)) continue;
+		const cur = merged[k];
+		if (Array.isArray(v) && Array.isArray(cur)) merged[k] = unionArrays(cur, v);
+		else if (isPlainObject(v) && isPlainObject(cur)) merged[k] = mergeItemContent(cur, v, immutable);
+		else if (isEmptyScalar(v)) {} else merged[k] = v;
+	}
+	return merged;
+}
+var DIDSpaceProvider = class extends _aigne_afs_provider.AFSBaseProvider {
+	static manifest() {
+		return {
+			name: "did-space",
+			description: "DID-scoped persistent storage with CID-based content deduplication.\n- Per-user data isolation via DID prefix\n- Content-addressable deduplication (CID v1, raw codec + SHA-256)\n- R2 for objects, D1 for tree index",
+			uriTemplate: "did-space://{did}/{path*}",
+			category: "storage",
+			schema: zod.z.object({
+				did: zod.z.string(),
+				path: zod.z.string().optional()
+			}),
+			tags: [
+				"did",
+				"storage",
+				"cid",
+				"dedup",
+				"cloud"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token"
+			],
+			security: {
+				riskLevel: "sandboxed",
+				resourceAccess: []
+			},
+			capabilities: { filesystem: {
+				read: true,
+				write: true
+			} },
+			noPerEntryActions: true
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"write",
+				"delete",
+				"search",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": { kind: "did-space:root" },
+				"/{path+}": { kind: "did-space:file" }
+			},
+			auth: { type: "custom" },
+			bestFor: [
+				"user files",
+				"persistent storage",
+				"content-addressed data"
+			],
+			notFor: ["large binary blobs", "real-time streaming"]
+		};
+	}
+	name;
+	description;
+	accessMode;
+	did;
+	objectStore;
+	treeIndex;
+	gcQueue;
+	/** See `DIDSpaceProviderOptions.deviceId`. Read by writeHandler/deleteHandler. */
+	deviceId;
+	/** Optional ShareResolver for .share reconcile hook (Phase 0.4) */
+	shareResolver;
+	/** See `DIDSpaceProviderOptions.shareOwnerDid` / `shareTreePrefix`. */
+	shareOwnerDid;
+	shareTreePrefix;
+	/** See `DIDSpaceProviderOptions.blockletResolver` / `blockletOwnerDid` (#674). */
+	blockletResolver;
+	blockletOwnerDid;
+	/** Upload plane deps (design §7). See `DIDSpaceProviderOptions`. */
+	signer;
+	uploadSessionStore;
+	uploadScope;
+	constructor(options) {
+		super();
+		require_did_utils.validateId(options.did);
+		this.name = options.name || "did-space";
+		this.description = options.description;
+		this.accessMode = options.accessMode ?? "readwrite";
+		this.did = require_did_utils.normalizeId(options.did);
+		this.objectStore = options.objectStore;
+		this.treeIndex = options.treeIndex;
+		this.gcQueue = options.gcQueue;
+		this.deviceId = options.deviceId ?? "server:default";
+		this.shareResolver = options.shareResolver;
+		this.shareOwnerDid = options.shareOwnerDid;
+		this.shareTreePrefix = options.shareTreePrefix;
+		this.blockletResolver = options.blockletResolver;
+		this.blockletOwnerDid = options.blockletOwnerDid;
+		this.signer = options.signer;
+		this.uploadSessionStore = options.uploadSessionStore;
+		this.uploadScope = options.uploadScope;
+	}
+	/** Convert AFS path to tree-index path (strip leading /) */
+	treePath(afsPath) {
+		if (afsPath.includes("\0")) throw new Error("Null byte in path");
+		if (/(?:^|\/)\.\.(?:\/|$)/.test(afsPath)) throw new Error("Path traversal in path");
+		return afsPath.replace(/^\/+/, "");
+	}
+	/** Convert AFS path to tree-index prefix for directory listing */
+	treeListPrefix(afsPath) {
+		if (afsPath === "/") return "";
+		return `${this.treePath(afsPath)}/`;
+	}
+	/**
+	* Remap a write/delete into the arguments the .share reconcile hook expects.
+	* On a whole-space provider this is identity. On a prefixed instance-fragment
+	* provider (`shareTreePrefix` set) it restores the WHOLE-TREE decl path and
+	* keys the share to the space owner (`shareOwnerDid`), so reconcile stores the
+	* same `owner_did` + full `decl_path` the public serving path resolves by.
+	*/
+	shareHookArgs(afsPath, treePath) {
+		const fullTreePath = this.shareTreePrefix ? (0, ufo.joinURL)(this.shareTreePrefix, treePath) : treePath;
+		return {
+			afsPath: this.shareTreePrefix ? `/${fullTreePath}` : afsPath,
+			treePath: fullTreePath,
+			ownerDid: this.shareOwnerDid ?? this.did
+		};
+	}
+	/**
+	* Remap a write/delete into the arguments the blocklet hook expects. Same
+	* whole-tree path restoration as {@link shareHookArgs}, but the recorded
+	* `ownerDid` is the PLAINTEXT space owner (`blockletOwnerDid`), not the de-id
+	* scope — the serve path re-derives the storage scope from the plaintext DID.
+	*/
+	blockletHookArgs(afsPath, treePath) {
+		const fullTreePath = this.shareTreePrefix ? (0, ufo.joinURL)(this.shareTreePrefix, treePath) : treePath;
+		return {
+			afsPath: this.shareTreePrefix ? `/${fullTreePath}` : afsPath,
+			treePath: fullTreePath,
+			ownerDid: this.blockletOwnerDid ?? this.did
+		};
+	}
+	objectKey(cid) {
+		if (!/^[bz][a-zA-Z0-9]{20,100}$/.test(cid)) throw new Error(`Invalid CID format: ${cid.slice(0, 30)}`);
+		return `objects/${cid}`;
+	}
+	async isDirectory(path) {
+		if (path === "/") return true;
+		return this.treeIndex.hasChildren(this.treeListPrefix(path));
+	}
+	/** Collect all CIDs under a prefix for GC queuing before bulk delete. */
+	async collectCIDsByPrefix(prefix) {
+		const cids = [];
+		let cursor;
+		do {
+			const result = await this.treeIndex.listEntries(prefix, {
+				limit: 1e3,
+				cursor
+			});
+			for (const e of result.entries) if (e.cid) cids.push(e.cid);
+			cursor = result.hasMore ? result.cursor : void 0;
+		} while (cursor);
+		return cids;
+	}
+	async readMeta(ctx) {
+		const afsPath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		if (afsPath === "/") {
+			const childrenCount = await this.treeIndex.countChildren(this.treeListPrefix("/"));
+			return this.buildEntry((0, ufo.joinURL)(afsPath, ".meta"), {
+				content: {
+					type: "directory",
+					path: "/"
+				},
+				meta: {
+					kind: "did-space:root",
+					childrenCount
+				}
+			});
+		}
+		const entry = await this.treeIndex.get(this.treePath(afsPath), { includeContent: false });
+		if (entry) return this.buildEntry((0, ufo.joinURL)(afsPath, ".meta"), {
+			content: {
+				type: "file",
+				path: afsPath,
+				size: entry.size,
+				cid: entry.cid
+			},
+			meta: {
+				kind: "did-space:file",
+				size: entry.size,
+				cid: entry.cid,
+				mimeType: entry.mimeType
+			},
+			createdAt: new Date(entry.ctime),
+			updatedAt: new Date(entry.mtime)
+		});
+		if (await this.isDirectory(afsPath)) {
+			const childrenCount = await this.treeIndex.countChildren(this.treeListPrefix(afsPath));
+			return this.buildEntry((0, ufo.joinURL)(afsPath, ".meta"), {
+				content: {
+					type: "directory",
+					path: afsPath
+				},
+				meta: {
+					kind: "did-space:directory",
+					childrenCount
+				}
+			});
+		}
+		throw new _aigne_afs.AFSNotFoundError(afsPath);
+	}
+	/**
+	* Override to implement the `maxDepth: -1` snapshot contract.
+	*
+	* When called with `maxDepth: -1`, collects ALL file entries under `path`
+	* using cursor-based pagination through the treeIndex and returns them in
+	* a single `AFSListResult` with `meta.cursor = String(manifestSeq)` so
+	* `SyncEngine.fullResync()` can advance `cloudSeq` correctly.
+	*
+	* > 10_000 entries → sets `meta.truncated: true` (HTTP 200, SyncEngine
+	* throws `ManifestTooLargeError`).
+	*
+	* All other options fall through to `super.list()` → `listHandler`.
+	*/
+	async list(path, options) {
+		if (options?.maxDepth !== -1) return super.list(path, options);
+		const normPath = path.startsWith("/") ? path.slice(1) : path;
+		if (normPath === ".changelog" || normPath.startsWith(".changelog/")) throw new _aigne_afs.AFSValidationError(".changelog path does not support maxDepth=-1 (changelog uses cursor-based incremental access)");
+		if (options.cursor !== void 0 || options.limit !== void 0 && Number.isFinite(options.limit) || options.offset !== void 0 && Number.isFinite(options.offset)) throw new _aigne_afs.AFSValidationError("list with maxDepth=-1 cannot be combined with cursor, limit, or offset");
+		const SNAPSHOT_MAX_ENTRIES = 1e4;
+		const prefix = this.treeListPrefix(path);
+		const allEntries = [];
+		let cursor;
+		do {
+			const result = await this.treeIndex.listEntries(prefix, {
+				limit: LIST_MAX_LIMIT,
+				cursor
+			});
+			for (const treeEntry of result.entries) {
+				if (allEntries.length >= SNAPSHOT_MAX_ENTRIES) return {
+					data: allEntries,
+					meta: {
+						truncated: true,
+						...(0, _aigne_afs.orderByRequested)(options.orderBy) ? { orderByIgnored: true } : {}
+					}
+				};
+				allEntries.push(this.buildEntry(`/${treeEntry.path}`, {
+					id: basenameId(treeEntry.path),
+					meta: require_changelog_schema.serializeManifestEntry({
+						cid: treeEntry.cid,
+						size: treeEntry.size,
+						mtime: treeEntry.mtime,
+						mimeType: treeEntry.mimeType
+					}),
+					createdAt: new Date(treeEntry.ctime),
+					updatedAt: new Date(treeEntry.mtime)
+				}));
+			}
+			cursor = result.hasMore ? result.cursor : void 0;
+		} while (cursor);
+		const manifestSeq = await this.treeIndex.getMaxSeq();
+		const snapshotMeta = { cursor: String(manifestSeq) };
+		if ((0, _aigne_afs.orderByRequested)(options.orderBy)) snapshotMeta.orderByIgnored = true;
+		return {
+			data: allEntries,
+			meta: snapshotMeta
+		};
+	}
+	async listHandler(ctx) {
+		const afsPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const options = ctx.options;
+		const includeContent = options?.includeContent === true;
+		const includeChildrenCounts = options?.includeChildrenCounts === true;
+		const orderRequested = (0, _aigne_afs.orderByRequested)(options?.orderBy);
+		const orderBy = orderRequested && (0, _aigne_afs.isValidOrderBy)(options?.orderBy) ? options.orderBy : void 0;
+		/** Merge the no-silent-drop flag into a result when ordering was requested but not applied. */
+		const flagIgnored = (result) => orderRequested ? {
+			...result,
+			meta: {
+				...result.meta,
+				orderByIgnored: true
+			}
+		} : result;
+		const sharesMatch = require_share_virtual_path.matchSharesVirtualPath(afsPath);
+		if (sharesMatch && this.shareResolver && !this.shareTreePrefix) {
+			const { list } = await new require_share_virtual_path.ShareVirtualHandler(this.shareResolver, this.did).list(sharesMatch);
+			return flagIgnored({ data: list });
+		}
+		const normPath = afsPath.startsWith("/") ? afsPath.slice(1) : afsPath;
+		const isChangelog = normPath === ".changelog" || normPath.startsWith(".changelog/");
+		if (isChangelog && options?.cursor !== void 0) return flagIgnored(await this.listChangelog(options.cursor, options.limit));
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const offset = Math.max(0, Number(options?.offset) || 0);
+		const maxDepth = options?.maxDepth ?? 1;
+		const collectLimit = offset + limit;
+		if (maxDepth === 0) return { data: [] };
+		const prefix = this.treeListPrefix(afsPath);
+		if (afsPath !== "/") {
+			if (!await this.treeIndex.get(this.treePath(afsPath), { includeContent: false })) {
+				if (!await this.treeIndex.hasChildren(prefix)) throw new _aigne_afs.AFSNotFoundError(afsPath);
+			}
+		}
+		const entries = [];
+		if (maxDepth === 1) {
+			if (orderBy) {
+				const scan$1 = await this.listShallowOrdered(prefix, collectLimit, entries, orderBy, includeContent);
+				if (includeChildrenCounts) await this.fillChildrenCounts(entries);
+				return this.withLiveSeq({
+					data: entries,
+					total: await this.shallowTotal(prefix, scan$1)
+				}, prefix, isChangelog);
+			}
+			const scan = await this.listShallow(prefix, collectLimit, entries, void 0, includeContent);
+			if (includeChildrenCounts) await this.fillChildrenCounts(entries);
+			return this.withLiveSeq(flagIgnored({
+				data: entries,
+				total: await this.shallowTotal(prefix, scan)
+			}), prefix, isChangelog);
+		}
+		await this.listDeep(afsPath, prefix, collectLimit, maxDepth, entries, includeContent);
+		return flagIgnored({ data: entries });
+	}
+	/**
+	* True direct-children total for a shallow listing.
+	*
+	* AFSListResult contract (`packages/core/src/type.ts`): absent `total`
+	* means "data IS the complete result" — so a handler that truncates its
+	* collection MUST report `total`, or every consumer downstream (base.ts
+	* pagination, afs-list pager) mistakes the page for the whole set.
+	*
+	* Cost model (D1: per-query round-trips dominate): `listShallow` scans
+	* the index in LIST_MAX_LIMIT batches and keeps counting rows past the
+	* build cap, so when the cursor drained (directories ≤ LIST_MAX_LIMIT
+	* children — the common case) the scan itself yields the exact total:
+	* ZERO extra queries. Only a directory truncated mid-cursor (> 1000
+	* children) pays ONE COUNT round-trip (same `countChildren(prefix)`
+	* call and parent-key format `readMeta` already relies on).
+	*/
+	async shallowTotal(prefix, scan) {
+		if (scan.exhausted) return scan.seen;
+		return this.treeIndex.countChildren(prefix);
+	}
+	/**
+	* Attach the per-prefix watermark `version` as the result's top-level
+	* `liveSeq` (Live Update Resilience §4 / 0a'). Read ONE row via the
+	* TreeIndex — O(1), independent of changelog history/global write volume.
+	*
+	* - Skipped for `.changelog` listings (sync-internal, no live-update scope).
+	* - Skipped when the index has no `getPrefixWatermark` (rollout) or reports
+	*   no watermark key for the path (`null` — no collection root): the
+	*   consumer then falls back to full re-list on the next edge/poll, still
+	*   correct.
+	* - A valid-but-never-written collection root reports `"0"` so consumers
+	*   baseline at 0 instead of conservatively refetching every poll tick on a
+	*   read-only collection (the first write bumps to 1 > 0 and is detected).
+	* - The value is prefix-LOCAL (only this collection root's write count), so
+	*   it never leaks another blocklet's timing (invariant I3).
+	*/
+	async withLiveSeq(result, prefix, isChangelog) {
+		if (isChangelog || !this.treeIndex.getPrefixWatermark) return result;
+		const version = await this.treeIndex.getPrefixWatermark(prefix);
+		if (version != null) result.liveSeq = String(version);
+		return result;
+	}
+	/**
+	* Shallow listing with a VALID orderBy (did-space-sorting Phase 3).
+	*
+	* - Single tuple → forwarded to the TreeIndex (`listChildren` orders
+	*   natively over the (scope,parent,col,name) indexes; keyset cursor
+	*   pages stay globally ordered, so collecting offset+limit entries is
+	*   the correct order-before-pagination slice).
+	* - 2-3 tuples → the index can order by one column only, so collect the
+	*   FULL child set and apply the canonical core sort before truncation
+	*   (order → offset → limit still holds).
+	*/
+	async listShallowOrdered(prefix, collectLimit, entries, orderBy, includeContent = false) {
+		if (orderBy.length === 1) {
+			const [field, order] = orderBy[0];
+			return this.listShallow(prefix, collectLimit, entries, {
+				orderBy: field,
+				order
+			}, includeContent);
+		}
+		const all = [];
+		await this.listShallow(prefix, Number.MAX_SAFE_INTEGER, all, void 0, includeContent);
+		const { entries: sorted } = (0, _aigne_afs.orderEntries)(all, orderBy);
+		entries.push(...sorted.slice(0, collectLimit));
+		return {
+			exhausted: true,
+			seen: all.length
+		};
+	}
+	async listShallow(prefix, limit, entries, order, includeContent = false) {
+		let cursor;
+		let seen = 0;
+		do {
+			const result = await this.treeIndex.listChildren(prefix, {
+				limit: LIST_MAX_LIMIT,
+				cursor,
+				includeContent,
+				...order ?? {}
+			});
+			seen += result.entries.length;
+			for (const child of result.entries) {
+				if (entries.length >= limit) continue;
+				if (child.path.endsWith("/")) {
+					const displayPath = `/${child.path.slice(0, -1)}`;
+					entries.push(this.buildEntry(displayPath, {
+						id: basenameId(displayPath),
+						meta: {
+							kind: "did-space:directory",
+							childrenCount: -1,
+							size: child.size
+						},
+						createdAt: new Date(child.ctime),
+						updatedAt: new Date(child.mtime)
+					}));
+				} else entries.push(this.buildEntry(`/${child.path}`, {
+					id: basenameId(child.path),
+					...includeContent && await this.verifiedInline(child) !== null ? { content: child.content } : {},
+					meta: {
+						kind: "did-space:file",
+						cid: child.cid,
+						size: child.size,
+						mimeType: child.mimeType
+					},
+					createdAt: new Date(child.ctime),
+					updatedAt: new Date(child.mtime)
+				}));
+			}
+			cursor = result.hasMore ? result.cursor : void 0;
+		} while (cursor && entries.length < limit);
+		return {
+			exhausted: cursor === void 0,
+			seen
+		};
+	}
+	/**
+	* Patch EXACT `meta.childrenCount` onto the directory entries of a
+	* collected shallow page — the opt-in half of the two-tier childrenCount
+	* contract (`AFSListOptions.includeChildrenCounts`; default tier is the
+	* `-1` sentinel stamped by listShallow). Page-bounded by construction:
+	* only the dirs actually collected are counted, ONE `countChildrenMany`
+	* round-trip (per-dir `countChildren` fallback for indexes without it),
+	* so the cost is Σ direct children of the page's dirs — never the
+	* whole-subtree scan the retired `countChildrenGrouped` performed.
+	*/
+	async fillChildrenCounts(entries) {
+		const dirs = entries.filter((e) => e.meta?.kind === "did-space:directory");
+		if (dirs.length === 0) return;
+		const keyOf = (e) => `${this.treePath(e.path)}/`;
+		if (this.treeIndex.countChildrenMany) {
+			const counts = await this.treeIndex.countChildrenMany(dirs.map(keyOf));
+			for (const e of dirs) e.meta.childrenCount = counts.get(keyOf(e)) ?? 0;
+			return;
+		}
+		for (const e of dirs) e.meta.childrenCount = await this.treeIndex.countChildren(keyOf(e));
+	}
+	async listDeep(afsBasePath, prefix, limit, maxDepth, entries, includeContent = false) {
+		const prefixDepth = afsBasePath === "/" ? 0 : afsBasePath.split("/").filter(Boolean).length;
+		const seenDirs = /* @__PURE__ */ new Set();
+		let cursor;
+		do {
+			const result = await this.treeIndex.listEntries(prefix, {
+				limit: LIST_MAX_LIMIT,
+				cursor,
+				includeContent
+			});
+			for (const treeEntry of result.entries) {
+				if (entries.length >= limit) return;
+				const parts = treeEntry.path.slice(prefix.length).split("/").filter(Boolean);
+				for (let i = 0; i < parts.length - 1; i++) {
+					if (i + 1 > maxDepth) break;
+					const dirKey = prefix + parts.slice(0, i + 1).join("/");
+					if (!seenDirs.has(dirKey)) {
+						seenDirs.add(dirKey);
+						entries.push(this.buildEntry(`/${dirKey}`, {
+							id: basenameId(dirKey),
+							meta: {
+								kind: "did-space:directory",
+								childrenCount: -1
+							}
+						}));
+					}
+				}
+				const path = `/${treeEntry.path}`;
+				if (path.split("/").filter(Boolean).length - prefixDepth <= maxDepth) entries.push(this.buildEntry(path, {
+					id: basenameId(path),
+					...includeContent && await this.verifiedInline(treeEntry) !== null ? { content: treeEntry.content } : {},
+					meta: {
+						kind: "did-space:file",
+						cid: treeEntry.cid,
+						size: treeEntry.size,
+						mimeType: treeEntry.mimeType
+					},
+					createdAt: new Date(treeEntry.ctime),
+					updatedAt: new Date(treeEntry.mtime)
+				}));
+			}
+			cursor = result.hasMore ? result.cursor : void 0;
+		} while (cursor && entries.length < limit);
+	}
+	/**
+	* Task 1.9: list changelog rows starting after `cursor` (seq number).
+	* Returns rows as AFSEntry objects + meta.cursor pointing to the last row's seq.
+	*/
+	async listChangelog(cursor, limit) {
+		const sinceSeq = Number(cursor) || 0;
+		const effectiveLimit = Math.min(limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const watermark = await this.treeIndex.getCompactedBelowSeq?.() ?? 0;
+		if (watermark > 0 && sinceSeq < watermark) throw new _aigne_afs.AFSCompactedError("/.changelog", String(watermark));
+		const changelog = await this.treeIndex.getChangelogSince(sinceSeq, effectiveLimit);
+		return {
+			data: changelog.entries.map((row) => this.buildEntry(`/.changelog/${row.seq}`, {
+				content: null,
+				meta: {
+					kind: require_changelog_schema.CHANGELOG_ROW_KIND,
+					extra: require_changelog_schema.serializeChangelogEntry(row)
+				}
+			})),
+			meta: {
+				cursor: String(changelog.cursor),
+				hasMore: changelog.hasMore
+			}
+		};
+	}
+	/**
+	* Promote write + delete to the object form so callers can discover the
+	* `ifMatch` sub-capability (CLAUDE.md "Sub-capability schema"). The base impl
+	* (base.ts) returns plain booleans; without this override the if-match
+	* conformance suite's `getCapabilityFeature("write","ifMatch")` reads nothing
+	* and the suite skips. Mirrors AFSFS's override (fs/src/index.ts).
+	*/
+	getOperationsDeclaration() {
+		const ops = super.getOperationsDeclaration();
+		if (typeof ops.write === "boolean" ? ops.write : ops.write?.supported === true) ops.write = {
+			supported: true,
+			features: {
+				ifMatch: true,
+				treeMerge: true,
+				treeToggle: true,
+				treeIncrement: true,
+				treeListAdd: true,
+				treeListRemove: true,
+				batchPushdown: true
+			}
+		};
+		if (typeof ops.delete === "boolean" ? ops.delete : ops.delete?.supported === true) ops.delete = {
+			supported: true,
+			features: { ifMatch: true }
+		};
+		if (typeof ops.list === "boolean" ? ops.list : ops.list?.supported === true) ops.list = {
+			supported: true,
+			features: {
+				orderBy: true,
+				includeContent: true
+			}
+		};
+		return ops;
+	}
+	async readCapabilities(_ctx) {
+		const operations = this.getOperationsDeclaration();
+		const queryable = typeof this.treeIndex.query === "function";
+		if (queryable) operations.query = true;
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: this.name,
+				description: this.description || "DID-scoped persistent storage with CID-based deduplication",
+				tools: [],
+				actions: [],
+				operations,
+				...queryable ? { standardActions: [(0, _aigne_afs.collectionQueryStandardAction)({
+					doc: true,
+					groupBy: true,
+					annotate: true,
+					aggregate: true
+				})] } : {}
+			},
+			meta: {
+				kind: "afs:capabilities",
+				operations
+			}
+		};
+	}
+	/**
+	* Typed collection query over a directory of records (design §3.5).
+	*
+	* - dir-per-record (`spec.doc`): direct child dirs joined with their
+	*   `<dir>/<doc>` document; file-per-record (no doc): direct child files'
+	*   inline content is the record.
+	* - where/orderBy/pagination/total/groupBy execute inside the TreeIndex
+	*   engine (SQL or in-memory — lockstep-tested). select + annotate.memberOf
+	*   are page-level post-processing here, identical across backends.
+	* - Strict contract: spec arrives core-validated; provider constraints
+	*   (single orderBy key, no text) throw AFSValidationError. An index
+	*   without the engine (e.g. not-yet-migrated backends) throws
+	*   AFSUnsupportedError — and is never declared in capabilities.
+	*/
+	async query(path, spec, _options) {
+		if (!this.treeIndex.query) throw new _aigne_afs.AFSUnsupportedError("query", "Collection query is not supported by this index backend");
+		const afsPath = (0, ufo.joinURL)("/", path);
+		if (this.isVirtualPath(afsPath) || require_share_virtual_path.matchSharesVirtualPath(afsPath)) throw new _aigne_afs.AFSValidationError(`Invalid query spec: path: not a queryable collection: ${afsPath}`);
+		require_tree_query.assertTreeQuerySpec(spec);
+		const prefix = this.treeListPrefix(afsPath);
+		if (afsPath !== "/") {
+			if (!await this.treeIndex.get(this.treePath(afsPath), { includeContent: false }) && !await this.treeIndex.hasChildren(prefix)) throw new _aigne_afs.AFSNotFoundError(afsPath);
+		}
+		const result = await this.treeIndex.query(prefix, spec);
+		let memberValues;
+		if (spec.annotate) {
+			memberValues = /* @__PURE__ */ new Set();
+			try {
+				const ref = await this.read((0, ufo.joinURL)("/", spec.annotate.memberOf.doc));
+				const raw = (0, _aigne_afs.resolveFieldPath)(require_tree_query.parseRecordText(typeof ref.data?.content === "string" ? ref.data.content : void 0), spec.annotate.memberOf.field);
+				if (Array.isArray(raw)) for (const v of raw) memberValues.add(typeof v === "string" ? v.toLowerCase() : String(v));
+			} catch {}
+		}
+		const entries = [];
+		for (const row of result.rows) entries.push(await this.queryRowToEntry(row, spec, memberValues));
+		const out = {
+			entries,
+			total: result.total
+		};
+		if (result.cursor) out.cursor = result.cursor;
+		if (result.groups) out.groups = result.groups;
+		if (result.aggregateGroups) out.aggregateGroups = result.aggregateGroups;
+		if (result.seekOffset !== void 0) out.seekOffset = result.seekOffset;
+		if (this.treeIndex.getPrefixWatermark) {
+			const version = await this.treeIndex.getPrefixWatermark(prefix);
+			if (version != null) out.liveSeq = String(version);
+		}
+		return out;
+	}
+	/** Map an engine row to an AFSEntry (mirrors the list handlers' shapes). */
+	async queryRowToEntry(row, spec, memberValues) {
+		const isDir = row.kind === "dir";
+		const displayPath = isDir ? `/${row.path.slice(0, -1)}` : `/${row.path}`;
+		const verifyCid = isDir ? row.contentCid : row.cid;
+		const verified = row.content !== void 0 && verifyCid ? await this.verifiedInline({
+			cid: verifyCid,
+			content: row.content
+		}) : null;
+		let content;
+		if (spec.select) content = require_tree_query.projectRecordFields(require_tree_query.parseRecordText(verified ?? void 0), spec.select);
+		else if (verified !== null) content = verified;
+		const entry = this.buildEntry(displayPath, {
+			id: basenameId(displayPath),
+			...content !== void 0 ? { content } : {},
+			meta: isDir ? {
+				...row.metadata ?? {},
+				kind: "did-space:directory",
+				childrenCount: -1,
+				size: row.size
+			} : {
+				...row.metadata ?? {},
+				kind: "did-space:file",
+				cid: row.cid,
+				size: row.size,
+				mimeType: row.mimeType
+			},
+			createdAt: new Date(row.ctime),
+			updatedAt: new Date(row.mtime)
+		});
+		if (spec.annotate && memberValues) {
+			const { by, as } = spec.annotate.memberOf;
+			const byValue = by === "$id" ? row.name : (0, _aigne_afs.resolveFieldPath)(require_tree_query.parseRecordText(verified ?? row.content), by);
+			const member = byValue != null && memberValues.has(typeof byValue === "string" ? byValue.toLowerCase() : String(byValue));
+			entry._derived = { [as]: member ? "1" : "" };
+		}
+		return entry;
+	}
+	async readHandler(ctx) {
+		const afsPath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		const sharesMatch = require_share_virtual_path.matchSharesVirtualPath(afsPath);
+		if (sharesMatch && this.shareResolver && !this.shareTreePrefix) {
+			const result = await new require_share_virtual_path.ShareVirtualHandler(this.shareResolver, this.did).read(sharesMatch);
+			if (!result) throw new _aigne_afs.AFSNotFoundError(afsPath);
+			return result.data;
+		}
+		const normPath = afsPath.startsWith("/") ? afsPath.slice(1) : afsPath;
+		if (normPath.startsWith(".objects/")) {
+			const cid = normPath.slice(9);
+			if (!await (0, _aigne_afs_timing.time)("ds.ref", () => this.treeIndex.isReferenced(cid))) throw new _aigne_afs.AFSNotFoundError(afsPath);
+			const obj = await (0, _aigne_afs_timing.time)("ds.obj", () => this.objectStore.get(this.objectKey(cid)));
+			if (!obj) throw new _aigne_afs.AFSNotFoundError(afsPath);
+			const bytes = new Uint8Array(await (0, _aigne_afs_timing.time)("ds.body", () => obj.arrayBuffer()));
+			return this.buildEntry(afsPath, {
+				content: bytes,
+				meta: {
+					kind: "did-space:object",
+					cid,
+					size: bytes.length
+				}
+			});
+		}
+		if (afsPath === "/") {
+			const childrenCount = await this.treeIndex.countChildren(this.treeListPrefix("/"));
+			return this.buildEntry(afsPath, {
+				content: `DID Space root for ${this.did} (${childrenCount} entries)`,
+				meta: {
+					kind: "did-space:root",
+					childrenCount
+				}
+			});
+		}
+		const entry = await (0, _aigne_afs_timing.time)("ds.idx", () => this.treeIndex.get(this.treePath(afsPath)));
+		if (entry) {
+			if (entry.content !== void 0 && (0, _aigne_afs_provider_utils.isTextMime)(entry.mimeType)) {
+				if (await (0, _aigne_afs_timing.time)("ds.inl", async () => {
+					return await require_cid.computeCID(entry.content) === entry.cid;
+				})) return this.buildEntry(afsPath, {
+					content: entry.content,
+					meta: {
+						...entry.metadata ?? {},
+						kind: "did-space:file",
+						size: entry.size,
+						cid: entry.cid,
+						mimeType: entry.mimeType,
+						version: entry.cid
+					},
+					createdAt: new Date(entry.ctime),
+					updatedAt: new Date(entry.mtime)
+				});
+				log.warn(`[did-space] inline content failed cid verification at ${afsPath} (cid=${entry.cid}) — serving from objects; row will self-repair on next write`);
+			}
+			const obj = await (0, _aigne_afs_timing.time)("ds.obj", () => this.objectStore.get(this.objectKey(entry.cid)));
+			const content = await (0, _aigne_afs_timing.time)("ds.body", async () => obj ? (0, _aigne_afs_provider_utils.isTextMime)(entry.mimeType) ? await obj.text() : await obj.arrayBuffer() : (0, _aigne_afs_provider_utils.isTextMime)(entry.mimeType) ? "" : /* @__PURE__ */ new ArrayBuffer(0));
+			return this.buildEntry(afsPath, {
+				content,
+				meta: {
+					...entry.metadata ?? {},
+					kind: "did-space:file",
+					size: entry.size,
+					cid: entry.cid,
+					mimeType: entry.mimeType,
+					version: entry.cid
+				},
+				createdAt: new Date(entry.ctime),
+				updatedAt: new Date(entry.mtime)
+			});
+		}
+		if (await this.isDirectory(afsPath)) {
+			const childrenCount = await this.treeIndex.countChildren(this.treeListPrefix(afsPath));
+			return this.buildEntry(afsPath, {
+				content: `Directory: ${afsPath} (${childrenCount} entries)`,
+				meta: {
+					kind: "did-space:directory",
+					childrenCount
+				}
+			});
+		}
+		throw new _aigne_afs.AFSNotFoundError(afsPath);
+	}
+	/**
+	* presignRead — path-keyed read-grant capability (preview-r2-direct §3).
+	*
+	* Resolves `path` in THIS provider's (prefix-isolated) view exactly like
+	* `read`/`stat` (`treeIndex.get(treePath(path))`, incl. the same null-byte /
+	* `..`-segment guards). iff the resolved entry has a cid AND a signer with
+	* `presignGet` is present → mint a short-TTL presigned GET with the
+	* Content-Type baked in, and return `{ url, expiresAt }`.
+	*
+	* The path resolution IS the authorization: a caller can only presign what
+	* `read` would already return. Prefix isolation is inherited from the view's
+	* `PrefixedTreeIndex` — no separate object-level `isReferenced(cid)` is needed
+	* (that primitive is for the cid-keyed `.objects/{cid}` path, which has no
+	* tree path). NEVER throws to the caller: no signer (Node) / non-CAS / no cid /
+	* unresolved / any internal error → `null`, and the raw handler then falls back
+	* to the worker serve path. TTL = `DOWNLOAD_GRANT_TTL_SEC` (2h) — never the 7d
+	* signer cap (§8.3).
+	*/
+	async presignRead(path, opts) {
+		try {
+			const entry = await this.treeIndex.get(this.treePath(path), { includeContent: false });
+			if (!entry?.cid) return null;
+			if (this.signer == null || typeof this.signer.presignGet !== "function") return null;
+			const g = await this.signer.presignGet({
+				objectKey: this.objectKey(entry.cid),
+				expiresInSec: require_download_actions.DOWNLOAD_GRANT_TTL_SEC,
+				responseContentType: opts?.responseContentType
+			});
+			return {
+				url: g.url,
+				expiresAt: g.expiresAt
+			};
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Re-verify an entry's inline copy against its cid (§2.I list contract).
+	* Returns the content when verified, null otherwise (best-effort miss).
+	*/
+	async verifiedInline(entry) {
+		if (entry.content === void 0) return null;
+		return await require_cid.computeCID(entry.content) === entry.cid ? entry.content : null;
+	}
+	/**
+	* Returns true if the given AFS path is a virtual D4-protected path
+	* (.objects/* or .changelog/*).
+	*/
+	isVirtualPath(afsPath) {
+		const norm = afsPath.startsWith("/") ? afsPath.slice(1) : afsPath;
+		return norm === ".objects" || norm.startsWith(".objects/") || norm === ".changelog" || norm.startsWith(".changelog/");
+	}
+	async writeHandler(ctx, payload) {
+		const afsPath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		if (this.isVirtualPath(afsPath)) throw new _aigne_afs.AFSForbiddenError(afsPath, "virtual_path");
+		if (require_share_declaration.isShareReservedPath(afsPath)) throw new _aigne_afs.AFSForbiddenError(afsPath, "share-path-reserved");
+		const writeIfMatch = ctx.options?.ifMatch;
+		if (writeIfMatch !== void 0) {
+			const current = await this.treeIndex.get(this.treePath(afsPath), { includeContent: false });
+			if (require_upload_actions.ifMatchPreconditionFailed(writeIfMatch, current)) throw new _aigne_afs.AFSConflictError(afsPath, {
+				cid: current?.cid ?? null,
+				mtime: current?.mtime ?? null
+			});
+		}
+		if (payload.content === void 0 && payload.meta !== void 0) return { data: this.buildEntry(afsPath, { meta: {
+			kind: "did-space:file",
+			...payload.meta
+		} }) };
+		let bytes;
+		let storeValue;
+		if (payload.content instanceof Uint8Array) {
+			bytes = payload.content;
+			storeValue = bytes.buffer;
+		} else if (payload.content instanceof ArrayBuffer) {
+			bytes = new Uint8Array(payload.content);
+			storeValue = payload.content;
+		} else {
+			const text = typeof payload.content === "string" ? payload.content : JSON.stringify(payload.content);
+			bytes = new TextEncoder().encode(text);
+			storeValue = text;
+		}
+		const cid = await require_cid.computeCID(bytes);
+		const treePath = this.treePath(afsPath);
+		await require_share_hook.applyShareWriteHook({
+			...this.shareHookArgs(afsPath, treePath),
+			bytes,
+			cid,
+			resolver: this.shareResolver,
+			phase: "pre-io"
+		});
+		if (!await this.objectStore.head(this.objectKey(cid))) await this.objectStore.put(this.objectKey(cid), storeValue);
+		const writeMeta = ctx.options?.meta;
+		const writeDeviceId = typeof writeMeta?.deviceId === "string" && writeMeta.deviceId ? writeMeta.deviceId : this.deviceId;
+		const now = typeof writeMeta?.mtime === "number" ? writeMeta.mtime : Date.now();
+		let mimeType = payload.meta?.mimeType ?? (0, _aigne_afs_provider_utils.detectMimeType)(afsPath) ?? void 0;
+		if (!mimeType && (payload.content instanceof Uint8Array || payload.content instanceof ArrayBuffer)) mimeType = "application/octet-stream";
+		const ctime = require_timestamp.resolveCtime(payload.meta, now);
+		const treeEntry = {
+			cid,
+			size: bytes.length,
+			mtime: now,
+			ctime,
+			mimeType
+		};
+		const appMeta = extractApplicationMeta(payload.meta);
+		if (appMeta) {
+			if (typeof appMeta.dedupScope === "string") {
+				treeEntry.dedupScope = appMeta.dedupScope;
+				delete appMeta.dedupScope;
+			}
+			if (typeof appMeta.dedupKey === "string") treeEntry.dedupKey = appMeta.dedupKey;
+			if (Object.keys(appMeta).length > 0) treeEntry.metadata = appMeta;
+		}
+		if (typeof storeValue === "string") treeEntry.content = storeValue;
+		else {
+			const inlineText = require_inline_content.decodeInlineText(bytes, mimeType);
+			if (inlineText !== null) treeEntry.content = inlineText;
+		}
+		const { oldCid } = await this.treeIndex.put(treePath, treeEntry, { deviceId: writeDeviceId });
+		if (this.gcQueue) {
+			await this.gcQueue.remove(cid);
+			if (oldCid && oldCid !== cid) await this.gcQueue.enqueue([oldCid]);
+		}
+		await require_share_hook.applyShareWriteHook({
+			...this.shareHookArgs(afsPath, treePath),
+			bytes,
+			cid,
+			resolver: this.shareResolver,
+			phase: "post-io"
+		});
+		await require_blocklet_hook.applyBlockletWriteHook({
+			...this.blockletHookArgs(afsPath, treePath),
+			bytes,
+			resolver: this.blockletResolver
+		});
+		if (afsPath.endsWith(".ash")) this.emit({
+			type: _aigne_afs.SCRIPT_EVENT_TYPES.REGISTERED,
+			path: afsPath,
+			data: { runtime: "ash" }
+		});
+		const meta = {
+			...appMeta ?? {},
+			kind: "did-space:file",
+			size: treeEntry.size,
+			cid,
+			mimeType: treeEntry.mimeType
+		};
+		if (this.treeIndex.getPrefixWatermark) {
+			const version = await this.treeIndex.getPrefixWatermark(this.treePath(afsPath));
+			if (version != null) meta.liveSeq = String(version);
+		}
+		return { data: this.buildEntry(afsPath, {
+			content: storeValue,
+			meta,
+			createdAt: new Date(treeEntry.ctime),
+			updatedAt: new Date(treeEntry.mtime)
+		}) };
+	}
+	async deleteHandler(ctx) {
+		const afsPath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		if (this.isVirtualPath(afsPath)) throw new _aigne_afs.AFSForbiddenError(afsPath, "virtual_path");
+		if (require_share_declaration.isShareReservedPath(afsPath)) throw new _aigne_afs.AFSForbiddenError(afsPath, "share-path-reserved");
+		const treePath = this.treePath(afsPath);
+		const deleteMeta = ctx.options?.meta;
+		const deleteIfMatch = deleteMeta?.ifMatch;
+		if (deleteIfMatch !== void 0) {
+			const current = await this.treeIndex.get(treePath, { includeContent: false });
+			if (!current || current.cid !== deleteIfMatch) throw new _aigne_afs.AFSConflictError(afsPath, {
+				cid: current?.cid ?? null,
+				mtime: current?.mtime ?? null
+			});
+		}
+		const deleteOpts = {
+			deviceId: typeof deleteMeta?.deviceId === "string" && deleteMeta.deviceId ? deleteMeta.deviceId : this.deviceId,
+			...typeof deleteMeta?.mtime === "number" ? { mtime: deleteMeta.mtime } : {}
+		};
+		const entry = await this.treeIndex.get(treePath, { includeContent: false });
+		if (entry) {
+			await this.gcQueue?.enqueue([entry.cid]);
+			await this.treeIndex.delete(treePath, deleteOpts);
+			await require_share_hook.applyShareDeleteHook({
+				...this.shareHookArgs(afsPath, treePath),
+				resolver: this.shareResolver
+			});
+			await require_blocklet_hook.applyBlockletDeleteHook({
+				...this.blockletHookArgs(afsPath, treePath),
+				resolver: this.blockletResolver
+			});
+			if (afsPath.endsWith(".ash")) this.emit({
+				type: _aigne_afs.SCRIPT_EVENT_TYPES.UNREGISTERED,
+				path: afsPath,
+				data: { runtime: "ash" }
+			});
+			return {
+				path: afsPath,
+				deleted: true
+			};
+		}
+		const prefix = this.treeListPrefix(afsPath);
+		if (this.gcQueue) {
+			const cids = await this.collectCIDsByPrefix(prefix);
+			if (cids.length > 0) await this.gcQueue.enqueue(cids);
+		}
+		if (await this.treeIndex.deleteByPrefix(prefix, deleteOpts) === 0) throw new _aigne_afs.AFSNotFoundError(afsPath);
+		return {
+			path: afsPath,
+			deleted: true
+		};
+	}
+	/** Conflict failure shaped exactly like the single-op AFSConflictError surface. */
+	batchConflictFailure(afsPath, conflict) {
+		return {
+			path: afsPath,
+			success: false,
+			error: `Write conflict at ${afsPath}`,
+			code: "AFS_CONFLICT",
+			conflict
+		};
+	}
+	/** ONE preflight read for a batch — getMany when the index has it, per-path get otherwise. */
+	async batchPreread(treePaths) {
+		if (this.treeIndex.getMany) return this.treeIndex.getMany(treePaths);
+		return new Map(await Promise.all(treePaths.map(async (tp) => [tp, await this.treeIndex.get(tp)])));
+	}
+	/** Run `fn` over `items` with bounded concurrency (Workers cap: 6 sockets). */
+	async boundedAll(items, limit, fn) {
+		let next = 0;
+		const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+			while (next < items.length) {
+				const item = items[next++];
+				await fn(item);
+			}
+		});
+		await Promise.all(workers);
+	}
+	/**
+	* Native batch read (issue #808 follow-up) — the render fast path. Resolves the
+	* whole path set with ONE `treeIndex.getMany` (chunked `IN(…)`, which carries
+	* inline content when the index has it), so small cid-verified inline files are
+	* served with ZERO R2 gets; only the (few, large) non-inline entries fall back
+	* to bounded-concurrent `objectStore.get`. Mirrors the single-read handler's
+	* inline-verify → objects cascade per entry. File-oriented: getMany matches
+	* `kind='file'`, so directory / absent paths come back AFS_NOT_FOUND (callers
+	* reading directories use `list`/`read`).
+	*/
+	async batchRead(entries, _options) {
+		const afsPaths = entries.map((e) => (0, ufo.joinURL)("/", e.path));
+		const treePaths = afsPaths.map((p) => this.treePath(p));
+		const preread = await this.batchPreread(treePaths);
+		const results = new Array(entries.length);
+		const fileEntry = (afsPath, entry, content) => this.buildEntry(afsPath, {
+			content,
+			meta: {
+				...entry.metadata ?? {},
+				kind: "did-space:file",
+				size: entry.size,
+				cid: entry.cid,
+				mimeType: entry.mimeType,
+				version: entry.cid
+			},
+			createdAt: new Date(entry.ctime),
+			updatedAt: new Date(entry.mtime)
+		});
+		const needObject = [];
+		for (let i = 0; i < entries.length; i++) {
+			const entry = preread.get(treePaths[i]);
+			if (!entry) {
+				results[i] = {
+					path: afsPaths[i],
+					success: false,
+					error: `Path not found: ${afsPaths[i]}`,
+					code: "AFS_NOT_FOUND"
+				};
+				continue;
+			}
+			if (entry.content !== void 0 && (0, _aigne_afs_provider_utils.isTextMime)(entry.mimeType)) {
+				if (await require_cid.computeCID(entry.content) === entry.cid) {
+					results[i] = {
+						path: afsPaths[i],
+						success: true,
+						data: fileEntry(afsPaths[i], entry, entry.content)
+					};
+					continue;
+				}
+				log.warn(`[did-space] inline content failed cid verification at ${afsPaths[i]} (cid=${entry.cid}) — serving from objects; row will self-repair on next write`);
+			}
+			needObject.push(i);
+		}
+		await this.boundedAll(needObject, 6, async (i) => {
+			const entry = preread.get(treePaths[i]);
+			const obj = await this.objectStore.get(this.objectKey(entry.cid));
+			const isText = (0, _aigne_afs_provider_utils.isTextMime)(entry.mimeType);
+			const content = obj ? isText ? await obj.text() : await obj.arrayBuffer() : isText ? "" : /* @__PURE__ */ new ArrayBuffer(0);
+			results[i] = {
+				path: afsPaths[i],
+				success: true,
+				data: fileEntry(afsPaths[i], entry, content)
+			};
+		});
+		const succeeded = results.filter((r) => r.success).length;
+		return {
+			results,
+			succeeded,
+			failed: entries.length - succeeded
+		};
+	}
+	/**
+	* Native batch write — the CF-subrequest-budget merge (§4.3): eight-step
+	* order aligned point-for-point with the single write path (preread BEFORE
+	* share pre-io, so a stale ifMatch on a `.share` declaration yields 409,
+	* never a share error):
+	*   1 shape/decode/computeCID → 2 ONE preread (conflict/skip exit here —
+	*   no share hook, no R2 upload) → 3 share pre-io (survivors) → 4 in-batch
+	*   CID dedup → 5 unconditional R2 put (unique cids, bounded ≤6 —
+	*   P0-measured wall-time) → 6 treeIndex.batchPutEntries (single db.batch)
+	*   → 7 gcQueue removeMany/enqueue → 8 share post-io + per-entry results.
+	*/
+	async batchWrite(entries, _options) {
+		if (entries.some((e) => e.options?.dedupBy || e.options?.dedupKey)) {
+			const seq = [];
+			let succeeded$1 = 0;
+			for (const entry of entries) {
+				const afsPath = (0, ufo.joinURL)("/", entry.path);
+				try {
+					const payload = entry.content;
+					if (!payload || payload.content === void 0) throw new _aigne_afs.AFSValidationError("Batch write requires entry content");
+					const opts = {
+						...entry.options ?? {},
+						...entry.mode ? { mode: entry.mode } : {}
+					};
+					const res = await this.write(entry.path, payload, opts);
+					seq.push({
+						path: res.data.path,
+						success: true,
+						data: res.data
+					});
+					succeeded$1++;
+				} catch (err) {
+					seq.push({
+						path: afsPath,
+						success: false,
+						error: err instanceof Error ? err.message : String(err),
+						code: err instanceof _aigne_afs.AFSConflictError ? "AFS_CONFLICT" : err?.code ?? "AFS_WRITE_ERROR"
+					});
+				}
+			}
+			return {
+				results: seq,
+				succeeded: succeeded$1,
+				failed: entries.length - succeeded$1
+			};
+		}
+		const results = new Array(entries.length);
+		const prepared = [];
+		for (let i = 0; i < entries.length; i++) {
+			const entry = entries[i];
+			const afsPath = (0, ufo.joinURL)("/", entry.path);
+			if (entry.patches || entry.mode && entry.mode !== "replace") {
+				results[i] = {
+					path: afsPath,
+					success: false,
+					error: `Batch write supports replace-mode content writes only (got mode '${entry.mode ?? "patches"}')`,
+					code: "AFS_UNSUPPORTED"
+				};
+				continue;
+			}
+			if (this.isVirtualPath(afsPath) || require_share_declaration.isShareReservedPath(afsPath)) {
+				results[i] = {
+					path: afsPath,
+					success: false,
+					error: `Forbidden at ${afsPath}: virtual_path`,
+					code: "AFS_FORBIDDEN"
+				};
+				continue;
+			}
+			const payload = entry.content ?? {};
+			if (payload.content === void 0) {
+				results[i] = {
+					path: afsPath,
+					success: false,
+					error: "Batch write requires entry content (meta-only writes are single-op)",
+					code: "AFS_VALIDATION_ERROR"
+				};
+				continue;
+			}
+			let bytes;
+			let storeValue;
+			if (payload.content instanceof Uint8Array) {
+				bytes = payload.content;
+				storeValue = bytes.buffer;
+			} else if (payload.content instanceof ArrayBuffer) {
+				bytes = new Uint8Array(payload.content);
+				storeValue = payload.content;
+			} else {
+				const text = typeof payload.content === "string" ? payload.content : JSON.stringify(payload.content);
+				bytes = new TextEncoder().encode(text);
+				storeValue = text;
+			}
+			const cid = await require_cid.computeCID(bytes);
+			const writeOptions = entry.options;
+			const writeMeta = writeOptions?.meta;
+			const deviceId = typeof writeMeta?.deviceId === "string" && writeMeta.deviceId ? writeMeta.deviceId : this.deviceId;
+			const now = typeof writeMeta?.mtime === "number" ? writeMeta.mtime : Date.now();
+			let mimeType = payload.meta?.mimeType ?? (0, _aigne_afs_provider_utils.detectMimeType)(afsPath) ?? void 0;
+			if (!mimeType && (payload.content instanceof Uint8Array || payload.content instanceof ArrayBuffer)) mimeType = "application/octet-stream";
+			const ctime = require_timestamp.resolveCtime(payload.meta, now);
+			const treeEntry = {
+				cid,
+				size: bytes.length,
+				mtime: now,
+				ctime,
+				mimeType
+			};
+			const appMeta = extractApplicationMeta(payload.meta);
+			if (appMeta) {
+				try {
+					assertMetadataSize(appMeta, afsPath);
+				} catch (err) {
+					results[i] = {
+						path: afsPath,
+						success: false,
+						error: err instanceof Error ? err.message : String(err),
+						code: err.code ?? "AFS_VALIDATION_ERROR"
+					};
+					continue;
+				}
+				treeEntry.metadata = appMeta;
+			}
+			if (typeof storeValue === "string") treeEntry.content = storeValue;
+			else {
+				const inlineText = require_inline_content.decodeInlineText(bytes, mimeType);
+				if (inlineText !== null) treeEntry.content = inlineText;
+			}
+			prepared.push({
+				i,
+				afsPath,
+				treePath: this.treePath(afsPath),
+				bytes,
+				storeValue,
+				cid,
+				treeEntry,
+				deviceId,
+				ifMatch: writeOptions?.ifMatch
+			});
+		}
+		const preread = await this.batchPreread(prepared.map((p) => p.treePath));
+		const skipped = [];
+		let live = [];
+		for (const p of prepared) {
+			const existing = preread.get(p.treePath) ?? null;
+			if (require_upload_actions.ifMatchPreconditionFailed(p.ifMatch, existing)) {
+				results[p.i] = this.batchConflictFailure(p.afsPath, {
+					currentCid: existing?.cid ?? null,
+					currentMtime: existing?.mtime ?? null,
+					currentDeviceId: null
+				});
+				continue;
+			}
+			live.push(p);
+		}
+		const preIoOk = [];
+		for (const p of live) try {
+			await require_share_hook.applyShareWriteHook({
+				...this.shareHookArgs(p.afsPath, p.treePath),
+				bytes: p.bytes,
+				cid: p.cid,
+				resolver: this.shareResolver,
+				phase: "pre-io"
+			});
+			preIoOk.push(p);
+		} catch (err) {
+			results[p.i] = {
+				path: p.afsPath,
+				success: false,
+				error: err instanceof Error ? err.message : String(err),
+				code: err.code
+			};
+		}
+		live = preIoOk;
+		const uniqueCids = /* @__PURE__ */ new Map();
+		for (const p of live) if (!uniqueCids.has(p.cid)) uniqueCids.set(p.cid, p);
+		const uploadFailed = /* @__PURE__ */ new Map();
+		const uploaded = [];
+		await this.boundedAll([...uniqueCids.values()], 6, async (p) => {
+			try {
+				await this.objectStore.put(this.objectKey(p.cid), p.storeValue);
+				uploaded.push(p.cid);
+			} catch (err) {
+				uploadFailed.set(p.cid, err instanceof Error ? err.message : String(err));
+			}
+		});
+		if (uploadFailed.size > 0) {
+			const stillLive = [];
+			for (const p of live) {
+				const failure = uploadFailed.get(p.cid);
+				if (failure !== void 0) results[p.i] = {
+					path: p.afsPath,
+					success: false,
+					error: `R2 put failed: ${failure}`
+				};
+				else stillLive.push(p);
+			}
+			live = stillLive;
+		}
+		let indexResults = [];
+		if (live.length > 0) {
+			const batchEntries = live.map((p) => ({
+				path: p.treePath,
+				entry: p.treeEntry,
+				opts: { deviceId: p.deviceId }
+			}));
+			try {
+				indexResults = this.treeIndex.batchPutEntries ? await this.treeIndex.batchPutEntries(batchEntries, { preread }) : await require_tree_index.loopBatchPutEntries(this.treeIndex, batchEntries, { preread });
+			} catch (err) {
+				await this.gcQueue?.enqueue(uploaded);
+				const message = err instanceof Error ? err.message : String(err);
+				for (const p of live) results[p.i] = {
+					path: p.afsPath,
+					success: false,
+					error: message
+				};
+				live = [];
+			}
+		}
+		const written = [];
+		live.forEach((p, j) => {
+			const r = indexResults[j];
+			if (!r) {
+				results[p.i] = {
+					path: p.afsPath,
+					success: false,
+					error: "index batch returned no result"
+				};
+				return;
+			}
+			if (r.conflict) {
+				results[p.i] = this.batchConflictFailure(p.afsPath, r.conflict);
+				return;
+			}
+			if (r.error) {
+				results[p.i] = {
+					path: p.afsPath,
+					success: false,
+					error: r.error
+				};
+				return;
+			}
+			if (r.skipped) {
+				skipped.push(p);
+				return;
+			}
+			written.push({
+				p,
+				oldCid: r.oldCid,
+				liveSeq: r.liveSeq
+			});
+		});
+		if (this.gcQueue) {
+			const reReferenced = [...new Set([...written.map((w) => w.p.cid), ...skipped.map((s) => s.cid)])];
+			if (reReferenced.length > 0) if (this.gcQueue.removeMany) await this.gcQueue.removeMany(reReferenced);
+			else for (const cid of reReferenced) await this.gcQueue.remove(cid);
+			const replaced = [...new Set(written.filter((w) => w.oldCid && w.oldCid !== w.p.cid).map((w) => w.oldCid))];
+			if (replaced.length > 0) await this.gcQueue.enqueue(replaced);
+		}
+		for (const w of written) {
+			try {
+				await require_share_hook.applyShareWriteHook({
+					...this.shareHookArgs(w.p.afsPath, w.p.treePath),
+					bytes: w.p.bytes,
+					cid: w.p.cid,
+					resolver: this.shareResolver,
+					phase: "post-io"
+				});
+			} catch (err) {
+				w.error = err instanceof Error ? err.message : String(err);
+			}
+			if (w.p.afsPath.endsWith(".ash")) this.emit({
+				type: _aigne_afs.SCRIPT_EVENT_TYPES.REGISTERED,
+				path: w.p.afsPath,
+				data: { runtime: "ash" }
+			});
+		}
+		const maxSeqByPrefix = /* @__PURE__ */ new Map();
+		for (const w of written) {
+			if (typeof w.liveSeq !== "number") continue;
+			const wm = require_changelog_schema.watermarkWritePrefix(w.p.treePath);
+			if (wm === null) continue;
+			maxSeqByPrefix.set(wm, Math.max(maxSeqByPrefix.get(wm) ?? 0, w.liveSeq));
+		}
+		for (const s of skipped) {
+			const wm = require_changelog_schema.watermarkWritePrefix(s.treePath);
+			let liveSeq = wm !== null ? maxSeqByPrefix.get(wm) : void 0;
+			if (liveSeq === void 0 && this.treeIndex.getPrefixWatermark) liveSeq = await this.treeIndex.getPrefixWatermark(s.treePath) ?? void 0;
+			results[s.i] = {
+				path: s.afsPath,
+				success: true,
+				data: this.buildBatchWriteData(s, liveSeq)
+			};
+		}
+		for (const w of written) {
+			if (w.error) {
+				results[w.p.i] = {
+					path: w.p.afsPath,
+					success: false,
+					error: w.error
+				};
+				continue;
+			}
+			results[w.p.i] = {
+				path: w.p.afsPath,
+				success: true,
+				data: this.buildBatchWriteData(w.p, w.liveSeq)
+			};
+		}
+		const succeeded = results.filter((r) => r?.success).length;
+		return {
+			results,
+			succeeded,
+			failed: results.length - succeeded
+		};
+	}
+	/** Write-echo entry — field-for-field the single-op writeHandler result. */
+	buildBatchWriteData(p, liveSeq) {
+		const meta = {
+			kind: "did-space:file",
+			size: p.treeEntry.size,
+			cid: p.cid,
+			mimeType: p.treeEntry.mimeType
+		};
+		if (liveSeq != null) meta.liveSeq = String(liveSeq);
+		return this.buildEntry(p.afsPath, {
+			content: p.storeValue,
+			meta,
+			createdAt: new Date(p.treeEntry.ctime),
+			updatedAt: new Date(p.treeEntry.mtime)
+		});
+	}
+	/** Build a failed AFSExecResult (shared across the three action handlers). */
+	uploadErr(code, message) {
+		return {
+			success: false,
+			error: {
+				code,
+				message
+			}
+		};
+	}
+	/**
+	* Session ownership isolation (§9 / §10): a session belongs to THIS view only
+	* when its scope equals this provider's storage scope. A different-scope (or
+	* unknown) session is treated as not-found — never confirm another user's
+	* session exists, and never let one view commit into another.
+	*/
+	ownsSession(session) {
+		return !!session && session.scope === (this.uploadScope ?? this.did);
+	}
+	/**
+	* Validate an action-supplied `path`. Unlike `@Write` handlers, action args
+	* carry NO router-layer traversal protection — `args.entries[].path` is raw
+	* client input, so we MUST normalize + reject traversal / reserved virtual
+	* prefixes explicitly (design §10). Returns the tree path on success.
+	*/
+	validateActionPath(afsPath) {
+		const norm = afsPath.startsWith("/") ? afsPath.slice(1) : afsPath;
+		if (this.isVirtualPath(afsPath) || require_share_declaration.isShareReservedPath(afsPath) || norm === ".actions" || norm.startsWith(".actions/")) return {
+			ok: false,
+			reason: `reserved path: ${afsPath}`
+		};
+		let treePath;
+		try {
+			treePath = this.treePath(afsPath);
+		} catch (err) {
+			return {
+				ok: false,
+				reason: err instanceof Error ? err.message : String(err)
+			};
+		}
+		return {
+			ok: true,
+			treePath
+		};
+	}
+	/**
+	* Action catalogue — the upload-plane + download-plane actions, always listed
+	* (protocol parity, T2.5). Each plane advertises its OWN capability flag:
+	* `grantCapability` for prepare-upload, the INDEPENDENT `downloadGrantCapability`
+	* for prepare-download (design §7.3 / Finding 4 — never reuse the upload flag,
+	* so the two planes can be advertised separately).
+	*/
+	listObjectPlaneActions(ctx) {
+		const grantCapable = this.signer != null;
+		const downloadGrantCapable = this.signer != null && typeof this.signer.presignGet === "function";
+		return { data: [...require_upload_actions.UPLOAD_ACTIONS, ...require_download_actions.DOWNLOAD_ACTIONS].map((name) => this.buildEntry((0, ufo.joinURL)(ctx.path, name), {
+			id: name,
+			meta: {
+				kind: "afs:executable",
+				...name === "prepare-upload" ? { grantCapability: grantCapable } : {},
+				...name === "prepare-download" ? { downloadGrantCapability: downloadGrantCapable } : {}
+			}
+		})) };
+	}
+	async execPrepareUpload(_ctx, args) {
+		if (!this.uploadSessionStore) return this.uploadErr("AFS_UNSUPPORTED", "upload plane not available");
+		const parsed = require_upload_actions.PrepareUploadArgsSchema.safeParse(args);
+		if (!parsed.success) return this.uploadErr("AFS_VALIDATION_ERROR", require_upload_actions.zodMessage(parsed.error));
+		const outEntries = [];
+		const storeEntries = [];
+		const seenPaths = /* @__PURE__ */ new Set();
+		for (const e of parsed.data.entries) {
+			const afsPath = (0, ufo.joinURL)("/", e.path);
+			const pv = this.validateActionPath(afsPath);
+			if (!pv.ok) return this.uploadErr("AFS_VALIDATION_ERROR", pv.reason);
+			if (seenPaths.has(afsPath)) return this.uploadErr("AFS_VALIDATION_ERROR", `duplicate path: ${afsPath}`);
+			seenPaths.add(afsPath);
+			let checksum;
+			try {
+				checksum = require_cid.cidToChecksumSha256(e.cid);
+			} catch (err) {
+				return this.uploadErr("AFS_VALIDATION_ERROR", `bad cid for ${afsPath}: ${err instanceof Error ? err.message : err}`);
+			}
+			const objectKey = this.objectKey(e.cid);
+			let grant = null;
+			if (this.signer) {
+				const g = await this.signer.presignPut({
+					objectKey,
+					checksumSha256: checksum,
+					expiresInSec: require_upload_actions.GRANT_EXPIRES_SEC,
+					contentLength: e.size
+				});
+				grant = {
+					kind: "presigned-put",
+					url: g.url,
+					method: g.method,
+					signedHeaders: g.signedHeaders,
+					expiresAt: g.expiresAt
+				};
+			}
+			outEntries.push({
+				path: afsPath,
+				cid: e.cid,
+				status: "needs-upload",
+				objectKey,
+				checksumSha256: checksum,
+				grant
+			});
+			storeEntries.push({
+				path: afsPath,
+				cid: e.cid,
+				objectKey,
+				checksumSha256: checksum,
+				size: e.size,
+				mimeType: e.mimeType ?? null,
+				ifMatch: e.ifMatch ?? null,
+				deviceId: e.deviceId ?? null,
+				mtime: e.mtime ?? null,
+				status: "needs_upload"
+			});
+		}
+		const sessionId = crypto.randomUUID();
+		const expiresAt = Date.now() + require_upload_session_store.UPLOAD_SESSION_TTL_MS;
+		await this.uploadSessionStore.createSession({
+			id: sessionId,
+			scope: this.uploadScope ?? this.did,
+			caller: null,
+			expiresAt,
+			entries: storeEntries
+		});
+		return {
+			success: true,
+			data: {
+				sessionId,
+				expiresAt: new Date(expiresAt).toISOString(),
+				entries: outEntries
+			}
+		};
+	}
+	async execPrepareDownload(_ctx, args) {
+		const parsed = require_download_actions.PrepareDownloadArgsSchema.safeParse(args);
+		if (!parsed.success) return this.uploadErr("AFS_VALIDATION_ERROR", require_upload_actions.zodMessage(parsed.error));
+		const inputEntries = parsed.data.entries;
+		const cidValid = /* @__PURE__ */ new Map();
+		const validCids = [];
+		for (const e of inputEntries) {
+			if (cidValid.has(e.cid)) continue;
+			let ok = true;
+			try {
+				require_cid.cidToChecksumSha256(e.cid);
+			} catch {
+				ok = false;
+			}
+			cidValid.set(e.cid, ok);
+			if (ok) validCids.push(e.cid);
+		}
+		let referenced = /* @__PURE__ */ new Set();
+		if (validCids.length > 0) try {
+			referenced = await this.treeIndex.isReferencedMany(validCids);
+		} catch {
+			return this.uploadErr("AFS_INTERNAL_ERROR", "prepare-download authorization unavailable");
+		}
+		const canSign = this.signer != null && typeof this.signer.presignGet === "function";
+		const grantByCid = /* @__PURE__ */ new Map();
+		for (const cid of referenced) if (canSign) {
+			const g = await this.signer.presignGet({
+				objectKey: this.objectKey(cid),
+				expiresInSec: require_download_actions.DOWNLOAD_GRANT_TTL_SEC
+			});
+			grantByCid.set(cid, {
+				kind: "presigned-get",
+				url: g.url,
+				method: g.method,
+				signedHeaders: g.signedHeaders,
+				expiresAt: g.expiresAt
+			});
+		} else grantByCid.set(cid, null);
+		return {
+			success: true,
+			data: { entries: inputEntries.map((e) => {
+				if (!cidValid.get(e.cid)) return {
+					cid: e.cid,
+					status: "invalid"
+				};
+				if (!referenced.has(e.cid)) return {
+					cid: e.cid,
+					status: "forbidden"
+				};
+				return {
+					cid: e.cid,
+					status: "ok",
+					objectKey: this.objectKey(e.cid),
+					grant: grantByCid.get(e.cid) ?? null
+				};
+			}) }
+		};
+	}
+	async execCommitUpload(_ctx, args) {
+		if (!this.uploadSessionStore) return this.uploadErr("AFS_UNSUPPORTED", "upload plane not available");
+		const parsed = require_upload_actions.CommitUploadArgsSchema.safeParse(args);
+		if (!parsed.success) return this.uploadErr("AFS_VALIDATION_ERROR", require_upload_actions.zodMessage(parsed.error));
+		const { sessionId, entries } = parsed.data;
+		const session = await this.uploadSessionStore.getSession(sessionId);
+		if (!this.ownsSession(session)) return this.uploadErr("AFS_NOT_FOUND", "unknown upload session");
+		if (session.status === "aborted") return this.uploadErr("AFS_UNSUPPORTED", "session aborted");
+		if (session.status === "prepared" && session.expiresAt <= Date.now()) return this.uploadErr("AFS_UNSUPPORTED", "session expired");
+		const result = await this.commitSessionEntries(session.id, session.entries, entries);
+		await this.uploadSessionStore.markCommitted(session.id);
+		return {
+			success: true,
+			data: result
+		};
+	}
+	async execAbortUpload(_ctx, args) {
+		if (!this.uploadSessionStore) return this.uploadErr("AFS_UNSUPPORTED", "upload plane not available");
+		const parsed = require_upload_actions.AbortUploadArgsSchema.safeParse(args);
+		if (!parsed.success) return this.uploadErr("AFS_VALIDATION_ERROR", require_upload_actions.zodMessage(parsed.error));
+		const session = await this.uploadSessionStore.getSession(parsed.data.sessionId);
+		if (!this.ownsSession(session)) return this.uploadErr("AFS_NOT_FOUND", "unknown upload session");
+		await this.uploadSessionStore.markAborted(session.id);
+		if (this.gcQueue) {
+			const orphanCids = [...new Set(session.entries.filter((e) => e.status !== "committed").map((e) => e.cid))];
+			if (orphanCids.length > 0) await this.gcQueue.enqueue(orphanCids);
+		}
+		return {
+			success: true,
+			data: {
+				sessionId: session.id,
+				status: "aborted"
+			}
+		};
+	}
+	/**
+	* Resolve the immutable-merge-key set: `createdAt` is always preserved, plus
+	* any caller-supplied lifecycle fields (e.g. `status`).
+	*/
+	resolveImmutableMergeKeys(extra) {
+		const keys = new Set(["createdAt"]);
+		for (const k of extra ?? []) keys.add(k);
+		return keys;
+	}
+	/** Extract the JSON record object from a write payload's `content`. */
+	parseRecordBody(content) {
+		if (content !== null && typeof content === "object" && !Array.isArray(content) && !(content instanceof Uint8Array) && !(content instanceof ArrayBuffer)) return content;
+		if (typeof content === "string") try {
+			const v = JSON.parse(content);
+			return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
+		} catch {
+			return null;
+		}
+		return null;
+	}
+	/**
+	* Stamp the dedup identity into a write's meta so the writeHandler can project
+	* it onto the entry's `dedup_scope` / `dedup_key` columns (#1159). `dedupKey`
+	* stays in the metadata blob (observability / collection-query); on a merge
+	* we drop `createdAt` so the index keeps the original file ctime (R1,
+	* feed-sort §5.1).
+	*/
+	stampDedupMeta(base, dedupScope, dedupKey, isDuplicate) {
+		const meta = { ...base ?? {} };
+		meta.dedupKey = dedupKey;
+		meta.dedupScope = dedupScope;
+		if (isDuplicate) delete meta.createdAt;
+		return meta;
+	}
+	/**
+	* Dedup-on-write core (#492 / #1159) — the `options.dedupBy` upsert behind the
+	* standard `write` / `batchWrite`. The record's `dedupBy` field (URL-valued)
+	* is normalized into a `dedupKey`; the record lands at a STABLE readable path
+	* (`{collection}/{uuid}.json`) and dedup resolves through the tree-index's
+	* `(scope, dedup_scope, dedup_key)` secondary UNIQUE index — NOT a
+	* cid-in-path filename (which silently orphaned records written under any
+	* other layout, #1159). On a hit the incoming record is MERGED
+	* (non-degrading) into the existing entry AT ITS REAL PATH. Concurrency-safe:
+	* a racing create collides on the UNIQUE index, and the loser re-queries the
+	* index and merges (bounded retry). Records missing the field are written
+	* normally under the collection (no dedup).
+	*/
+	async upsertByDedupKey(path, content, options, dedupBy) {
+		if (!this.treeIndex.findByDedupKey) throw new _aigne_afs.AFSValidationError("dedup-on-write (dedupBy) is not supported by this DID Space index");
+		const { dedupBy: _by, dedupKey: _dk, mergeImmutableFields, ...baseOpts } = options;
+		const body = this.parseRecordBody(content.content);
+		const rawVal = body && typeof body[dedupBy] === "string" ? body[dedupBy] : null;
+		if (!body || !rawVal) {
+			const fresh = (0, ufo.joinURL)("/", path, `${crypto.randomUUID()}.json`);
+			return {
+				...await super.write(fresh, content, baseOpts),
+				deduped: false
+			};
+		}
+		const dedupKey = require_url_normalize.normalizeItemUrl(rawVal);
+		const dedupScope = this.treePath((0, ufo.joinURL)("/", path));
+		const immutable = this.resolveImmutableMergeKeys(mergeImmutableFields);
+		const MAX_ATTEMPTS = 4;
+		for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+			const existing = await this.treeIndex.findByDedupKey(dedupScope, dedupKey);
+			if (existing) {
+				const target = `/${existing.path}`;
+				let existingBody = null;
+				let version;
+				try {
+					const readResult = await this.read(target);
+					existingBody = this.parseRecordBody(readResult.data?.content);
+					version = (readResult.data?.meta)?.version;
+				} catch (err) {
+					if (err instanceof _aigne_afs.AFSNotFoundError) continue;
+					throw err;
+				}
+				const mergedBody = existingBody !== null ? mergeItemContent(existingBody, body, immutable) : { ...body };
+				const meta$1 = this.stampDedupMeta(content.meta, dedupScope, dedupKey, true);
+				const callerIfMatch = baseOpts.ifMatch;
+				const ifMatch = callerIfMatch ?? version;
+				try {
+					return {
+						...await super.write(target, {
+							...content,
+							content: mergedBody,
+							meta: meta$1
+						}, ifMatch ? {
+							...baseOpts,
+							ifMatch
+						} : baseOpts),
+						deduped: true
+					};
+				} catch (err) {
+					if (err instanceof _aigne_afs.AFSConflictError && callerIfMatch === void 0) continue;
+					throw err;
+				}
+			}
+			const fresh = (0, ufo.joinURL)("/", path, `${crypto.randomUUID()}.json`);
+			const meta = this.stampDedupMeta(content.meta, dedupScope, dedupKey, false);
+			try {
+				return {
+					...await super.write(fresh, {
+						...content,
+						content: body,
+						meta
+					}, baseOpts),
+					deduped: false
+				};
+			} catch (err) {
+				if (await this.treeIndex.findByDedupKey(dedupScope, dedupKey)) continue;
+				throw err;
+			}
+		}
+		throw new _aigne_afs.AFSConflictError((0, ufo.joinURL)("/", path), {});
+	}
+	/**
+	* One-time reindex/backfill seam (#1159 — run from a deferred one-shot
+	* script, NOT on the write hot path). Populates the dedup columns for
+	* EXISTING records under `collection` so pre-feature entries (old
+	* `{slug}.json` / `{uuid}/item.json` / `{cid}.json` layouts) become
+	* dedup-able — fixing the "an already-saved URL's first re-save duplicates"
+	* bug. Reads each record, extracts + normalizes `record[dedupBy]`, and writes
+	* the dedup columns INDEX-ONLY (no changelog / no cid change) via
+	* `TreeIndex.setDedupKey`. Records missing the field, and genuine
+	* pre-existing duplicates (which would violate the UNIQUE index), are
+	* skipped. Idempotent.
+	*/
+	async reindexDedupKeys(collection, dedupBy) {
+		if (!this.treeIndex.setDedupKey) throw new _aigne_afs.AFSValidationError("reindexDedupKeys is not supported by this DID Space index");
+		const dedupScope = this.treePath((0, ufo.joinURL)("/", collection));
+		const listPrefix = dedupScope.endsWith("/") ? dedupScope : `${dedupScope}/`;
+		let scanned = 0;
+		let indexed = 0;
+		let skipped = 0;
+		let cursor;
+		do {
+			const page = await this.treeIndex.listEntries(listPrefix, {
+				limit: 500,
+				cursor
+			});
+			for (const e of page.entries) {
+				scanned++;
+				let body = null;
+				try {
+					const r = await this.read(`/${e.path}`);
+					body = this.parseRecordBody(r.data?.content);
+				} catch {
+					skipped++;
+					continue;
+				}
+				const raw = body && typeof body[dedupBy] === "string" ? body[dedupBy] : null;
+				if (!raw) {
+					skipped++;
+					continue;
+				}
+				try {
+					await this.treeIndex.setDedupKey(e.path, dedupScope, require_url_normalize.normalizeItemUrl(raw), { deviceId: this.deviceId });
+					indexed++;
+				} catch {
+					skipped++;
+				}
+			}
+			cursor = page.hasMore ? page.cursor : void 0;
+		} while (cursor);
+		return {
+			scanned,
+			indexed,
+			skipped
+		};
+	}
+	/**
+	* Standard write, extended with the dedup-on-write upsert policy (#492 /
+	* #1159). When `options.dedupBy` (canonical) or the deprecated `dedupKey`
+	* alias is set the write becomes a secondary-index upsert (see
+	* {@link upsertByDedupKey}); otherwise it is the base provider's write.
+	*/
+	async write(path, content, options) {
+		const dedupBy = options?.dedupBy ?? options?.dedupKey;
+		if (dedupBy) return this.upsertByDedupKey(path, content, options, dedupBy);
+		return super.write(path, content, options);
+	}
+	/**
+	* The commit write — mirrors `batchWrite` steps 2/6/7/8 WITHOUT the R2 byte
+	* leg (existence is trusted, §8): preread → ifMatch/skip → batchPutEntries →
+	* GC bookkeeping → share hooks → per-entry results. `cid`/`size`/`mimeType`
+	* come from the SESSION record (the prepared contract, re-validated against
+	* the client's entries); `deviceId`/`mtime` are client provenance threaded to
+	* the changelog (echo防回环, §6.1).
+	*/
+	async commitSessionEntries(sessionId, sessionEntries, clientEntries) {
+		const byPath = new Map(sessionEntries.map((e) => [(0, ufo.joinURL)("/", e.path), e]));
+		const results = new Array(clientEntries.length);
+		const prepared = [];
+		for (let i = 0; i < clientEntries.length; i++) {
+			const c = clientEntries[i];
+			const afsPath = (0, ufo.joinURL)("/", c.path);
+			const pv = this.validateActionPath(afsPath);
+			if (!pv.ok) {
+				results[i] = {
+					path: afsPath,
+					success: false,
+					error: pv.reason,
+					code: "AFS_VALIDATION_ERROR"
+				};
+				continue;
+			}
+			const se = byPath.get(afsPath);
+			if (!se || se.cid !== c.cid) {
+				results[i] = {
+					path: afsPath,
+					success: false,
+					error: "entry not in session, or cid mismatch with prepared contract",
+					code: "AFS_VALIDATION_ERROR"
+				};
+				continue;
+			}
+			const deviceId = typeof c.deviceId === "string" && c.deviceId ? c.deviceId : se.deviceId ?? this.deviceId;
+			const mtime = typeof c.mtime === "number" ? c.mtime : se.mtime ?? Date.now();
+			const ctime = require_timestamp.resolveCtime(c.metadata, mtime);
+			const treeEntry = {
+				cid: se.cid,
+				size: se.size,
+				mtime,
+				ctime,
+				mimeType: se.mimeType ?? void 0
+			};
+			if (c.content !== void 0 && (0, _aigne_afs_provider_utils.isTextMime)(se.mimeType ?? void 0)) {
+				if (await require_cid.checksumSha256OfContent(c.content) === se.checksumSha256) treeEntry.content = c.content;
+			}
+			if (c.metadata) {
+				const appMeta = extractApplicationMeta(c.metadata);
+				if (appMeta) {
+					try {
+						assertMetadataSize(appMeta, afsPath);
+					} catch (err) {
+						results[i] = {
+							path: afsPath,
+							success: false,
+							error: err instanceof Error ? err.message : String(err),
+							code: err.code ?? "AFS_VALIDATION_ERROR"
+						};
+						continue;
+					}
+					treeEntry.metadata = appMeta;
+				}
+			}
+			prepared.push({
+				i,
+				afsPath,
+				treePath: pv.treePath,
+				cid: se.cid,
+				treeEntry,
+				deviceId,
+				...se.ifMatch ? { ifMatch: se.ifMatch } : {}
+			});
+		}
+		const preread = await this.batchPreread(prepared.map((p) => p.treePath));
+		const skipped = [];
+		let live = [];
+		for (const p of prepared) {
+			const existing = preread.get(p.treePath) ?? null;
+			if (require_upload_actions.ifMatchPreconditionFailed(p.ifMatch, existing)) {
+				results[p.i] = this.batchConflictFailure(p.afsPath, {
+					currentCid: existing?.cid ?? null,
+					currentMtime: existing?.mtime ?? null,
+					currentDeviceId: null
+				});
+				continue;
+			}
+			live.push(p);
+		}
+		const preIoOk = [];
+		for (const p of live) try {
+			await require_share_hook.applyShareWriteHook({
+				...this.shareHookArgs(p.afsPath, p.treePath),
+				bytes: new Uint8Array(0),
+				cid: p.cid,
+				resolver: this.shareResolver,
+				phase: "pre-io"
+			});
+			preIoOk.push(p);
+		} catch (err) {
+			results[p.i] = {
+				path: p.afsPath,
+				success: false,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+		live = preIoOk;
+		let indexResults = [];
+		if (live.length > 0) {
+			const batchEntries = live.map((p) => ({
+				path: p.treePath,
+				entry: p.treeEntry,
+				opts: { deviceId: p.deviceId }
+			}));
+			indexResults = this.treeIndex.batchPutEntries ? await this.treeIndex.batchPutEntries(batchEntries, { preread }) : await require_tree_index.loopBatchPutEntries(this.treeIndex, batchEntries, { preread });
+		}
+		const written = [];
+		live.forEach((p, j) => {
+			const r = indexResults[j];
+			if (!r) {
+				results[p.i] = {
+					path: p.afsPath,
+					success: false,
+					error: "index batch returned no result"
+				};
+				return;
+			}
+			if (r.conflict) {
+				results[p.i] = this.batchConflictFailure(p.afsPath, r.conflict);
+				return;
+			}
+			if (r.error) {
+				results[p.i] = {
+					path: p.afsPath,
+					success: false,
+					error: r.error
+				};
+				return;
+			}
+			if (r.skipped) {
+				skipped.push(p);
+				return;
+			}
+			written.push({
+				p,
+				oldCid: r.oldCid,
+				liveSeq: r.liveSeq
+			});
+		});
+		if (this.gcQueue) {
+			const reReferenced = [...new Set([...written.map((w) => w.p.cid), ...skipped.map((s) => s.cid)])];
+			if (reReferenced.length > 0) if (this.gcQueue.removeMany) await this.gcQueue.removeMany(reReferenced);
+			else for (const cid of reReferenced) await this.gcQueue.remove(cid);
+			const replaced = [...new Set(written.filter((w) => w.oldCid && w.oldCid !== w.p.cid).map((w) => w.oldCid))];
+			if (replaced.length > 0) await this.gcQueue.enqueue(replaced);
+		}
+		for (const w of written) try {
+			await require_share_hook.applyShareWriteHook({
+				...this.shareHookArgs(w.p.afsPath, w.p.treePath),
+				bytes: new Uint8Array(0),
+				cid: w.p.cid,
+				resolver: this.shareResolver,
+				phase: "post-io"
+			});
+		} catch {}
+		const commitOk = (p, liveSeq) => ({
+			status: 200,
+			ok: true,
+			data: {
+				path: p.afsPath,
+				meta: {
+					cid: p.cid,
+					liveSeq: liveSeq != null ? String(liveSeq) : void 0
+				}
+			}
+		});
+		for (const w of written) results[w.p.i] = commitOk(w.p, w.liveSeq);
+		for (const s of skipped) {
+			let liveSeq;
+			if (this.treeIndex.getPrefixWatermark) liveSeq = await this.treeIndex.getPrefixWatermark(s.treePath) ?? void 0;
+			results[s.i] = commitOk(s, liveSeq);
+		}
+		const committedPaths = [...written, ...skipped.map((s) => ({ p: s }))].map((w) => ({
+			path: w.p.afsPath,
+			status: "committed"
+		}));
+		if (committedPaths.length > 0) await this.uploadSessionStore?.markEntries(sessionId, committedPaths);
+		const succeeded = results.filter((r) => r?.ok === true).length;
+		return {
+			ok: true,
+			results,
+			succeeded,
+			failed: results.length - succeeded
+		};
+	}
+	/**
+	* Native batch delete — same merge without the R2 leg: ONE preread → GC
+	* enqueue (before delete, single-op ordering) → ONE atomic index batch →
+	* share delete hooks. FILE entries only (no directory fallback — sync
+	* never dir-deletes; a dir path fails per entry with 404).
+	*/
+	async batchDelete(entries, _options) {
+		const results = new Array(entries.length);
+		const prepared = [];
+		for (let i = 0; i < entries.length; i++) {
+			const entry = entries[i];
+			const afsPath = (0, ufo.joinURL)("/", entry.path);
+			if (this.isVirtualPath(afsPath) || require_share_declaration.isShareReservedPath(afsPath)) {
+				results[i] = {
+					path: afsPath,
+					success: false,
+					error: `Forbidden at ${afsPath}: virtual_path`,
+					code: "AFS_FORBIDDEN"
+				};
+				continue;
+			}
+			const deleteMeta = entry.options?.meta;
+			prepared.push({
+				i,
+				afsPath,
+				treePath: this.treePath(afsPath),
+				deviceId: typeof deleteMeta?.deviceId === "string" && deleteMeta.deviceId ? deleteMeta.deviceId : this.deviceId,
+				...typeof deleteMeta?.mtime === "number" ? { mtime: deleteMeta.mtime } : {},
+				...typeof deleteMeta?.ifMatch === "string" ? { ifMatch: deleteMeta.ifMatch } : {}
+			});
+		}
+		const preread = await this.batchPreread(prepared.map((p) => p.treePath));
+		const live = [];
+		for (const p of prepared) {
+			const existing = preread.get(p.treePath) ?? null;
+			if (p.ifMatch !== void 0 && (!existing || existing.cid !== p.ifMatch)) {
+				results[p.i] = this.batchConflictFailure(p.afsPath, {
+					currentCid: existing?.cid ?? null,
+					currentMtime: existing?.mtime ?? null,
+					currentDeviceId: null
+				});
+				continue;
+			}
+			if (!existing) {
+				results[p.i] = {
+					path: p.afsPath,
+					success: false,
+					error: `Path not found: ${p.afsPath}`,
+					code: "AFS_NOT_FOUND"
+				};
+				continue;
+			}
+			live.push(p);
+		}
+		if (this.gcQueue && live.length > 0) {
+			const cids = [...new Set(live.map((p) => (preread.get(p.treePath) ?? null)?.cid).filter(Boolean))];
+			if (cids.length > 0) await this.gcQueue.enqueue(cids);
+		}
+		if (live.length > 0) {
+			const batchEntries = live.map((p) => ({
+				path: p.treePath,
+				opts: {
+					deviceId: p.deviceId,
+					...p.mtime !== void 0 ? { mtime: p.mtime } : {}
+				}
+			}));
+			let indexResults;
+			try {
+				indexResults = this.treeIndex.batchDeleteEntries ? await this.treeIndex.batchDeleteEntries(batchEntries, { preread }) : await require_tree_index.loopBatchDeleteEntries(this.treeIndex, batchEntries, { preread });
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				for (const p of live) results[p.i] = {
+					path: p.afsPath,
+					success: false,
+					error: message
+				};
+				const succeededEarly = results.filter((r) => r?.success).length;
+				return {
+					results,
+					succeeded: succeededEarly,
+					failed: results.length - succeededEarly
+				};
+			}
+			for (let j = 0; j < live.length; j++) {
+				const p = live[j];
+				const r = indexResults[j];
+				if (!r || r.error || r.conflict || r.notFound) {
+					results[p.i] = r?.conflict ? this.batchConflictFailure(p.afsPath, r.conflict) : {
+						path: p.afsPath,
+						success: false,
+						error: r?.error ?? `Path not found: ${p.afsPath}`,
+						...r?.notFound ? { code: "AFS_NOT_FOUND" } : {}
+					};
+					continue;
+				}
+				await require_share_hook.applyShareDeleteHook({
+					...this.shareHookArgs(p.afsPath, p.treePath),
+					resolver: this.shareResolver
+				});
+				if (p.afsPath.endsWith(".ash")) this.emit({
+					type: _aigne_afs.SCRIPT_EVENT_TYPES.UNREGISTERED,
+					path: p.afsPath,
+					data: { runtime: "ash" }
+				});
+				results[p.i] = {
+					path: p.afsPath,
+					success: true
+				};
+			}
+		}
+		const succeeded = results.filter((r) => r?.success).length;
+		return {
+			results,
+			succeeded,
+			failed: results.length - succeeded
+		};
+	}
+	async statHandler(ctx) {
+		const afsPath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		if (afsPath === "/") return { data: {
+			id: "/",
+			path: "/",
+			meta: {
+				kind: "did-space:root",
+				childrenCount: await this.treeIndex.countChildren(this.treeListPrefix("/"))
+			}
+		} };
+		const entry = await this.treeIndex.get(this.treePath(afsPath), { includeContent: false });
+		if (entry) return { data: {
+			id: afsPath.split("/").pop() || afsPath,
+			path: afsPath,
+			meta: {
+				kind: "did-space:file",
+				size: entry.size,
+				cid: entry.cid,
+				mimeType: entry.mimeType,
+				version: entry.cid
+			},
+			createdAt: new Date(entry.ctime),
+			updatedAt: new Date(entry.mtime)
+		} };
+		if (await this.isDirectory(afsPath)) {
+			const prefix = this.treeListPrefix(afsPath);
+			const meta = {
+				kind: "did-space:directory",
+				childrenCount: await this.treeIndex.countChildren(prefix)
+			};
+			if (this.treeIndex.getPrefixWatermark) {
+				const version = await this.treeIndex.getPrefixWatermark(prefix);
+				if (version != null) meta.liveSeq = String(version);
+			}
+			const stat = {
+				id: afsPath.split("/").pop() || afsPath,
+				path: afsPath,
+				meta
+			};
+			const dirTimes = await this.treeIndex.getDirTimes?.(prefix);
+			if (dirTimes) {
+				stat.createdAt = new Date(dirTimes.ctime);
+				stat.updatedAt = new Date(dirTimes.mtime);
+			}
+			return { data: stat };
+		}
+		throw new _aigne_afs.AFSNotFoundError(afsPath);
+	}
+	async searchHandler(ctx, query, options) {
+		const afsPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const pattern = query || "";
+		const limit = options?.limit || 50;
+		if (!pattern) return {
+			data: [],
+			total: 0
+		};
+		const prefix = this.treeListPrefix(afsPath);
+		const results = [];
+		let cursor;
+		const searchQuery = pattern.toLowerCase();
+		do {
+			const listResult = await this.treeIndex.list(prefix, {
+				limit: LIST_MAX_LIMIT,
+				cursor
+			});
+			for (const treeListEntry of listResult.entries) {
+				if (results.length >= limit) break;
+				const path = `/${treeListEntry.path}`;
+				if ((path.split("/").pop() || "").toLowerCase().includes(searchQuery)) {
+					results.push(this.buildEntry(path, {}));
+					continue;
+				}
+				const treeEntry = await this.treeIndex.get(treeListEntry.path, { includeContent: false });
+				if (treeEntry) {
+					if (!(0, _aigne_afs_provider_utils.isTextMime)(treeEntry.mimeType)) continue;
+					const obj = await this.objectStore.get(this.objectKey(treeEntry.cid));
+					if (obj) {
+						const content = await obj.text();
+						if (content.toLowerCase().includes(searchQuery)) results.push(this.buildEntry(path, { content }));
+					}
+				}
+			}
+			cursor = listResult.hasMore ? listResult.cursor : void 0;
+		} while (cursor && results.length < limit);
+		return {
+			data: results,
+			total: results.length
+		};
+	}
+	async explainHandler(ctx) {
+		const afsPath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		const lines = [];
+		lines.push(`# DID Space: ${afsPath}`);
+		lines.push("");
+		if (afsPath === "/") {
+			lines.push(`DID: ${this.did}`);
+			lines.push("");
+			lines.push(this.description || "DID-scoped persistent storage with CID-based deduplication");
+			lines.push("");
+			lines.push("## Operations");
+			lines.push("- `list /` — List root files and directories");
+			lines.push("- `read /{path}` — Read file content");
+			lines.push("- `write /{path}` — Write file (content-addressed dedup)");
+			lines.push("- `delete /{path}` — Delete file entry (lazy GC)");
+		} else {
+			const entry = await this.treeIndex.get(this.treePath(afsPath), { includeContent: false });
+			if (entry) {
+				lines.push(`DID: ${this.did}`);
+				lines.push(`Path: ${afsPath}`);
+				lines.push(`Size: ${entry.size} bytes`);
+				lines.push(`CID: ${entry.cid}`);
+				lines.push(`MIME: ${entry.mimeType ?? "unknown"}`);
+				lines.push(`Created: ${new Date(entry.ctime).toISOString()}`);
+				lines.push(`Modified: ${new Date(entry.mtime).toISOString()}`);
+			} else if (await this.isDirectory(afsPath)) {
+				lines.push(`DID: ${this.did}`);
+				lines.push(`Virtual directory: ${afsPath}`);
+				lines.push("Use `list` to see contents.");
+			} else lines.push("Path not found.");
+		}
+		return {
+			format: "markdown",
+			content: lines.join("\n")
+		};
+	}
+	/**
+	* Write content to the provider, bypassing D4 virtual path protection.
+	* Stores content to objectStore and treeIndex with the given deviceId.
+	*/
+	async internalWrite(afsPath, opts) {
+		if (require_share_declaration.isShareReservedPath(afsPath)) throw new _aigne_afs.AFSForbiddenError(afsPath, "share-path-reserved");
+		const { content, deviceId, mtime, mimeType: explicitMimeType, metadata } = opts;
+		let bytes;
+		let storeValue;
+		if (content instanceof Uint8Array) {
+			bytes = content;
+			storeValue = bytes.buffer;
+		} else {
+			bytes = new Uint8Array(content);
+			storeValue = bytes.buffer;
+		}
+		const cid = await require_cid.computeCID(bytes);
+		const objKey = this.objectKey(cid);
+		const treePath = this.treePath(afsPath);
+		await require_share_hook.applyShareWriteHook({
+			...this.shareHookArgs(afsPath, treePath),
+			bytes,
+			cid,
+			resolver: this.shareResolver,
+			phase: "pre-io"
+		});
+		if (!await this.objectStore.head(objKey)) await this.objectStore.put(objKey, storeValue);
+		const now = mtime ?? Date.now();
+		const detectedMime = explicitMimeType ?? (0, _aigne_afs_provider_utils.detectMimeType)(afsPath) ?? void 0;
+		const ctime = require_timestamp.resolveCtime(metadata, now);
+		const treeEntry = {
+			cid,
+			size: bytes.length,
+			mtime: now,
+			ctime,
+			mimeType: detectedMime
+		};
+		const appMeta = extractApplicationMeta(metadata);
+		if (appMeta) treeEntry.metadata = appMeta;
+		const inlineText = require_inline_content.decodeInlineText(bytes, detectedMime);
+		if (inlineText !== null) treeEntry.content = inlineText;
+		const { oldCid } = await this.treeIndex.put(treePath, treeEntry, { deviceId });
+		if (this.gcQueue) {
+			await this.gcQueue.remove(cid);
+			if (oldCid && oldCid !== cid) await this.gcQueue.enqueue([oldCid]);
+		}
+		await require_share_hook.applyShareWriteHook({
+			...this.shareHookArgs(afsPath, treePath),
+			bytes,
+			cid,
+			resolver: this.shareResolver,
+			phase: "post-io"
+		});
+		await require_blocklet_hook.applyBlockletWriteHook({
+			...this.blockletHookArgs(afsPath, treePath),
+			bytes,
+			resolver: this.blockletResolver
+		});
+		return oldCid === void 0 ? { cid } : {
+			cid,
+			oldCid
+		};
+	}
+	/**
+	* Delete a file from the provider, bypassing D4 virtual path protection.
+	*/
+	async internalDelete(afsPath, opts) {
+		if (require_share_declaration.isShareReservedPath(afsPath)) throw new _aigne_afs.AFSForbiddenError(afsPath, "share-path-reserved");
+		const treePath = this.treePath(afsPath);
+		const entry = await this.treeIndex.get(treePath, { includeContent: false });
+		if (!entry) return { deleted: false };
+		await this.gcQueue?.enqueue([entry.cid]);
+		await this.treeIndex.delete(treePath, { deviceId: opts.deviceId });
+		await require_share_hook.applyShareDeleteHook({
+			...this.shareHookArgs(afsPath, treePath),
+			resolver: this.shareResolver
+		});
+		await require_blocklet_hook.applyBlockletDeleteHook({
+			...this.blockletHookArgs(afsPath, treePath),
+			resolver: this.blockletResolver
+		});
+		return { deleted: true };
+	}
+	capabilities() {
+		return {
+			schemaVersion: 1,
+			provider: this.name,
+			tools: [],
+			actions: [],
+			operations: this.getOperationsDeclaration()
+		};
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/:path*")], DIDSpaceProvider.prototype, "readMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/:path*", { handleDepth: true })], DIDSpaceProvider.prototype, "listHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/.meta/.capabilities")], DIDSpaceProvider.prototype, "readCapabilities", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/:path*")], DIDSpaceProvider.prototype, "readHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/:path*")], DIDSpaceProvider.prototype, "writeHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Delete)("/:path*")], DIDSpaceProvider.prototype, "deleteHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/")], DIDSpaceProvider.prototype, "listObjectPlaneActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "prepare-upload", "Reserve an upload session + (CF) mint exact-key checksum-pinned PUT grants", { effect: "write" })], DIDSpaceProvider.prototype, "execPrepareUpload", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "prepare-download", "Mint exact-key short-TTL presigned GET grants for view-referenced objects", { effect: "write" })], DIDSpaceProvider.prototype, "execPrepareDownload", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "commit-upload", "Commit uploaded objects' metadata (trust existence, 0 R2 subrequests)", { effect: "write" })], DIDSpaceProvider.prototype, "execCommitUpload", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "abort-upload", "Abort an upload session; staged objects become GC candidates", { effect: "write" })], DIDSpaceProvider.prototype, "execAbortUpload", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/:path*")], DIDSpaceProvider.prototype, "statHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/:path*")], DIDSpaceProvider.prototype, "searchHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/:path*")], DIDSpaceProvider.prototype, "explainHandler", null);
+
+//#endregion
+exports.AFS_IFMATCH_ABSENT = require_upload_actions.AFS_IFMATCH_ABSENT;
+exports.BLOCKLET_PUBLISH_MARKER = require_blocklet_hook.BLOCKLET_PUBLISH_MARKER;
+exports.BatchOverBudgetError = require_remote_afs.BatchOverBudgetError;
+exports.BatchUnsupportedError = require_remote_afs.BatchUnsupportedError;
+exports.CHANGELOG_DDL = require_changelog_schema.CHANGELOG_DDL;
+exports.CHANGELOG_INDEX_SQL = require_changelog_schema.CHANGELOG_INDEX_SQL;
+exports.CHANGELOG_INSERT_SQL = require_changelog_write.CHANGELOG_INSERT_SQL;
+exports.CHANGELOG_ROW_KIND = require_changelog_schema.CHANGELOG_ROW_KIND;
+exports.CHANGELOG_SCOPE_CID_MIGRATION_SQL = require_changelog_schema.CHANGELOG_SCOPE_CID_MIGRATION_SQL;
+exports.CHANGELOG_TABLE_SQL = require_changelog_schema.CHANGELOG_TABLE_SQL;
+exports.CHANGELOG_WIRE_EXTRA_FIELDS = require_changelog_schema.CHANGELOG_WIRE_EXTRA_FIELDS;
+exports.CachingObjectStore = require_cid_byte_cache.CachingObjectStore;
+exports.CidByteCache = require_cid_byte_cache.CidByteCache;
+exports.ConflictResolutionError = require_sync_engine.ConflictResolutionError;
+exports.CurrentObjectMissingError = require_sync_engine.CurrentObjectMissingError;
+exports.D1GCQueue = require_d1_gc_queue.D1GCQueue;
+exports.D1ResolveStore = require_d1_resolve_store.D1ResolveStore;
+exports.D1ShareReconciler = require_d1_share_store.D1ShareReconciler;
+exports.D1ShareStore = require_d1_share_store.D1ShareStore;
+exports.D1TreeIndex = require_d1_tree_index.D1TreeIndex;
+exports.D1UploadSessionStore = require_upload_session_store.D1UploadSessionStore;
+exports.D1VersionedScopeBackend = require_versioned_content_backends.D1VersionedScopeBackend;
+exports.D1_DID_SPACE_SCHEMA_SQL = require_d1_schema.D1_DID_SPACE_SCHEMA_SQL;
+exports.DEFAULT_GC_GRACE_MS = require_run_gc.DEFAULT_GC_GRACE_MS;
+exports.DEFAULT_INLINE_THRESHOLD = require_inline_content.DEFAULT_INLINE_THRESHOLD;
+exports.DEVICE_ID_FORMAT_RE = require_sync_state.DEVICE_ID_FORMAT_RE;
+exports.DEVICE_SYNC_STATE_INDEX_SQL = require_changelog_schema.DEVICE_SYNC_STATE_INDEX_SQL;
+exports.DEVICE_SYNC_STATE_TABLE_SQL = require_changelog_schema.DEVICE_SYNC_STATE_TABLE_SQL;
+exports.DIDSpaceBlockletDataBackend = require_data_backend.DIDSpaceBlockletDataBackend;
+exports.DIDSpaceClient = require_client.DIDSpaceClient;
+exports.DIDSpaceProvider = DIDSpaceProvider;
+exports.DIDSpaceResolver = require_resolve.DIDSpaceResolver;
+exports.DIRTY_PATH_DDL = require_dirty_path_schema.DIRTY_PATH_DDL;
+exports.DIRTY_PATH_INDEX_SQL = require_dirty_path_schema.DIRTY_PATH_INDEX_SQL;
+exports.DIRTY_PATH_TABLE_SQL = require_dirty_path_schema.DIRTY_PATH_TABLE_SQL;
+exports.DIRTY_PATH_TRIGGER_SQL = require_dirty_path_schema.DIRTY_PATH_TRIGGER_SQL;
+exports.ENTRIES_CONTENT_TYPE_COLUMN_SQL = require_d1_schema.ENTRIES_CONTENT_TYPE_COLUMN_SQL;
+exports.ENTRIES_CONTENT_TYPE_INDEX_DROP_SQL = require_d1_schema.ENTRIES_CONTENT_TYPE_INDEX_DROP_SQL;
+exports.ENTRIES_CONTENT_TYPE_INDEX_SQL = require_d1_schema.ENTRIES_CONTENT_TYPE_INDEX_SQL;
+exports.ENTRIES_DEDUP_INDEX_SQL = require_d1_schema.ENTRIES_DEDUP_INDEX_SQL;
+exports.ENTRIES_DEDUP_KEY_COLUMN_SQL = require_d1_schema.ENTRIES_DEDUP_KEY_COLUMN_SQL;
+exports.ENTRIES_DEDUP_SCOPE_COLUMN_SQL = require_d1_schema.ENTRIES_DEDUP_SCOPE_COLUMN_SQL;
+exports.ENTRIES_INDEX_SQL = require_d1_schema.ENTRIES_INDEX_SQL;
+exports.ENTRIES_INLINE_CONTENT_COLUMN_SQL = require_d1_schema.ENTRIES_INLINE_CONTENT_COLUMN_SQL;
+exports.ENTRIES_METADATA_COLUMN_SQL = require_d1_schema.ENTRIES_METADATA_COLUMN_SQL;
+exports.ENTRIES_TABLE_SQL = require_d1_schema.ENTRIES_TABLE_SQL;
+exports.GC_QUEUE_INDEX_SQL = require_d1_schema.GC_QUEUE_INDEX_SQL;
+exports.GC_QUEUE_TABLE_SQL = require_d1_schema.GC_QUEUE_TABLE_SQL;
+exports.HttpTransport = require_http.HttpTransport;
+exports.INGEST_DEVICE_ID = require_inline_content.INGEST_DEVICE_ID;
+exports.INLINE_CONTENT_HARD_CAP = require_inline_content.INLINE_CONTENT_HARD_CAP;
+exports.LOCAL_CHANGELOG_DEFAULT_LIMIT = require_local_changelog.LOCAL_CHANGELOG_DEFAULT_LIMIT;
+exports.LOCAL_CHANGELOG_MAX_LIMIT = require_local_changelog.LOCAL_CHANGELOG_MAX_LIMIT;
+exports.LibsqlVersionedScopeBackend = require_versioned_content_backends.LibsqlVersionedScopeBackend;
+exports.LocalChangelog = require_local_changelog.LocalChangelog;
+exports.MANIFEST_FILE_KIND = require_changelog_schema.MANIFEST_FILE_KIND;
+exports.MANIFEST_WIRE_EXTRA_FIELDS = require_changelog_schema.MANIFEST_WIRE_EXTRA_FIELDS;
+exports.MAX_DEVICE_ID_BYTES = require_changelog_write.MAX_DEVICE_ID_BYTES;
+exports.MAX_ENTRIES_PER_SCOPE = require_d1_tree_index.MAX_ENTRIES_PER_SCOPE;
+exports.MemoryGcQueue = require_memory_gc_queue.MemoryGcQueue;
+exports.MemoryTreeIndex = require_memory_tree_index.MemoryTreeIndex;
+exports.MemoryVersionedScopeBackend = require_versioned_content_backends.MemoryVersionedScopeBackend;
+exports.PREFIX_WATERMARK_TABLE_SQL = require_changelog_schema.PREFIX_WATERMARK_TABLE_SQL;
+exports.PRESIGN_MAX_EXPIRES_SEC = require_presign_signer.PRESIGN_MAX_EXPIRES_SEC;
+exports.PULL_BATCH_LIMIT = require_sync_engine.PULL_BATCH_LIMIT;
+exports.PULL_FETCH_CONCURRENCY = require_sync_engine.PULL_FETCH_CONCURRENCY;
+exports.PUSH_BATCH_LIMIT = require_sync_engine.PUSH_BATCH_LIMIT;
+exports.PUSH_PROGRESS_FLUSH_INTERVAL = require_sync_engine.PUSH_PROGRESS_FLUSH_INTERVAL;
+exports.PrefixedTreeIndex = require_prefixed_tree_index.PrefixedTreeIndex;
+exports.RESOLVE_ENTRIES_INDEX_SQL = require_d1_schema.RESOLVE_ENTRIES_INDEX_SQL;
+exports.RESOLVE_ENTRIES_TABLE_SQL = require_d1_schema.RESOLVE_ENTRIES_TABLE_SQL;
+exports.RpcUserSpaceAFS = require_remote_afs.RpcUserSpaceAFS;
+exports.SCOPE_META_FILE_COUNT_BACKFILL_SQL = require_changelog_schema.SCOPE_META_FILE_COUNT_BACKFILL_SQL;
+exports.SCOPE_META_FILE_COUNT_DELETE_ONE_SQL = require_changelog_schema.SCOPE_META_FILE_COUNT_DELETE_ONE_SQL;
+exports.SCOPE_META_FILE_COUNT_DELETE_RANGE_SQL = require_changelog_schema.SCOPE_META_FILE_COUNT_DELETE_RANGE_SQL;
+exports.SCOPE_META_FILE_COUNT_TRIGGER_SQL = require_changelog_schema.SCOPE_META_FILE_COUNT_TRIGGER_SQL;
+exports.SCOPE_META_INDEX_SQL = require_changelog_schema.SCOPE_META_INDEX_SQL;
+exports.SCOPE_META_TABLE_SQL = require_changelog_schema.SCOPE_META_TABLE_SQL;
+exports.SCOPE_META_TOTAL_BYTES_BACKFILL_SQL = require_changelog_schema.SCOPE_META_TOTAL_BYTES_BACKFILL_SQL;
+exports.SCOPE_META_TOTAL_BYTES_COLUMN_SQL = require_changelog_schema.SCOPE_META_TOTAL_BYTES_COLUMN_SQL;
+exports.SCOPE_META_TOTAL_BYTES_TRIGGER_SQL = require_changelog_schema.SCOPE_META_TOTAL_BYTES_TRIGGER_SQL;
+exports.SHARES_INDEX_SQL = require_d1_schema.SHARES_INDEX_SQL;
+exports.SHARES_TABLE_SQL = require_d1_schema.SHARES_TABLE_SQL;
+exports.SYNC_STATE_DDL = require_changelog_schema.SYNC_STATE_DDL;
+exports.SYNC_STATE_INDEX_SQL = require_changelog_schema.SYNC_STATE_INDEX_SQL;
+exports.SYNC_STATE_KEYS = require_sync_state.SYNC_STATE_KEYS;
+exports.SYNC_STATE_TABLE_SQL = require_changelog_schema.SYNC_STATE_TABLE_SQL;
+exports.SYNC_WALL_CLOCK_BUDGET_MS = require_sync_engine.SYNC_WALL_CLOCK_BUDGET_MS;
+exports.ShareResolver = require_share_resolve.ShareResolver;
+exports.SqliteGcQueue = require_sqlite_gc_queue.SqliteGcQueue;
+exports.SqliteResolveStore = require_sqlite_resolve_store.SqliteResolveStore;
+exports.SqliteShareStore = require_sqlite_share_store.SqliteShareStore;
+exports.SqliteUploadSessionStore = require_upload_session_store.SqliteUploadSessionStore;
+exports.StaticReadonlyTransport = require_static.StaticReadonlyTransport;
+exports.SyncEngine = require_sync_engine.SyncEngine;
+exports.SyncStateStore = require_sync_state.SyncStateStore;
+exports.UPLOAD_SESSIONS_INDEX_SQL = require_d1_schema.UPLOAD_SESSIONS_INDEX_SQL;
+exports.UPLOAD_SESSIONS_TABLE_SQL = require_d1_schema.UPLOAD_SESSIONS_TABLE_SQL;
+exports.UPLOAD_SESSION_ENTRIES_TABLE_SQL = require_d1_schema.UPLOAD_SESSION_ENTRIES_TABLE_SQL;
+exports.UPLOAD_SESSION_TTL_MS = require_upload_session_store.UPLOAD_SESSION_TTL_MS;
+exports.VERSIONED_SCOPES_INDEX_SQL = require_d1_schema.VERSIONED_SCOPES_INDEX_SQL;
+exports.VERSIONED_SCOPES_TABLE_SQL = require_d1_schema.VERSIONED_SCOPES_TABLE_SQL;
+exports.VersionedContentIndex = require_versioned_content_index.VersionedContentIndex;
+exports.VersionedContentStore = require_versioned_content_store.VersionedContentStore;
+exports.WsTransport = require_ws.WsTransport;
+exports.ancestorDirs = require_d1_tree_index.ancestorDirs;
+exports.applyDirtyUpsert = require_dirty_path_queue.applyDirtyUpsert;
+exports.assertInlineThreshold = require_inline_content.assertInlineThreshold;
+exports.assertValidCid = require_object_key.assertValidCid;
+exports.attachMetadataContext = require_afs_metadata_context.attachMetadataContext;
+exports.buildChangelogBinds = require_changelog_write.buildChangelogBinds;
+exports.buildD1MigrationSql = require_scope_migration.buildD1MigrationSql;
+exports.buildKeysetCursor = require_tree_index.buildKeysetCursor;
+exports.buildManifest = require_rsync.buildManifest;
+exports.buildOrderedQueryParts = require_tree_index.buildOrderedQueryParts;
+exports.cidToChecksumSha256 = require_cid.cidToChecksumSha256;
+exports.classifyMissingObject = require_sync_engine.classifyMissingObject;
+exports.classifyScopes = require_scope_migration.classifyScopes;
+exports.compareTreeSortValues = require_tree_index.compareTreeSortValues;
+exports.computeCID = require_cid.computeCID;
+exports.computeDiff = require_rsync.computeDiff;
+exports.connectDIDSpace = require_client.connectDIDSpace;
+exports.createWsTransport = require_ws.createWsTransport;
+exports.decodeInlineText = require_inline_content.decodeInlineText;
+exports.decodeScopeHmacSecret = require_scope_id.decodeScopeHmacSecret;
+exports.defaultAppState = require_sync_state.defaultAppState;
+exports.deriveScope = require_scope_id.deriveScope;
+exports.detachMetadataContext = require_afs_metadata_context.detachMetadataContext;
+Object.defineProperty(exports, 'detectMimeType', {
+  enumerable: true,
+  get: function () {
+    return _aigne_afs_provider_utils.detectMimeType;
+  }
+});
+exports.fetchRemoteManifest = require_rsync.fetchRemoteManifest;
+exports.generateDesktopDeviceId = require_sync_state.generateDesktopDeviceId;
+exports.getMetadataContext = require_afs_metadata_context.getMetadataContext;
+exports.isPlainDidScope = require_scope_id.isPlainDidScope;
+exports.isShareDeclarationPath = require_share_declaration.isShareDeclarationPath;
+Object.defineProperty(exports, 'isTextMime', {
+  enumerable: true,
+  get: function () {
+    return _aigne_afs_provider_utils.isTextMime;
+  }
+});
+exports.isValidDeviceId = require_sync_state.isValidDeviceId;
+exports.keysetAfter = require_tree_index.keysetAfter;
+exports.migrateD1Scopes = require_scope_migration.migrateD1Scopes;
+exports.nameOf = require_d1_tree_index.nameOf;
+exports.normalizeDdl = require_changelog_schema.normalizeDdl;
+exports.normalizeId = require_did_utils.normalizeId;
+exports.normalizeItemUrl = require_url_normalize.normalizeItemUrl;
+exports.objectKeyForCid = require_object_key.objectKeyForCid;
+exports.openDaemonShareStore = require_sqlite_share_store.openDaemonShareStore;
+exports.parentOf = require_d1_tree_index.parentOf;
+exports.parseChangelogEntry = require_changelog_schema.parseChangelogEntry;
+exports.parseManifestEntry = require_changelog_schema.parseManifestEntry;
+exports.parseSyncStatus = require_sync_state.parseSyncStatus;
+exports.parseTreeCursor = require_tree_index.parseTreeCursor;
+exports.prefixRange = require_prefix_range.prefixRange;
+exports.referencedAnywhereD1 = require_reference_check.referencedAnywhereD1;
+exports.referencedAnywhereLibsql = require_reference_check.referencedAnywhereLibsql;
+exports.resolveVersionToken = require_versioned_scope.resolveVersionToken;
+exports.rowToEntry = require_share_store.rowToEntry;
+exports.runGc = require_run_gc.runGc;
+exports.runWithConcurrency = require_rsync.runWithConcurrency;
+exports.serializeChangelogEntry = require_changelog_schema.serializeChangelogEntry;
+exports.serializeManifestEntry = require_changelog_schema.serializeManifestEntry;
+exports.serializeSyncStatus = require_sync_state.serializeSyncStatus;
+exports.serveShare = require_share_serve.serveShare;
+exports.syncDIDSpace = require_rsync.syncDIDSpace;
+exports.validateDeviceId = require_changelog_write.validateDeviceId;
+exports.validateId = require_did_utils.validateId;
+exports.versionedScope = require_versioned_scope.versionedScope;
+exports.versionedScopeGroup = require_versioned_scope.versionedScopeGroup;