@aigne/aos 0.2.0-beta

package/dist/http/afs-rpc.mjs

@@ -0,0 +1,729 @@
+import { createAfsRequestContext } from "./request-context.mjs";
+import { BATCH_LIMITS_CF, WIRE_ERROR_CODES, encodeContentBase64, readBoundedBody, validateAndDecodeWrite, validateBatchBody } from "./afs-rpc-wire.mjs";
+import { csrfRejection } from "./csrf.mjs";
+import { execIngestFacade, injectIngestFacadeList, isIngestFacadePath } from "./ingest-facade.mjs";
+import { UPLOAD_LIMIT_DEFAULTS, logEnabled, makeNsLog, sanitizeAfsPath } from "@aigne/afs";
+import { time, timeMeta } from "@aigne/afs-timing";
+
+//#region src/http/afs-rpc.ts
+/**
+* Blocklet-aware HTTP RPC handler for stateless AFS read operations.
+*
+* Why: AUP pages that just need `afs.list()` / `afs.read()` open a
+* WebSocket otherwise — pinning a Durable Object on Cloudflare, or holding a
+* WS handle on a Node daemon — even though the call is stateless. This
+* handler runs purely in the HTTP request path; no WebSocket required.
+*
+* Distinct from `createAFSRestHandler` (which exposes the global AFS
+* unscoped at `/afs/*`): this handler resolves the caller's blocklet from
+* the request and returns paths that look like the blocklet's root to the
+* client. It mirrors `AUPSessionDO.onSessionStart`'s `ProjectionProvider`
+* setup but for HTTP, not WS.
+*
+* Scope: `read`, `list`, `stat`, `search`, `exec` (open to any resolved
+* caller), plus `write`/`delete` (Phase 4) gated by an auth + allowlist layer —
+* a verified Bearer caller writing only their own `/user/**` data path.
+*
+* Blocklet resolution priority:
+*   1. options.resolveHostAlias(host)         — caller-provided alias map
+*                                                (e.g. CF worker's patternCache
+*                                                from `.afs/aliases.json` —
+*                                                resolves `explorer.arcblock.io`
+*                                                → `chain-explorer` when the
+*                                                first label is NOT the
+*                                                blocklet id)
+*   2. extractBlockletFromHost(host)          — e.g. `showcase.afsd.io`
+*                                                → `"showcase"` when first
+*                                                label IS the blocklet id
+*   3. body.blocklet / ?blocklet=             — untrusted browser hint fallback
+*   4. options.fallbackBlocklet
+*/
+const READ_ONLY_OPS = new Set([
+	"read",
+	"list",
+	"stat",
+	"search",
+	"exec",
+	"batchRead"
+]);
+const log = makeNsLog("aos:rpc");
+/**
+* Mutating ops (Phase 4 + afs-rpc-batch P1). Gated by an extra auth +
+* allowlist layer on top of the read pipeline: a verified BEARER caller
+* writing only their own `/user/**` data path. Batch ops run the SAME gate
+* per entry — any entry failing it rejects the whole envelope (fail-closed).
+*/
+const MUTATING_OPS = new Set([
+	"write",
+	"delete",
+	"batchWrite",
+	"batchDelete"
+]);
+/** Batch wire ops (afs-rpc-batch P1): entries carry paths; no top-level path. */
+const BATCH_OPS = new Set([
+	"batchRead",
+	"batchWrite",
+	"batchDelete"
+]);
+const RPC_BLOCKLET_HINT_PRIORITY = {
+	explicitPriority: "fallback",
+	queryPriority: "fallback"
+};
+const JSON_HEADERS = { "Content-Type": "application/json; charset=utf-8" };
+function jsonResponse(status, body) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { ...JSON_HEADERS }
+	});
+}
+function fail(status, error) {
+	return jsonResponse(status, {
+		ok: false,
+		error
+	});
+}
+/**
+* Lift a wire write entry's top-level `meta` onto `AFSWriteEntryPayload.meta`
+* so metadata-aware providers (did-space) index application fields like
+* `createdAt` / `updatedAt`. Sync provenance stays in `options.meta` and is
+* untouched here. Mirrors `execRootWriteAction`'s `args.meta` forwarding
+* (afs-root-handlers) for the RPC write/batchWrite ingress, which previously
+* dropped `meta` entirely. Returns `undefined` for absent/non-object meta.
+*/
+function wireMeta(meta) {
+	return meta !== null && typeof meta === "object" ? meta : void 0;
+}
+/**
+* Map AFS-layer errors onto sensible HTTP status codes.
+* Unknown classes fall through to 500; the message still surfaces in
+* the response body for debugging.
+* Exported for the raw endpoint (afs-raw.ts) — one mapping, not two.
+*/
+/**
+* Stable AFS error code → HTTP status (afs-rpc-batch P2). One map serves both
+* thrown errors ({@link statusForError}) and the structured `code` slot on
+* core batch entry results — the two derivations must never drift.
+*/
+const STATUS_BY_CODE = {
+	AFS_CONFLICT: 409,
+	AFS_NOT_FOUND: 404,
+	AFS_ACTION_NOT_FOUND: 404,
+	ENOENT: 404,
+	ENOTDIR: 404,
+	AFS_VALIDATION_ERROR: 400,
+	AFS_ACCESS_MODE: 405,
+	AFS_READONLY: 405,
+	AFS_ACCESS_DENIED: 403,
+	AFS_FORBIDDEN: 403,
+	AFS_AUTH_REQUIRED: 401,
+	AFS_PAYMENT_REQUIRED: 402,
+	AFS_UNSUPPORTED: 501
+};
+/** HTTP status for a structured per-entry error code (500 when unknown). */
+function statusForCode(code) {
+	return code && STATUS_BY_CODE[code] || 500;
+}
+function statusForError(err) {
+	const byCode = STATUS_BY_CODE[err?.code ?? ""];
+	if (byCode) return byCode;
+	const name = err?.name ?? "";
+	if (name === "AFSAuthRequiredError") return 401;
+	if (name === "AFSPaymentRequiredError") return 402;
+	if (name === "AFSConflictError") return 409;
+	if (name === "AFSForbiddenError" || name === "AFSPermissionError") return 403;
+	if (name === "AFSNotFoundError") return 404;
+	if (name === "AFSValidationError") return 400;
+	if (name === "AFSAccessModeError") return 405;
+	if (name === "AFSReadonlyError") return 405;
+	if (name === "AFSUnsupportedError") return 501;
+	const message = errorMessage(err);
+	if (/\b(ENOENT|ENOTDIR):/.test(message)) return 404;
+	return 500;
+}
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* Shape the 409 conflict body fields (wire-contract §7): the opaque
+* current-version triple the client's conflict resolution (LWW) consumes.
+* Single source for the single-op catch branch AND batch per-entry results —
+* the triple must never drift between the two (afs-rpc-batch G3).
+*/
+function enrichConflictBody(err) {
+	const c = err;
+	return {
+		error: errorMessage(err),
+		code: WIRE_ERROR_CODES.conflict,
+		currentCid: typeof c.currentCid === "string" ? c.currentCid : null,
+		currentMtime: typeof c.currentMtime === "number" ? c.currentMtime : null,
+		currentDeviceId: typeof c.currentDeviceId === "string" ? c.currentDeviceId : null
+	};
+}
+/**
+* Map a per-entry failure onto the batch `results[i]` shape — identical to
+* the single-op error body plus the `status` field (design §5.4 isomorphism).
+* `optional` mirrors the single-op soft-miss: 404 → `{status:200, missing}`.
+*/
+function batchEntryError(err, optional) {
+	const status = statusForError(err);
+	const message = errorMessage(err);
+	if (optional === true && status === 404) return {
+		status: 200,
+		ok: false,
+		error: message,
+		missing: true
+	};
+	if (status === 409) return {
+		status: 409,
+		ok: false,
+		...enrichConflictBody(err)
+	};
+	const code = err?.code;
+	return {
+		status,
+		ok: false,
+		error: message,
+		...code ? { code } : {}
+	};
+}
+/**
+* Map a CORE batch entry result onto the wire `results[i]` shape (L2 switch,
+* P2). Field-for-field identical to what the P1 handler loop produced from
+* thrown errors: success → single-op body, conflict → 409 + triple, other
+* failures → status derived from the structured `code`.
+*/
+function wireResultFromCore(r) {
+	if (r.success) return {
+		status: 200,
+		ok: true,
+		data: encodeReadData(r.data)
+	};
+	if (r.conflict) return {
+		status: 409,
+		ok: false,
+		error: r.error ?? "",
+		code: WIRE_ERROR_CODES.conflict,
+		...r.conflict
+	};
+	return {
+		status: statusForCode(r.code),
+		ok: false,
+		error: r.error ?? "",
+		...r.code ? { code: r.code } : {}
+	};
+}
+/** Max write payload (decoded bytes) before a 413. Large-blob bypass (D-A) is
+*  deferred to Phase 6; until then, oversize writes are rejected outright. */
+const MAX_WRITE_BYTES = 16 * 1024 * 1024;
+/**
+* Phase 4 write-surface allowlist: ONLY the caller's own `/user/**` data paths
+* are mutable over afs-rpc. `/user` itself, `/instance/**`, `/space/**`, the
+* blocklet-global root paths, and the `.objects`/`.changelog`/`.shares` virtual
+* namespaces are all rejected (the provider's D4 guard is a second layer).
+*/
+function isAllowedUserDataPath(path) {
+	if (!path.startsWith("/user/")) return false;
+	const segs = path.split("/").filter(Boolean);
+	if (segs.length < 2) return false;
+	return !segs.some((s) => s === ".objects" || s === ".changelog" || s === ".shares");
+}
+/**
+* Authorize a mutating op (Phase 4, P0-1 + P1-1). Returns an error `Response`
+* when the write/delete is NOT permitted, else `null`.
+*
+* Defense in depth (not "trust the client to write /user"):
+*  - authenticated (caller.did present) → else 401
+*  - BEARER auth-source (cookie alone can't drive a write) → else 403 (CSRF)
+*  - non-root blocklet scope (root exposes global topology) → else 403
+*  - path under the caller's own `/user/**` data namespace → else 403
+* The `/user` overlay is keyed by `caller.did`, so a caller can only ever reach
+* its own fragment (structural isolation); `body.blocklet` only selects the app.
+*/
+function checkMutationAllowed(path, caller, scope) {
+	if (!caller || !caller.did) return fail(401, "Authentication required for write/delete");
+	if (caller.authSource !== "bearer") return fail(403, "write/delete require Authorization: Bearer (cookie-only is rejected)");
+	if (scope === "root") return fail(403, "write/delete not allowed on a root-scope blocklet");
+	if (!isAllowedUserDataPath(path)) return fail(403, `write/delete only allowed under /user/** data paths (got '${path}')`);
+	return null;
+}
+/**
+* Wire-contract §5: a `read` whose `content` is raw bytes (e.g. `.objects/{cid}`
+* or any binary file) is base64-encoded with an `encoding` marker so it
+* survives JSON transport. Text/JSON content passes through unchanged. The
+* client (mobile RemoteDIDSpaceAFS) base64-decodes + recomputes the CID.
+*/
+function encodeReadData(data) {
+	if (!data || typeof data !== "object") return data;
+	const c = data.content;
+	if (c instanceof Uint8Array) return {
+		...data,
+		content: encodeContentBase64(c),
+		encoding: "base64"
+	};
+	if (c instanceof ArrayBuffer) return {
+		...data,
+		content: encodeContentBase64(new Uint8Array(c)),
+		encoding: "base64"
+	};
+	return data;
+}
+/**
+* Extract the `{error,code,details}` triple from a provider that resolved with
+* `success:false` (semantic failure, no throw). Buffered and streaming exec
+* MUST format these identically — the cross-phase "流式与 buffered 语义对齐"
+* invariant — so both spread this single source of truth.
+*/
+function execFailureFields(error) {
+	return {
+		error: error?.message || error?.code || "Action failed",
+		code: error?.code,
+		details: error?.details
+	};
+}
+/**
+* NDJSON streaming response for a streaming `exec` (README §3.2). Each output
+* line is one typed envelope:
+*   {"t":"chunk","chunk":{ ...full AFSExecChunk... }}   — per onChunk callback
+*   {"t":"done","data":<final exec result data>}        — exec resolved success
+*   {"t":"error","error":"...","code":"...","details":...}  — failure / reject
+*
+* Wire contract (§3.2): the chunk envelope serializes the WHOLE `AFSExecChunk`
+* (incl. `thoughts` + provider-specific fields) so the transport layer never
+* drops fields — the client typed-surface narrowing happens later, not here.
+*
+* Errors are two-layered (§3.2.1): handler-level errors (CSRF, bad path) are
+* already returned with a real HTTP status BEFORE this is called. Once the
+* stream is open the status is committed to 200, so an `afs.exec()` failure —
+* including a provider that resolves with `success:false` (mirroring the
+* buffered branch) or an effect-gate reject — surfaces as a `{"t":"error"}`
+* line, never as `{"t":"done"}`.
+*/
+function execStreamResponse(afs, path, args, opts, context) {
+	const encoder = new TextEncoder();
+	const { stream: _wireOnlyStream, ...restOpts } = opts;
+	let closed = false;
+	const stream = new ReadableStream({
+		async start(controller) {
+			const enqueue = (line) => {
+				if (closed) return;
+				try {
+					controller.enqueue(encoder.encode(`${JSON.stringify(line)}\n`));
+				} catch {
+					closed = true;
+				}
+			};
+			const execOptions = {
+				...restOpts,
+				context,
+				onChunk: (chunk) => enqueue({
+					t: "chunk",
+					chunk
+				})
+			};
+			try {
+				const r = await time("op", () => afs.exec(path, args, execOptions));
+				if (r.success === false) enqueue({
+					t: "error",
+					...execFailureFields(r.error)
+				});
+				else enqueue({
+					t: "done",
+					data: r.data
+				});
+			} catch (err) {
+				const code = err?.code;
+				enqueue({
+					t: "error",
+					error: errorMessage(err),
+					code
+				});
+			} finally {
+				if (!closed) try {
+					controller.close();
+				} catch {}
+			}
+		},
+		cancel() {
+			closed = true;
+		}
+	});
+	return new Response(stream, {
+		status: 200,
+		headers: { "Content-Type": "application/x-ndjson; charset=utf-8" }
+	});
+}
+function createAfsRpcHandler(options) {
+	const reqCtx = createAfsRequestContext(options);
+	return async function handle(request) {
+		const probe = { t0: Date.now() };
+		try {
+			const resp = await handleInner(request, probe);
+			if (logEnabled("aos:rpc", "debug")) log.debug(`rpc:done type=${probe.type ?? "?"} status=${resp.status} totalMs=${Date.now() - probe.t0}`);
+			return resp;
+		} catch (err) {
+			log.warn(`afs-rpc unhandled failure error=${errorMessage(err)}`);
+			return fail(500, errorMessage(err));
+		}
+	};
+	async function handleInner(request, probe) {
+		if (request.method !== "POST") return fail(405, "Method Not Allowed (use POST)");
+		const limits = options.batchLimits ?? BATCH_LIMITS_CF;
+		const bounded = await readBoundedBody(request, limits.maxEncodedRequestBytes);
+		if (bounded.tooLarge) return jsonResponse(413, {
+			ok: false,
+			error: `Request body too large (> ${limits.maxEncodedRequestBytes} bytes)`,
+			code: WIRE_ERROR_CODES.payloadTooLarge
+		});
+		let body;
+		try {
+			body = JSON.parse(bounded.text);
+			if (typeof body !== "object" || body === null) throw new Error("body must be object");
+		} catch (err) {
+			return fail(400, `Invalid JSON body: ${errorMessage(err)}`);
+		}
+		const type = body.type;
+		if (typeof type !== "string" || !type) return fail(400, "Missing 'type' field");
+		const isMutation = MUTATING_OPS.has(type);
+		if (!READ_ONLY_OPS.has(type) && !isMutation) return fail(400, `Unsupported op '${type}' (supported: ${[...READ_ONLY_OPS, ...MUTATING_OPS].join(", ")})`);
+		const isBatch = BATCH_OPS.has(type);
+		let batch = null;
+		let path = "";
+		if (isBatch) {
+			const validated = validateBatchBody(body, limits, sanitizeAfsPath);
+			if (!validated.ok) return jsonResponse(validated.status, {
+				ok: false,
+				error: validated.error,
+				...validated.code ? { code: validated.code } : {}
+			});
+			batch = validated;
+		} else {
+			if (typeof body.path !== "string" || sanitizeAfsPath(body.path) === null) return fail(400, "Missing or invalid 'path'");
+			path = body.path;
+		}
+		probe.type = type;
+		if (logEnabled("aos:rpc", "debug")) {
+			const o = body.options ?? {};
+			const optBits = [
+				o.maxDepth !== void 0 ? `maxDepth=${o.maxDepth}` : "",
+				o.limit !== void 0 ? `limit=${o.limit}` : "",
+				o.offset !== void 0 ? `offset=${o.offset}` : "",
+				o.cursor !== void 0 ? "cursor=1" : ""
+			].filter(Boolean).join(";");
+			const argEntries = Array.isArray(body.args?.entries) ? body.args.entries.length : void 0;
+			const target = isBatch ? `batch:${batch?.entries.length ?? 0}` : path;
+			log.debug(`rpc:begin type=${type} target=${target}${argEntries !== void 0 ? ` args.entries=${argEntries}` : ""}${optBits ? ` opt=${optBits}` : ""} blockletHint=${body.blocklet ?? "-"}`);
+		}
+		const tPre = Date.now();
+		const blocklet = await time("resolve", () => reqCtx.resolveBlocklet(request, body.blocklet, RPC_BLOCKLET_HINT_PRIORITY));
+		const tBlocklet = Date.now();
+		if (!blocklet) return fail(400, "Could not resolve blocklet (set body.blocklet, ?blocklet=, or use a subdomain)");
+		const opts = body.options ?? {};
+		const caller = await reqCtx.resolveCaller(request);
+		const tCaller = Date.now();
+		const sessionIdForCtx = typeof body.sessionId === "string" && body.sessionId ? body.sessionId : null;
+		let scope;
+		let afs;
+		let context;
+		try {
+			const scoped = await reqCtx.resolveScoped(request, {
+				blocklet,
+				sessionId: sessionIdForCtx,
+				caller,
+				opOptions: opts
+			});
+			scope = scoped.scope;
+			afs = scoped.afs;
+			context = scoped.context;
+		} catch (err) {
+			return fail(statusForError(err), errorMessage(err));
+		}
+		const tScoped = Date.now();
+		if (logEnabled("aos:rpc", "debug")) log.debug(`rpc:resolved type=${type} blocklet=${blocklet} scope=${scope} resolveMs=${tScoped - probe.t0} blockletMs=${tBlocklet - tPre} callerMs=${tCaller - tBlocklet} scopedMs=${tScoped - tCaller}`);
+		if (isMutation) {
+			const gatePaths = batch ? batch.entries.map((e) => e.path) : [path];
+			for (const gatePath of gatePaths) {
+				const denied = checkMutationAllowed(gatePath, caller, scope);
+				if (denied) return denied;
+			}
+		}
+		if (type === "exec") {
+			const csrfReason = csrfRejection(request, caller, true);
+			if (csrfReason) return fail(403, csrfReason);
+		}
+		try {
+			switch (type) {
+				case "read":
+					if (!afs.read) return fail(501, "read not supported");
+					return jsonResponse(200, {
+						ok: true,
+						data: encodeReadData((await time("op", () => afs.read(path, {
+							...opts,
+							context
+						}))).data)
+					});
+				case "list": {
+					const r = await time("op", () => afs.list(path, {
+						...opts,
+						context
+					}));
+					return jsonResponse(200, {
+						ok: true,
+						data: path === "/.actions" ? injectIngestFacadeList(r.data) : r.data,
+						total: r.total,
+						meta: r.meta,
+						liveSeq: r.liveSeq
+					});
+				}
+				case "stat":
+					if (!afs.stat) return fail(501, "stat not supported");
+					return jsonResponse(200, {
+						ok: true,
+						data: (await time("op", () => afs.stat(path, {
+							...opts,
+							context
+						}))).data
+					});
+				case "search": {
+					if (!afs.search) return fail(501, "search not supported");
+					const query = String(body.args?.query ?? body.options?.query ?? "");
+					const filters = body.args?.filters ?? body.options?.filters;
+					const mode = body.args?.mode ?? body.options?.mode;
+					const r = await time("op", () => afs.search(path, query, {
+						...opts,
+						context,
+						filters,
+						mode
+					}));
+					return jsonResponse(200, {
+						ok: true,
+						data: r.data,
+						message: r.message,
+						meta: r.meta
+					});
+				}
+				case "exec": {
+					if (!afs.exec) return fail(501, "exec not supported");
+					if (isIngestFacadePath(path)) {
+						const fr = await time("op", () => execIngestFacade({
+							afs,
+							path,
+							args: body.args ?? {},
+							context,
+							caller,
+							limits: options.uploadLimits ?? UPLOAD_LIMIT_DEFAULTS
+						}));
+						if ("status" in fr) return fail(fr.status, fr.error);
+						if (fr.ok) return jsonResponse(200, {
+							ok: true,
+							data: fr.data
+						});
+						return jsonResponse(200, {
+							ok: false,
+							error: fr.error,
+							...fr.code ? { code: fr.code } : {}
+						});
+					}
+					const args = { ...body.args ?? {} };
+					delete args._scope_afs;
+					args._scope_afs = afs;
+					if (opts.stream === true) return execStreamResponse(afs, path, args, opts, context);
+					const r = await time("op", () => afs.exec(path, args, {
+						...opts,
+						context
+					}));
+					const exec = r;
+					if (exec.success === false) return jsonResponse(200, {
+						ok: false,
+						...execFailureFields(exec.error)
+					});
+					return jsonResponse(200, {
+						ok: true,
+						data: r.data
+					});
+				}
+				case "write": {
+					if (!afs.write) return fail(501, "write not supported");
+					const decoded = validateAndDecodeWrite({
+						type: "write",
+						path,
+						content: body.content,
+						encoding: body.encoding,
+						options: opts
+					});
+					if (!decoded.ok) return fail(decoded.status, decoded.error);
+					if (decoded.bytes.length > MAX_WRITE_BYTES) return jsonResponse(413, {
+						ok: false,
+						error: `Payload too large (> ${MAX_WRITE_BYTES} bytes)`,
+						code: WIRE_ERROR_CODES.payloadTooLarge
+					});
+					return jsonResponse(200, {
+						ok: true,
+						data: encodeReadData((await time("op", () => afs.write(path, {
+							content: decoded.bytes,
+							meta: wireMeta(body.meta)
+						}, {
+							...opts,
+							context
+						}))).data)
+					});
+				}
+				case "delete":
+					if (!afs.delete) return fail(501, "delete not supported");
+					return jsonResponse(200, {
+						ok: true,
+						data: await time("op", () => afs.delete(path, {
+							...opts,
+							context
+						}))
+					});
+				case "batchWrite": {
+					if (!afs.batchWrite) return fail(501, "write not supported");
+					const entries = batch.entries;
+					const decodes = batch.writeDecodes;
+					timeMeta("batch", `batchWrite n=${entries.length}`);
+					const results = new Array(entries.length);
+					const coreEntries = [];
+					const coreIndex = [];
+					for (let i = 0; i < entries.length; i++) {
+						const decoded = decodes[i];
+						if (!decoded.ok) {
+							results[i] = {
+								status: decoded.status,
+								ok: false,
+								error: decoded.error,
+								...decoded.code ? { code: decoded.code } : {}
+							};
+							continue;
+						}
+						coreIndex.push(i);
+						coreEntries.push({
+							path: entries[i].path,
+							content: {
+								content: decoded.bytes,
+								meta: wireMeta(entries[i].meta)
+							},
+							options: entries[i].options
+						});
+					}
+					if (coreEntries.length > 0) {
+						const core = await time("op", () => afs.batchWrite(coreEntries, { context }));
+						for (let j = 0; j < core.results.length; j++) results[coreIndex[j]] = wireResultFromCore(core.results[j]);
+					}
+					const succeeded = results.filter((r) => r?.ok === true).length;
+					return jsonResponse(200, {
+						ok: true,
+						results,
+						succeeded,
+						failed: results.length - succeeded
+					});
+				}
+				case "batchDelete": {
+					if (!afs.batchDelete) return fail(501, "delete not supported");
+					const entries = batch.entries;
+					timeMeta("batch", `batchDelete n=${entries.length}`);
+					const core = await time("op", () => afs.batchDelete(entries.map((entry) => ({
+						path: entry.path,
+						options: entry.options
+					})), { context }));
+					return jsonResponse(200, {
+						ok: true,
+						results: core.results.map((r) => r.success ? {
+							status: 200,
+							ok: true,
+							data: {
+								path: r.path,
+								deleted: true
+							}
+						} : wireResultFromCore(r)),
+						succeeded: core.succeeded,
+						failed: core.failed
+					});
+				}
+				case "batchRead": {
+					if (!afs.read) return fail(501, "read not supported");
+					const entries = batch.entries;
+					timeMeta("batch", `batchRead n=${entries.length}`);
+					const results = [];
+					let succeeded = 0;
+					let encodedBytes = 0;
+					await time("op", async () => {
+						for (const entry of entries) {
+							if (encodedBytes >= limits.readTailSkipThresholdBytes) {
+								results.push({
+									status: 503,
+									ok: false,
+									error: "Batch response budget reached — retry this entry in the next batch",
+									code: WIRE_ERROR_CODES.batchTailSkipped
+								});
+								continue;
+							}
+							try {
+								const data = encodeReadData((await afs.read(entry.path, {
+									...entry.options ?? {},
+									includeActions: "none",
+									context
+								})).data);
+								const content = data?.content;
+								if (typeof content === "string") encodedBytes += content.length;
+								results.push({
+									status: 200,
+									ok: true,
+									data
+								});
+								succeeded++;
+							} catch (err) {
+								results.push(batchEntryError(err, entry.optional === true));
+							}
+						}
+					});
+					return jsonResponse(200, {
+						ok: true,
+						results,
+						succeeded,
+						failed: results.length - succeeded
+					});
+				}
+				default: return fail(400, `Unsupported op '${type}'`);
+			}
+		} catch (err) {
+			const status = statusForError(err);
+			const message = errorMessage(err);
+			if (body.optional === true && status === 404) return jsonResponse(200, {
+				ok: false,
+				error: message,
+				missing: true
+			});
+			if (status === 402) {
+				const paymentRequired = err.paymentRequired;
+				const extraHeaders = paymentRequired !== void 0 ? { "PAYMENT-REQUIRED": typeof paymentRequired === "string" ? paymentRequired : JSON.stringify(paymentRequired) } : {};
+				return new Response(JSON.stringify({
+					ok: false,
+					error: message,
+					code: "AFS_PAYMENT_REQUIRED"
+				}), {
+					status: 402,
+					headers: {
+						...JSON_HEADERS,
+						...extraHeaders
+					}
+				});
+			}
+			if (status === 409) return jsonResponse(409, {
+				ok: false,
+				...enrichConflictBody(err)
+			});
+			if (status >= 500) log.warn(`afs-rpc op failed type=${type} path=${isBatch ? "<batch>" : path} blocklet=${blocklet} status=${status} error=${message}`);
+			const code = err?.code;
+			if (code) return jsonResponse(status, {
+				ok: false,
+				error: message,
+				code
+			});
+			return fail(status, message);
+		}
+	}
+}
+
+//#endregion
+export { createAfsRpcHandler, statusForError };
+//# sourceMappingURL=afs-rpc.mjs.map