@powerhousedao/reactor-attachments 6.2.3-dev.50 → 6.2.3-dev.52

package/dist/replication.js

@@ -0,0 +1,1975 @@
+import { a as parseRef, c as AttachmentPending, i as createRef, r as isAttachmentMetadata, s as AttachmentNotFound, t as SwitchboardAttachmentTransport } from "./switchboard-attachment-transport-BH3ZAmxE.js";
+import { t as AttachmentSchemaCompiler } from "./attachment-schema-compiler-rIaJpiHO.js";
+import { t as sha256Hex } from "./hash-CKHeI4AH.js";
+import { GQL_CHANNEL_TYPE, ReactorEventTypes } from "@powerhousedao/reactor";
+import { isPurgeMarker } from "@powerhousedao/shared/document-model";
+//#region src/access/attachment-read-gate.ts
+/** The scope an attachment's bytes belong to: the document's own domain state. */
+const ATTACHMENT_READ_SCOPE = "global";
+/** The branch an attachment reference is resolved against. */
+const ATTACHMENT_READ_BRANCH = "main";
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+/** Whether `value` is a canonical v1 hash: 64 lowercase SHA-256 hex chars. */
+function isAttachmentHash(value) {
+	return typeof value === "string" && HASH_PATTERN.test(value);
+}
+/** Rethrows a failure: a read side that is down must not read as a denial. */
+async function scopeGateAllowsAttachmentRead(scopeGate, documentId, subject) {
+	return (await scopeGate.scopePredicateById(documentId, subject, ATTACHMENT_READ_BRANCH))(ATTACHMENT_READ_SCOPE);
+}
+/** Served to the subject, references `ref`, and a referencing scope is readable. */
+async function readGateAllowsAttachmentRead(readGate, references, documentId, ref, subject) {
+	let served;
+	try {
+		served = await readGate.isServed(documentId, { subject });
+	} catch {
+		return false;
+	}
+	if (!served) return false;
+	const scopes = await references.referencingScopes(documentId, ref);
+	if (scopes.length === 0) return false;
+	let held;
+	try {
+		held = (await readGate.get(documentId, {
+			subject,
+			scopes
+		})).state;
+	} catch {
+		return false;
+	}
+	return scopes.some((scope) => scope in held);
+}
+//#endregion
+//#region src/local/protocol.ts
+/**
+* Wire tag on every message, so one `LocalChannelPort` can carry this
+* request/response protocol without being confused with anything else on the
+* port, and so a version skew is a readable refusal rather than a crash.
+*/
+const LOCAL_ATTACHMENT_PROTOCOL = "ph-attachment/v1";
+/** Default bytes per `chunk` message. */
+const DEFAULT_LOCAL_CHUNK_BYTES = 262144;
+/** Default wait for the next message of a request before it is abandoned. */
+const DEFAULT_LOCAL_REQUEST_TIMEOUT_MS = 3e4;
+const REQUEST_KINDS = /* @__PURE__ */ new Set(["fetch", "cancel"]);
+const RESPONSE_KINDS = /* @__PURE__ */ new Set([
+	"begin",
+	"chunk",
+	"end",
+	"pending",
+	"not-found",
+	"error"
+]);
+function tagged(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return record.protocol === "ph-attachment/v1" && typeof record.kind === "string" && typeof record.id === "string";
+}
+/**
+* Whether `value` is a request for this protocol.
+*
+* Both halves live on one port -- each peer runs a transport AND a server over
+* the same `LocalChannelPort` -- so each half has to recognise only its own
+* side of the conversation and ignore the rest rather than treat it as
+* malformed.
+*/
+function isLocalAttachmentRequest(value) {
+	return tagged(value) && REQUEST_KINDS.has(value.kind);
+}
+/** Whether `value` is a response for this protocol. */
+function isLocalAttachmentResponse(value) {
+	return tagged(value) && RESPONSE_KINDS.has(value.kind);
+}
+//#endregion
+//#region src/local/local-attachment-server.ts
+/** Default {@link LocalAttachmentServerOptions.maxConcurrentServes}. */
+const DEFAULT_LOCAL_MAX_CONCURRENT_SERVES = 4;
+/** A macrotask, so a cancel posted by the peer is handled between slices. */
+function nextTurn() {
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
+/**
+* Authorizes a peer read the way the Switchboard's attachment route does: the
+* link's subject may read the document's `global` scope, the reactor serves
+* the document to it, and a scope it may read references the hash.
+*/
+function readGateAttachmentAuthorizer(options) {
+	return async (link, hash, documentId) => {
+		const subject = options.subjectOf(link);
+		if (!subject) return false;
+		if (!await scopeGateAllowsAttachmentRead(options.scopeGate, documentId, subject)) return false;
+		return readGateAllowsAttachmentRead(options.readGate, options.references, documentId, createRef(hash), subject);
+	};
+}
+/**
+* Serves attachment bytes to a brokered local peer from this reactor's own
+* store.
+*
+* The answering half of {@link LocalAttachmentTransport}; both run on the same
+* `LocalChannelPort` and ignore each other's messages.
+*
+* It never chains. The store is read WITHOUT a document id, which means a
+* `LocalAttachmentStore` serves only bytes it actually holds and cannot reach
+* for its own transport on the requester's behalf. Without that, two peers
+* linked to each other would answer a miss by asking each other, and a hash
+* neither held would bounce between them.
+*/
+var LocalAttachmentServer = class {
+	port;
+	link;
+	store;
+	authorize;
+	chunkSizeBytes;
+	maxConcurrentServes;
+	onDiagnostic;
+	cancelled = /* @__PURE__ */ new Set();
+	inFlight = /* @__PURE__ */ new Set();
+	detachPort;
+	served = 0;
+	bytesServed = 0;
+	refused = 0;
+	closed = false;
+	constructor(options) {
+		this.port = options.port;
+		this.link = { ...options.link };
+		this.store = options.store;
+		this.authorize = options.authorize ?? (() => Promise.resolve(false));
+		this.chunkSizeBytes = options.chunkSizeBytes ?? 262144;
+		this.maxConcurrentServes = options.maxConcurrentServes ?? 4;
+		this.onDiagnostic = options.onDiagnostic ?? (() => void 0);
+		this.detachPort = this.port.onMessage((data) => this.onMessage(data));
+	}
+	/** What this peer has handed out. */
+	stats() {
+		return {
+			served: this.served,
+			bytesServed: this.bytesServed,
+			refused: this.refused
+		};
+	}
+	/** Detaches from the port. In-flight serves stop at their next slice. */
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.detachPort();
+		this.cancelled.clear();
+		this.inFlight.clear();
+	}
+	onMessage(data) {
+		if (!isLocalAttachmentRequest(data)) return;
+		if (data.kind === "cancel") {
+			if (this.inFlight.has(data.id)) this.cancelled.add(data.id);
+			return;
+		}
+		if (this.inFlight.has(data.id)) {
+			this.onDiagnostic(`ignoring a duplicate attachment request id ${data.id}`);
+			return;
+		}
+		if (!isAttachmentHash(data.hash) || typeof data.documentId !== "string" || data.documentId === "") {
+			this.refuse(data);
+			return;
+		}
+		if (this.inFlight.size >= this.maxConcurrentServes) {
+			this.post({
+				protocol: LOCAL_ATTACHMENT_PROTOCOL,
+				kind: "pending",
+				id: data.id,
+				hash: data.hash,
+				expiresAtUtc: new Date(Date.now() + BUSY_PENDING_TTL_MS).toISOString(),
+				retryAfterMs: BUSY_RETRY_MS,
+				busy: true
+			});
+			return;
+		}
+		this.serve(data);
+	}
+	stopped(id) {
+		return this.closed || this.cancelled.has(id);
+	}
+	async serve(request) {
+		this.inFlight.add(request.id);
+		try {
+			await this.serveInner(request);
+		} finally {
+			this.inFlight.delete(request.id);
+			this.cancelled.delete(request.id);
+		}
+	}
+	async serveInner(request) {
+		try {
+			if (!await this.authorize({ ...this.link }, request.hash, request.documentId)) {
+				this.refuse(request);
+				return;
+			}
+		} catch (error) {
+			this.onDiagnostic(`authorizing attachment ${request.hash} for ${request.documentId} failed`, error);
+			this.post({
+				protocol: LOCAL_ATTACHMENT_PROTOCOL,
+				kind: "error",
+				id: request.id,
+				message: "authorization check failed"
+			});
+			return;
+		}
+		if (this.stopped(request.id)) return;
+		let held;
+		try {
+			held = await this.store.has(request.hash);
+		} catch (error) {
+			this.failRequest(request, "reading the local attachment store failed", error);
+			return;
+		}
+		if (this.stopped(request.id)) return;
+		if (!held) {
+			this.refuse(request);
+			return;
+		}
+		await this.stream(request);
+	}
+	async stream(request) {
+		let response;
+		try {
+			response = await this.store.get(request.hash);
+		} catch (error) {
+			if (error instanceof AttachmentPending) {
+				this.post({
+					protocol: LOCAL_ATTACHMENT_PROTOCOL,
+					kind: "pending",
+					id: request.id,
+					hash: request.hash,
+					expiresAtUtc: error.expiresAtUtc,
+					retryAfterMs: DEFAULT_PENDING_RETRY_MS
+				});
+				return;
+			}
+			this.onDiagnostic(`serving attachment ${request.hash} failed`, error);
+			this.refuse(request);
+			return;
+		}
+		this.post({
+			protocol: LOCAL_ATTACHMENT_PROTOCOL,
+			kind: "begin",
+			id: request.id,
+			hash: request.hash,
+			metadata: {
+				mimeType: response.header.mimeType,
+				fileName: response.header.fileName,
+				sizeBytes: response.header.sizeBytes,
+				extension: response.header.extension,
+				createdAtUtc: response.header.createdAtUtc,
+				lastAccessedAtUtc: response.header.lastAccessedAtUtc
+			}
+		});
+		const reader = response.body.getReader();
+		let seq = 0;
+		try {
+			for (;;) {
+				if (this.stopped(request.id)) {
+					await reader.cancel();
+					return;
+				}
+				const { done, value } = await reader.read();
+				if (done) break;
+				for (let offset = 0; offset < value.byteLength; offset += this.chunkSizeBytes) {
+					if (offset > 0) await nextTurn();
+					if (this.stopped(request.id)) {
+						await reader.cancel();
+						return;
+					}
+					const slice = value.subarray(offset, Math.min(offset + this.chunkSizeBytes, value.byteLength));
+					const bytes = new Uint8Array(slice.byteLength);
+					bytes.set(slice);
+					this.post({
+						protocol: LOCAL_ATTACHMENT_PROTOCOL,
+						kind: "chunk",
+						id: request.id,
+						seq: seq++,
+						bytes
+					});
+					this.bytesServed += bytes.byteLength;
+				}
+			}
+		} catch (error) {
+			this.onDiagnostic(`streaming attachment ${request.hash} failed`, error);
+			this.post({
+				protocol: LOCAL_ATTACHMENT_PROTOCOL,
+				kind: "error",
+				id: request.id,
+				message: "reading the attachment body failed"
+			});
+			return;
+		}
+		this.served += 1;
+		this.post({
+			protocol: LOCAL_ATTACHMENT_PROTOCOL,
+			kind: "end",
+			id: request.id
+		});
+	}
+	/** Refused and absent are one answer, so a peer learns nothing from it. */
+	refuse(request) {
+		this.refused += 1;
+		this.post({
+			protocol: LOCAL_ATTACHMENT_PROTOCOL,
+			kind: "not-found",
+			id: request.id
+		});
+	}
+	failRequest(request, message, error) {
+		this.onDiagnostic(`${message} (${request.hash})`, error);
+		this.post({
+			protocol: LOCAL_ATTACHMENT_PROTOCOL,
+			kind: "error",
+			id: request.id,
+			message
+		});
+	}
+	post(message) {
+		try {
+			this.port.postMessage(message);
+		} catch (error) {
+			this.onDiagnostic("posting an attachment response failed", error);
+		}
+	}
+};
+/**
+* Retry hint sent with a `pending` answer. A local store has no reservation
+* table, so this only arises when the served store is a server-side one; the
+* value mirrors `SwitchboardAttachmentTransport`'s own default.
+*/
+const DEFAULT_PENDING_RETRY_MS = 5e3;
+/** Retry hint sent with the `pending` that answers a request over the serve cap. */
+const BUSY_RETRY_MS = 1e3;
+/** Expiry of that `pending`, for callers that surface it as `AttachmentPending`. */
+const BUSY_PENDING_TTL_MS = 6e4;
+//#endregion
+//#region src/local/local-attachment-transport.ts
+/**
+* `IAttachmentTransport` over a brokered `LocalChannelPort`: one linked reactor
+* pulling attachment bytes straight from its peer, with no Switchboard and no
+* HTTP.
+*
+* The counterpart of {@link LocalAttachmentServer}, and a pair of them runs on
+* each end of one port: a reactor both asks for bytes and serves them. The two
+* halves share the port and ignore each other's messages (see
+* `isLocalAttachmentRequest` / `isLocalAttachmentResponse`), and request ids
+* are namespaced per instance so two peers that both start counting at 1 never
+* match each other's replies.
+*
+* Pull-only by design. The agreed byte-movement model is lazy
+* fetch-on-reference, so {@link announce} is a no-op and {@link push} refuses
+* by name rather than silently succeeding: a push that reported success while
+* moving nothing would make an eager-replication caller believe bytes had
+* landed on a peer.
+*/
+var LocalAttachmentTransport = class {
+	port;
+	requestTimeoutMs;
+	setTimer;
+	clearTimer;
+	instanceId;
+	maxBytes;
+	pending = /* @__PURE__ */ new Map();
+	detachPort;
+	nextRequest = 0;
+	closed = false;
+	constructor(options) {
+		this.port = options.port;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+		this.setTimer = options.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+		this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+		this.instanceId = options.instanceId ?? Math.random().toString(36).slice(2, 10);
+		this.maxBytes = options.maxBytes;
+		this.detachPort = this.port.onMessage((data) => this.onMessage(data));
+	}
+	fetch(hash, documentId, signal) {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Local attachment transport is closed; the link is severed"));
+		if (signal?.aborted) return Promise.reject(/* @__PURE__ */ new Error("Attachment fetch aborted"));
+		const id = `${this.instanceId}:${++this.nextRequest}`;
+		return new Promise((resolve, reject) => {
+			const entry = {
+				hash,
+				settle: resolve,
+				fail: reject,
+				controller: void 0,
+				nextSeq: 0,
+				declaredBytes: 0,
+				receivedBytes: 0,
+				timer: void 0,
+				detachAbort: void 0
+			};
+			this.pending.set(id, entry);
+			this.arm(id, entry);
+			if (signal) {
+				const onAbort = () => {
+					this.post({
+						protocol: LOCAL_ATTACHMENT_PROTOCOL,
+						kind: "cancel",
+						id
+					});
+					this.abandon(id, /* @__PURE__ */ new Error("Attachment fetch aborted"));
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				entry.detachAbort = () => signal.removeEventListener("abort", onAbort);
+			}
+			this.post({
+				protocol: LOCAL_ATTACHMENT_PROTOCOL,
+				kind: "fetch",
+				id,
+				hash,
+				documentId
+			});
+		});
+	}
+	/**
+	* No-op: the agreed model is the peer PULLING on reference, so there is
+	* nothing useful to tell it -- it will ask when one of its own operations
+	* names the hash. An eager-announce protocol would need a peer that acts on
+	* the notice, which nothing does.
+	*/
+	announce() {
+		return Promise.resolve();
+	}
+	/** Refuses: this transport moves bytes only in answer to a peer's request. */
+	push() {
+		return Promise.reject(/* @__PURE__ */ new Error("LocalAttachmentTransport is pull-only: a linked peer fetches bytes on reference, so there is no push path to a local peer"));
+	}
+	/** Detaches from the port and fails every in-flight request. */
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.detachPort();
+		for (const id of [...this.pending.keys()]) this.abandon(id, /* @__PURE__ */ new Error("Local attachment transport closed while a fetch was in flight"));
+	}
+	onMessage(data) {
+		if (!isLocalAttachmentResponse(data)) return;
+		const entry = this.pending.get(data.id);
+		if (!entry) return;
+		this.arm(data.id, entry);
+		this.handle(data.id, entry, data);
+	}
+	handle(id, entry, message) {
+		if (entry.controller && (message.kind === "begin" || message.kind === "pending" || message.kind === "not-found")) {
+			this.violate(id, `Local attachment peer sent ${message.kind} after the body began`);
+			return;
+		}
+		switch (message.kind) {
+			case "begin": {
+				if (message.hash !== entry.hash || !isAttachmentMetadata(message.metadata)) {
+					this.violate(id, "Local attachment peer sent a malformed begin");
+					return;
+				}
+				const sizeBytes = message.metadata.sizeBytes;
+				if (this.maxBytes !== void 0 && sizeBytes > this.maxBytes) {
+					this.violate(id, `Local attachment of ${sizeBytes} bytes exceeds the ${this.maxBytes} byte limit`);
+					return;
+				}
+				entry.declaredBytes = sizeBytes;
+				const body = new ReadableStream({
+					start: (controller) => {
+						entry.controller = controller;
+					},
+					cancel: () => {
+						this.post({
+							protocol: LOCAL_ATTACHMENT_PROTOCOL,
+							kind: "cancel",
+							id
+						});
+						this.release(id, entry);
+					}
+				});
+				entry.settle({
+					kind: "data",
+					response: {
+						hash: message.hash,
+						metadata: message.metadata,
+						body
+					}
+				});
+				return;
+			}
+			case "chunk":
+				if (!entry.controller) {
+					this.abandon(id, /* @__PURE__ */ new Error("Local attachment peer sent body bytes before announcing the attachment"));
+					return;
+				}
+				if (!(message.bytes instanceof Uint8Array)) {
+					this.violate(id, "Local attachment peer sent a malformed chunk");
+					return;
+				}
+				if (message.seq !== entry.nextSeq) {
+					this.abandon(id, /* @__PURE__ */ new Error(`Local attachment chunk out of order: expected ${entry.nextSeq}, got ${message.seq}`));
+					return;
+				}
+				entry.receivedBytes += message.bytes.byteLength;
+				if (entry.receivedBytes > entry.declaredBytes) {
+					this.violate(id, `Local attachment peer sent more than the ${entry.declaredBytes} bytes it declared`);
+					return;
+				}
+				entry.nextSeq += 1;
+				entry.controller.enqueue(new Uint8Array(message.bytes));
+				return;
+			case "end":
+				if (!entry.controller) {
+					this.abandon(id, /* @__PURE__ */ new Error("Local attachment peer ended the transfer before announcing the attachment"));
+					return;
+				}
+				if (entry.receivedBytes !== entry.declaredBytes) {
+					this.abandon(id, /* @__PURE__ */ new Error(`Local attachment peer ended after ${entry.receivedBytes} of ${entry.declaredBytes} declared bytes`));
+					return;
+				}
+				entry.controller.close();
+				this.release(id, entry);
+				return;
+			case "pending":
+				if (message.hash !== entry.hash || typeof message.expiresAtUtc !== "string") {
+					this.violate(id, "Local attachment peer sent a malformed pending");
+					return;
+				}
+				entry.settle({
+					kind: "pending",
+					hash: message.hash,
+					expiresAtUtc: message.expiresAtUtc,
+					retryAfterMs: typeof message.retryAfterMs === "number" ? message.retryAfterMs : NaN,
+					...message.busy === true ? { busy: true } : {}
+				});
+				this.release(id, entry);
+				return;
+			case "not-found":
+				entry.settle({ kind: "not-found" });
+				this.release(id, entry);
+				return;
+			case "error":
+				this.abandon(id, /* @__PURE__ */ new Error(`Local attachment peer failed: ${message.message}`));
+				return;
+		}
+	}
+	/** A reply that breaks the protocol: tell the peer to stop, fail the request. */
+	violate(id, message) {
+		this.post({
+			protocol: LOCAL_ATTACHMENT_PROTOCOL,
+			kind: "cancel",
+			id
+		});
+		this.abandon(id, new Error(message));
+	}
+	/** Resets this request's silence timer. */
+	arm(id, entry) {
+		if (entry.timer !== void 0) this.clearTimer(entry.timer);
+		entry.timer = this.setTimer(() => {
+			this.post({
+				protocol: LOCAL_ATTACHMENT_PROTOCOL,
+				kind: "cancel",
+				id
+			});
+			this.abandon(id, /* @__PURE__ */ new Error(`Local attachment peer went silent for ${this.requestTimeoutMs}ms while serving ${entry.hash}`));
+		}, this.requestTimeoutMs);
+	}
+	/** Forgets a request that completed normally. */
+	release(id, entry) {
+		if (entry.timer !== void 0) {
+			this.clearTimer(entry.timer);
+			entry.timer = void 0;
+		}
+		entry.detachAbort?.();
+		this.pending.delete(id);
+	}
+	/**
+	* Forgets a request that failed, pushing the failure to whichever side is
+	* still listening: the fetch promise before `begin`, the body stream after.
+	*/
+	abandon(id, error) {
+		const entry = this.pending.get(id);
+		if (!entry) return;
+		this.release(id, entry);
+		if (entry.controller) {
+			entry.controller.error(error);
+			return;
+		}
+		entry.fail(error);
+	}
+	post(message) {
+		try {
+			this.port.postMessage(message);
+		} catch {}
+	}
+};
+//#endregion
+//#region src/peers/attachment-peer-links.ts
+/** Holds one raw listener for the link's life and fans it out to both halves. */
+var LinkPort = class {
+	raw;
+	onDiagnostic;
+	subscribers = /* @__PURE__ */ new Set();
+	detachRaw;
+	constructor(raw, onDiagnostic) {
+		this.raw = raw;
+		this.onDiagnostic = onDiagnostic;
+		this.detachRaw = raw.onMessage((data) => this.dispatch(data));
+	}
+	/** A view for one half; its close() is a no-op, the link owns the port. */
+	view() {
+		return {
+			postMessage: (data) => this.raw.postMessage(data),
+			onMessage: (callback) => {
+				this.subscribers.add(callback);
+				return () => {
+					this.subscribers.delete(callback);
+				};
+			},
+			close: () => void 0
+		};
+	}
+	detach() {
+		this.subscribers.clear();
+		this.detachRaw();
+	}
+	release() {
+		this.detach();
+		try {
+			this.raw.close();
+		} catch (error) {
+			this.onDiagnostic("closing an attachment link port failed", error);
+		}
+	}
+	dispatch(data) {
+		for (const subscriber of [...this.subscribers]) try {
+			subscriber(data);
+		} catch (error) {
+			this.onDiagnostic("an attachment link handler threw", error);
+		}
+	}
+};
+/** Per-peer server and transport pairs, each on its own port, not the sync port. */
+var AttachmentPeerLinks = class {
+	options;
+	links = /* @__PURE__ */ new Map();
+	onDiagnostic;
+	constructor(options) {
+		this.options = options;
+		this.onDiagnostic = options.onDiagnostic ?? (() => void 0);
+	}
+	has(peerId, channelName) {
+		return this.links.has(linkKey(peerId, channelName));
+	}
+	/** Takes ownership of `port` on success; on failure the port is untouched. */
+	addPeer(peerId, channelName, port, linkOptions = {}) {
+		const key = linkKey(peerId, channelName);
+		if (this.links.has(key)) throw new Error(`This reactor already holds an attachment link to peer '${peerId}' on channel '${channelName}'; remove it before linking again`);
+		const linkPort = new LinkPort(port, this.onDiagnostic);
+		const authorize = linkOptions.authorize ?? this.options.authorize;
+		const server = new LocalAttachmentServer({
+			port: linkPort.view(),
+			link: {
+				peerId,
+				channelName
+			},
+			store: this.options.store,
+			...authorize ? { authorize } : {},
+			...this.options.chunkSizeBytes !== void 0 ? { chunkSizeBytes: this.options.chunkSizeBytes } : {},
+			...this.options.maxConcurrentServes !== void 0 ? { maxConcurrentServes: this.options.maxConcurrentServes } : {},
+			onDiagnostic: this.onDiagnostic
+		});
+		const transport = new LocalAttachmentTransport({
+			port: linkPort.view(),
+			...this.options.requestTimeoutMs !== void 0 ? { requestTimeoutMs: this.options.requestTimeoutMs } : {},
+			...this.options.maxBytes !== void 0 ? { maxBytes: this.options.maxBytes } : {}
+		});
+		try {
+			this.options.transport.addPeer(peerId, channelName, transport);
+		} catch (error) {
+			server.close();
+			transport.close();
+			linkPort.detach();
+			throw error;
+		}
+		this.links.set(key, {
+			peerId,
+			channelName,
+			port: linkPort,
+			server,
+			transport
+		});
+		try {
+			this.options.onPeerAdded?.(peerId, channelName);
+		} catch (error) {
+			this.onDiagnostic("an attachment onPeerAdded hook threw", error);
+		}
+	}
+	/** Closes the link's server, transport and port. False when absent. */
+	removePeer(peerId, channelName) {
+		const key = linkKey(peerId, channelName);
+		const link = this.links.get(key);
+		if (!link) return false;
+		this.links.delete(key);
+		this.options.transport.removePeer(peerId, channelName);
+		link.server.close();
+		link.transport.close();
+		link.port.release();
+		return true;
+	}
+	servedStats() {
+		const total = {
+			served: 0,
+			bytesServed: 0,
+			refused: 0
+		};
+		for (const link of this.links.values()) {
+			const stats = link.server.stats();
+			total.served += stats.served;
+			total.bytesServed += stats.bytesServed;
+			total.refused += stats.refused;
+		}
+		return total;
+	}
+	close() {
+		for (const link of [...this.links.values()]) this.removePeer(link.peerId, link.channelName);
+	}
+};
+function linkKey(peerId, channelName) {
+	return `${peerId}\u0000${channelName}`;
+}
+//#endregion
+//#region src/storage/local/bytes.ts
+/**
+* Drains `stream` into one `Uint8Array`.
+*
+* The local stores hold whole blobs (see {@link ILocalAttachmentBackend}), so
+* the stream an `IAttachmentStore.put` is handed has to be collected before it
+* can be written. Realm-neutral: no `node:buffer`, no `Blob`.
+*/
+async function collectStream(stream) {
+	const reader = stream.getReader();
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+		total += value.byteLength;
+	}
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+/** A one-chunk `ReadableStream` over `bytes`. */
+function streamFromBytes(bytes) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
+}
+//#endregion
+//#region src/peers/peered-attachment-transport.ts
+/**
+* What the sources that did not answer data said, ranked by the combine rule:
+* a reservation, then a busy source, then an error, then a not-found. A busy
+* source may hold the bytes; the replicator bounds a busy run.
+*/
+var Answers = class {
+	pending;
+	busy;
+	firstError;
+	notFound = false;
+	error(error) {
+		this.firstError ??= error instanceof Error ? error : new Error(String(error));
+	}
+	result() {
+		if (this.pending) return this.pending;
+		if (this.busy) {
+			const { othersNotFound: _, ...busy } = this.busy;
+			return this.notFound && this.firstError === void 0 ? {
+				...busy,
+				othersNotFound: true
+			} : busy;
+		}
+		if (this.firstError !== void 0) throw this.firstError;
+		return { kind: "not-found" };
+	}
+};
+/** Collects and checks a body, so a source's wrong bytes are its own error. */
+async function verified(hash, result) {
+	const bytes = await collectStream(result.response.body);
+	const actual = await sha256Hex(bytes);
+	if (actual !== hash) throw new Error(`Attachment bytes for ${hash} hashed to ${actual}; the source served content that is not what was asked for`);
+	return {
+		kind: "data",
+		response: {
+			...result.response,
+			body: streamFromBytes(bytes)
+		}
+	};
+}
+/**
+* Peers in parallel, then Switchboards in turn; verified data > pending >
+* busy > error > unanimous not-found.
+*/
+var PeeredAttachmentTransport = class {
+	syncManager;
+	switchboardUrl;
+	jwtHandler;
+	fetchFn;
+	peers = /* @__PURE__ */ new Map();
+	switchboards = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.syncManager = options.syncManager;
+		this.switchboardUrl = options.switchboardUrl;
+		this.jwtHandler = options.jwtHandler;
+		this.fetchFn = options.fetchFn;
+	}
+	/** Keyed by (peerId, channelName), so one peer may hold several links. */
+	addPeer(peerId, channelName, transport) {
+		const key = peerKey(peerId, channelName);
+		if (this.peers.has(key)) throw new Error(`An attachment peer is already registered for '${peerId}' on channel '${channelName}'; remove it before linking again`);
+		this.peers.set(key, {
+			peerId,
+			transport
+		});
+	}
+	/** Forgets one peer link; the caller owns closing its transport. */
+	removePeer(peerId, channelName) {
+		const key = peerKey(peerId, channelName);
+		const entry = this.peers.get(key);
+		this.peers.delete(key);
+		return entry?.transport;
+	}
+	/** Distinct linked peer ids. */
+	peerNames() {
+		return [...new Set([...this.peers.values()].map((entry) => entry.peerId))];
+	}
+	/** The explicit Switchboard, then every gql remote's origin. */
+	switchboardSources() {
+		const urls = /* @__PURE__ */ new Set();
+		if (this.switchboardUrl) urls.add(this.switchboardUrl);
+		for (const remote of this.syncManager?.list() ?? []) {
+			if (remote.meta.channelConfig.type !== GQL_CHANNEL_TYPE) continue;
+			const url = remote.meta.channelConfig.parameters.url;
+			if (typeof url === "string" && url !== "") urls.add(attachmentOriginOf(url));
+		}
+		return [...urls];
+	}
+	async fetch(hash, documentId, signal) {
+		signal?.throwIfAborted();
+		const peers = [...this.peers.values()].map((entry) => entry.transport);
+		const switchboards = this.switchboardSources().map((url) => this.switchboardFor(url));
+		if (peers.length === 0 && switchboards.length === 0) return { kind: "not-found" };
+		const answers = new Answers();
+		if (peers.length > 0) {
+			const data = await this.askPeers(peers, hash, documentId, answers, signal);
+			if (data) return data;
+		}
+		for (const switchboard of switchboards) {
+			signal?.throwIfAborted();
+			const data = await this.ask(switchboard, hash, documentId, answers, signal);
+			if (data) return data;
+		}
+		signal?.throwIfAborted();
+		return answers.result();
+	}
+	async ask(source, hash, documentId, answers, signal) {
+		let result;
+		try {
+			result = await source.fetch(hash, documentId, signal);
+		} catch (error) {
+			answers.error(error);
+			return;
+		}
+		if (result.kind === "pending") {
+			if (result.busy) answers.busy ??= result;
+			else answers.pending ??= result;
+			return;
+		}
+		if (result.kind === "not-found") {
+			answers.notFound = true;
+			return;
+		}
+		try {
+			return await verified(hash, result);
+		} catch (error) {
+			answers.error(error);
+			return;
+		}
+	}
+	/** The first verified data wins and cancels the other peers. */
+	askPeers(peers, hash, documentId, answers, signal) {
+		const controllers = peers.map(() => new AbortController());
+		const abortAll = () => {
+			for (const controller of controllers) controller.abort();
+		};
+		if (signal?.aborted) abortAll();
+		signal?.addEventListener("abort", abortAll, { once: true });
+		return new Promise((resolve) => {
+			let remaining = peers.length;
+			let won = false;
+			peers.forEach((peer, index) => {
+				this.ask(peer, hash, documentId, answers, controllers[index].signal).then((data) => {
+					remaining -= 1;
+					if (data && !won) {
+						won = true;
+						controllers.forEach((controller, other) => {
+							if (other !== index) controller.abort();
+						});
+						resolve(data);
+						return;
+					}
+					if (remaining === 0 && !won) resolve(void 0);
+				});
+			});
+		}).finally(() => signal?.removeEventListener("abort", abortAll));
+	}
+	/** Best effort across every source. */
+	async announce(hash) {
+		await Promise.allSettled(this.sources().map((source) => source.announce(hash)));
+	}
+	push() {
+		return Promise.reject(/* @__PURE__ */ new Error("PeeredAttachmentTransport is pull-only: bytes move when a reactor references a hash it lacks, not by being pushed"));
+	}
+	sources() {
+		return [...[...this.peers.values()].map((entry) => entry.transport), ...this.switchboardSources().map((url) => this.switchboardFor(url))];
+	}
+	switchboardFor(url) {
+		const existing = this.switchboards.get(url);
+		if (existing) return existing;
+		const transport = new SwitchboardAttachmentTransport({
+			remoteUrl: url,
+			...this.jwtHandler ? { jwtHandler: this.jwtHandler } : {},
+			...this.fetchFn ? { fetchFn: this.fetchFn } : {}
+		});
+		this.switchboards.set(url, transport);
+		return transport;
+	}
+};
+/** NUL-joined so no peer id or channel name can forge another pair's key. */
+function peerKey(peerId, channelName) {
+	return `${peerId}\u0000${channelName}`;
+}
+/** Attachments are served from the origin, not under the GraphQL path. */
+function attachmentOriginOf(graphqlUrl) {
+	try {
+		return new URL(graphqlUrl).origin;
+	} catch {
+		const marker = graphqlUrl.lastIndexOf("/graphql");
+		return (marker >= 0 ? graphqlUrl.slice(0, marker) : graphqlUrl).replace(/\/+$/, "");
+	}
+}
+//#endregion
+//#region src/replication/retry-state.ts
+/** setTimeout's largest delay; a longer one fires at once. */
+const MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
+function newRetryEntry(documentId) {
+	return {
+		notFoundAnswers: 0,
+		errorRun: 0,
+		pendingRun: 0,
+		busyRun: 0,
+		livePending: void 0,
+		unasked: [documentId],
+		asked: []
+	};
+}
+/** The document the next attempt asks through. */
+function documentToAsk(entry) {
+	return entry.unasked[0] ?? entry.asked[0];
+}
+/** Every counter zeroed and every document unasked again. */
+function resetRetry(documentIds) {
+	return {
+		notFoundAnswers: 0,
+		errorRun: 0,
+		pendingRun: 0,
+		busyRun: 0,
+		livePending: void 0,
+		unasked: [...documentIds],
+		asked: []
+	};
+}
+/** `revive`: a terminal entry earns one more attempt through the new document. */
+function withDocument(entry, documentId, state) {
+	return {
+		entry: {
+			...entry,
+			unasked: [...entry.unasked, documentId]
+		},
+		revive: state === "not-found" || state === "failed"
+	};
+}
+/** The whole retry policy; `now` is epoch ms. */
+function nextAfter(entry, outcome, now, policy) {
+	switch (outcome.kind) {
+		case "data": return {
+			entry: {
+				...entry,
+				errorRun: 0,
+				pendingRun: 0,
+				busyRun: 0,
+				livePending: void 0
+			},
+			state: "held",
+			delayMs: void 0
+		};
+		case "aborted": return {
+			entry,
+			state: "queued",
+			delayMs: void 0
+		};
+		case "pending": {
+			const untilMs = typeof outcome.expiresAtUtc === "string" ? Date.parse(outcome.expiresAtUtc) : NaN;
+			if (!(untilMs > now)) return notFound(entry, outcome.documentId, now, policy);
+			const pendingRun = entry.pendingRun + 1;
+			return {
+				entry: {
+					...entry,
+					errorRun: 0,
+					pendingRun,
+					busyRun: 0,
+					livePending: {
+						documentId: outcome.documentId,
+						untilMs
+					},
+					unasked: without(entry.unasked, outcome.documentId),
+					asked: [outcome.documentId, ...without(entry.asked, outcome.documentId)]
+				},
+				state: "waiting",
+				delayMs: pendingDelay(outcome.retryAfterMs, pendingRun, policy)
+			};
+		}
+		case "busy": {
+			const busyRun = entry.busyRun + 1;
+			if (pendingGrowth(outcome.retryAfterMs, busyRun, policy) >= policy.maxPendingRetryMs) return outcome.othersNotFound ? notFound(entry, outcome.documentId, now, policy) : failure(entry, outcome.documentId, policy);
+			return {
+				entry: {
+					...entry,
+					busyRun
+				},
+				state: "waiting",
+				delayMs: pendingDelay(outcome.retryAfterMs, busyRun, policy)
+			};
+		}
+		case "not-found": return notFound(entry, outcome.documentId, now, policy);
+		case "error": return failure(entry, outcome.documentId, policy);
+	}
+}
+function failure(entry, documentId, policy) {
+	const errorRun = entry.errorRun + 1;
+	if (errorRun < policy.errorAttempts) return {
+		entry: {
+			...entry,
+			errorRun,
+			pendingRun: 0,
+			busyRun: 0
+		},
+		state: "waiting",
+		delayMs: backoff(policy.errorRetryMs, errorRun, policy)
+	};
+	const next = {
+		...entry,
+		errorRun,
+		pendingRun: 0,
+		busyRun: 0,
+		unasked: without(entry.unasked, documentId),
+		asked: entry.asked.includes(documentId) ? entry.asked : [...entry.asked, documentId]
+	};
+	if (next.unasked.length > 0) return {
+		entry: next,
+		state: "waiting",
+		delayMs: policy.errorRetryMs
+	};
+	return {
+		entry: next,
+		state: "failed",
+		delayMs: void 0
+	};
+}
+function notFound(entry, documentId, now, policy) {
+	const notFoundAnswers = entry.notFoundAnswers + 1;
+	const livePending = entry.livePending && entry.livePending.documentId !== documentId && entry.livePending.untilMs > now ? entry.livePending : void 0;
+	const next = {
+		...entry,
+		notFoundAnswers,
+		errorRun: 0,
+		pendingRun: 0,
+		busyRun: 0,
+		livePending,
+		unasked: without(entry.unasked, documentId),
+		asked: [...without(entry.asked, documentId), documentId]
+	};
+	if (next.unasked.length > 0 || livePending !== void 0) return {
+		entry: next,
+		state: "waiting",
+		delayMs: policy.notFoundRetryMs
+	};
+	if (notFoundAnswers < policy.notFoundAttempts) return {
+		entry: next,
+		state: "waiting",
+		delayMs: backoff(policy.notFoundRetryMs, notFoundAnswers, policy)
+	};
+	return {
+		entry: next,
+		state: "not-found",
+		delayMs: void 0
+	};
+}
+/** A run's uncapped wait: the asked delay, floored, doubled per answer. */
+function pendingGrowth(retryAfterMs, run, policy) {
+	const asked = Number.isFinite(retryAfterMs) && retryAfterMs >= 0 ? retryAfterMs : policy.pendingRetryMs;
+	return Math.max(asked, policy.minPendingRetryMs) * 2 ** (run - 1);
+}
+function pendingDelay(retryAfterMs, pendingRun, policy) {
+	const grown = Math.min(pendingGrowth(retryAfterMs, pendingRun, policy), policy.maxPendingRetryMs);
+	return Math.min(Math.max(grown, policy.minPendingRetryMs), MAX_TIMER_DELAY_MS);
+}
+function backoff(baseMs, run, policy) {
+	return Math.min(baseMs * 2 ** (run - 1), policy.maxRetryMs, MAX_TIMER_DELAY_MS);
+}
+function without(list, item) {
+	return list.filter((entry) => entry !== item);
+}
+//#endregion
+//#region src/replication/types.ts
+const DEFAULT_ATTACHMENT_RETRY_POLICY = {
+	pendingRetryMs: 5e3,
+	minPendingRetryMs: 250,
+	maxPendingRetryMs: 3e5,
+	notFoundAttempts: 3,
+	notFoundRetryMs: 2e3,
+	errorAttempts: 5,
+	errorRetryMs: 1e3,
+	maxRetryMs: 3e5
+};
+/** Default bounded concurrency for in-flight attachment fetches. */
+const DEFAULT_ATTACHMENT_REPLICATION_CONCURRENCY = 3;
+/** Default number of held hashes a replicator remembers after dropping their entries. */
+const DEFAULT_ATTACHMENT_HELD_HASH_LIMIT = 1e4;
+/** Default page size for the boot re-scan over the reference backlog. */
+const DEFAULT_ATTACHMENT_BACKLOG_PAGE_SIZE = 200;
+//#endregion
+//#region src/replication/attachment-replicator.ts
+const SYSTEM_REPLICATION_TIMERS = {
+	now: () => Date.now(),
+	setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimer: (handle) => clearTimeout(handle)
+};
+/**
+* Lazy fetch-on-reference: pulls attachment bytes a reactor's own operations
+* reference but whose hash its local store lacks.
+*
+* The seam is `ReactorEventTypes.JOB_READ_READY` on the reactor's event bus,
+* and that choice matters in two ways. It is AFTER the pre-ready read models,
+* so by the time the replicator asks a peer for a hash, this reactor's own
+* attachment reference index has recorded the reference -- the same reactor is
+* therefore able to serve the hash onward, and a reactor cannot be in the
+* position of chasing bytes it would refuse to authorize itself. And it is off
+* the write path: a slow or unreachable peer cannot delay a commit, because
+* the subscriber only notes hashes and returns.
+*
+* Resume is a re-scan of the reference index ({@link IAttachmentReferenceScanner}),
+* not a cursor: the index plus `store.has()` re-derives the exact outstanding
+* work set on every boot, idempotently, and a persisted cursor could only add a
+* second truth that is wrong in the one direction that loses data.
+*
+* Loop-safety is structural: one entry per hash, created once, and every
+* retry decision is {@link nextAfter}'s. A terminal entry (`not-found`,
+* `failed`) is never re-queued by a further reference from a document it
+* already knows; a document it has not seen earns it one more attempt, through
+* that document. Otherwise only {@link AttachmentReplicator.retry} moves a
+* terminal entry back. A held hash drops its entry and is remembered in a
+* bounded set, so the map holds only unfinished work.
+*/
+var AttachmentReplicator = class {
+	store;
+	transport;
+	refs;
+	eventBus;
+	backlog;
+	concurrency;
+	policy;
+	backlogPageSize;
+	heldHashLimit;
+	verifyHash;
+	timers;
+	onDiagnostic;
+	entries = /* @__PURE__ */ new Map();
+	heldHashes = /* @__PURE__ */ new Set();
+	queue = [];
+	idleWaiters = [];
+	aborts = /* @__PURE__ */ new Set();
+	unsubscribe;
+	running = false;
+	inFlight = 0;
+	timerHandle;
+	timerAtMs;
+	backlogScan;
+	backlogDone = false;
+	lastError;
+	constructor(options) {
+		this.store = options.store;
+		this.transport = options.transport;
+		this.refs = options.refs;
+		this.eventBus = options.eventBus;
+		this.backlog = options.backlog;
+		this.concurrency = options.concurrency ?? 3;
+		this.policy = {
+			...DEFAULT_ATTACHMENT_RETRY_POLICY,
+			...options.retry
+		};
+		this.backlogPageSize = options.backlogPageSize ?? 200;
+		this.heldHashLimit = options.heldHashLimit ?? 1e4;
+		this.verifyHash = options.verifyHash ?? true;
+		this.timers = options.timers ?? SYSTEM_REPLICATION_TIMERS;
+		this.onDiagnostic = options.onDiagnostic ?? (() => void 0);
+	}
+	/**
+	* Subscribes to committed operations and starts the boot re-scan.
+	*
+	* The subscription is taken BEFORE the scan so no operation committed during
+	* the scan can slip between the two. A hash both paths find is one entry.
+	*
+	* A restart resumes its own unfinished work: a `stop()` empties the queue but
+	* keeps the entries, so entries left `queued` or `waiting` are re-armed here.
+	* Without that, a hash that was outstanding at `stop()` would sit in the map
+	* forever unless an unrelated live operation happened to pump the queue --
+	* the backlog re-scan does not rescue it, because `observeReference` treats
+	* an already-known hash as nothing to do.
+	*/
+	start() {
+		if (this.running) return;
+		this.running = true;
+		this.unsubscribe = this.eventBus.subscribe(ReactorEventTypes.JOB_READ_READY, (_type, event) => {
+			this.observeOperations(event.operations);
+		});
+		this.resumeOutstanding();
+		this.backlogScan = this.scanBacklog();
+	}
+	/**
+	* Stops scheduling, drops the subscription and aborts in-flight fetches.
+	*
+	* Entries are kept: the in-memory retry counters are not durable state and a
+	* restart legitimately starts the budgets over (a hash that was `not-found`
+	* because a peer's index lagged deserves another look after a reboot), but a
+	* `stop()` that is not a restart should not forget what is held either --
+	* `store.has()` is re-checked before every fetch regardless.
+	*/
+	async stop() {
+		this.running = false;
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		this.cancelTimer();
+		for (const controller of this.aborts) controller.abort();
+		this.aborts.clear();
+		this.queue.length = 0;
+		const scan = this.backlogScan;
+		this.backlogScan = void 0;
+		if (scan) await scan.catch(() => void 0);
+	}
+	/** Notes every ref carried by `items`. Synchronous: it only enqueues. */
+	observeOperations(items) {
+		for (const item of items) for (const ref of this.refs.refsOf(item)) this.observeReference(item.context.documentId, ref);
+	}
+	/** Notes one (document, ref) pair, queueing the hash if it is new. */
+	observeReference(documentId, ref) {
+		let hash;
+		try {
+			hash = parseRef(ref).hash;
+		} catch (error) {
+			this.onDiagnostic(`ignoring malformed attachment ref ${ref}`, error);
+			return;
+		}
+		if (this.heldHashes.has(hash)) return;
+		const existing = this.entries.get(hash);
+		if (existing) {
+			if (existing.documentIds.includes(documentId)) return;
+			existing.documentIds.push(documentId);
+			const { entry, revive } = withDocument(existing.retry, documentId, existing.state);
+			existing.retry = entry;
+			if (revive) {
+				existing.state = "queued";
+				if (!this.queue.includes(hash)) this.queue.push(hash);
+				this.pump();
+			}
+			return;
+		}
+		this.entries.set(hash, {
+			hash,
+			state: "queued",
+			documentIds: [documentId],
+			attempts: 0,
+			retry: newRetryEntry(documentId),
+			nextAttemptAtMs: void 0,
+			lastError: void 0
+		});
+		this.queue.push(hash);
+		this.pump();
+	}
+	async status() {
+		const counts = {
+			queued: 0,
+			fetching: 0,
+			held: 0,
+			waiting: 0,
+			"not-found": 0,
+			failed: 0
+		};
+		for (const entry of this.entries.values()) counts[entry.state] += 1;
+		const bytesHeld = await this.store.storageUsed();
+		return {
+			running: this.running,
+			refsSeen: this.entries.size + this.heldHashes.size,
+			held: this.heldHashes.size,
+			bytesHeld,
+			queued: counts.queued,
+			fetching: counts.fetching,
+			waiting: counts.waiting,
+			notFound: counts["not-found"],
+			failed: counts.failed,
+			backlogScanned: this.backlogDone,
+			lastError: this.lastError
+		};
+	}
+	/** Every hash not yet held and what is happening to it. */
+	report() {
+		return [...this.entries.values()].map((entry) => ({
+			hash: entry.hash,
+			state: entry.state,
+			documentIds: [...entry.documentIds],
+			attempts: entry.attempts,
+			notFoundAnswers: entry.retry.notFoundAnswers,
+			nextAttemptAtMs: entry.nextAttemptAtMs,
+			lastError: entry.lastError
+		}));
+	}
+	/**
+	* Re-queues terminal entries so a `not-found` or `failed` hash is chased
+	* again, resetting their budgets. `hash` narrows it to one; absent, every
+	* terminal entry is retried.
+	*
+	* The deliberate manual lever over the reference-index race: when an
+	* operator can see that a peer has caught up, nothing should make them wait
+	* for a reboot to find out.
+	*/
+	retry(hash) {
+		const targets = hash ? [this.entries.get(hash)].filter((entry) => entry !== void 0) : [...this.entries.values()];
+		for (const entry of targets) {
+			if (entry.state === "held" || entry.state === "fetching") continue;
+			entry.state = "queued";
+			entry.retry = resetRetry(entry.documentIds);
+			entry.nextAttemptAtMs = void 0;
+			if (!this.queue.includes(entry.hash)) this.queue.push(entry.hash);
+		}
+		this.pump();
+	}
+	/**
+	* Resolves when nothing is queued or in flight.
+	*
+	* Entries `waiting` on a retry deadline do NOT hold this open -- their next
+	* attempt is the timer's business, and a caller that wants to reach it
+	* advances the injected clock. A test seam, and what a load harness waits on.
+	*/
+	idle() {
+		if (this.queue.length === 0 && this.inFlight === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.idleWaiters.push(resolve);
+		});
+	}
+	/** Awaits the boot re-scan; resolves immediately when there is no backlog. */
+	async backlogScanned() {
+		await this.backlogScan;
+	}
+	/** Re-queues every non-terminal entry a previous `stop()` stranded. */
+	resumeOutstanding() {
+		for (const entry of this.entries.values()) {
+			if (entry.state !== "queued" && entry.state !== "waiting") continue;
+			entry.state = "queued";
+			entry.nextAttemptAtMs = void 0;
+			if (!this.queue.includes(entry.hash)) this.queue.push(entry.hash);
+		}
+		this.pump();
+	}
+	async scanBacklog() {
+		const backlog = this.backlog;
+		if (!backlog) return;
+		let cursor;
+		for (;;) {
+			if (!this.running) return;
+			let page;
+			try {
+				page = await backlog.listReferences(cursor, this.backlogPageSize);
+			} catch (error) {
+				this.onDiagnostic("scanning the attachment reference backlog failed", error);
+				return;
+			}
+			for (const reference of page.references) this.observeReference(reference.documentId, reference.ref);
+			if (page.nextCursor === void 0) break;
+			cursor = page.nextCursor;
+		}
+		this.backlogDone = true;
+	}
+	/** Starts as many queued fetches as the concurrency bound allows. */
+	pump() {
+		while (this.running && this.inFlight < this.concurrency && this.queue.length > 0) {
+			const hash = this.queue.shift();
+			if (hash === void 0) break;
+			const entry = this.entries.get(hash);
+			if (!entry || entry.state !== "queued") continue;
+			this.fetchOne(entry);
+		}
+		this.settleIdle();
+	}
+	async fetchOne(entry) {
+		entry.state = "fetching";
+		entry.attempts += 1;
+		this.inFlight += 1;
+		const controller = new AbortController();
+		this.aborts.add(controller);
+		const documentId = documentToAsk(entry.retry) ?? entry.documentIds[0];
+		let outcome;
+		try {
+			outcome = await this.attempt(entry, documentId, controller.signal);
+		} catch (error) {
+			if (controller.signal.aborted) outcome = { kind: "aborted" };
+			else {
+				this.recordError(entry, error);
+				outcome = {
+					kind: "error",
+					documentId
+				};
+			}
+		}
+		try {
+			this.apply(entry, outcome);
+		} finally {
+			this.aborts.delete(controller);
+			this.inFlight -= 1;
+			this.pump();
+		}
+	}
+	async attempt(entry, documentId, signal) {
+		if (await this.store.has(entry.hash)) return { kind: "data" };
+		signal.throwIfAborted();
+		const result = await this.transport.fetch(entry.hash, documentId, signal);
+		if (result.kind === "pending" && result.busy) return {
+			kind: "busy",
+			documentId,
+			retryAfterMs: result.retryAfterMs,
+			othersNotFound: result.othersNotFound === true
+		};
+		if (result.kind === "pending") return {
+			kind: "pending",
+			documentId,
+			expiresAtUtc: result.expiresAtUtc,
+			retryAfterMs: result.retryAfterMs
+		};
+		if (result.kind === "not-found") return {
+			kind: "not-found",
+			documentId
+		};
+		const bytes = await collectStream(result.response.body);
+		if (this.verifyHash) {
+			const actual = await sha256Hex(bytes);
+			if (actual !== entry.hash) throw new Error(`Attachment bytes for ${entry.hash} hashed to ${actual}; the peer served content that is not what was asked for`);
+		}
+		await this.store.put(entry.hash, result.response.metadata, streamFromBytes(bytes));
+		return { kind: "data" };
+	}
+	apply(entry, outcome) {
+		const next = nextAfter(entry.retry, outcome, this.timers.now(), this.policy);
+		if (outcome.kind === "busy" && next.entry.errorRun > entry.retry.errorRun) this.recordError(entry, /* @__PURE__ */ new Error(`the attachment source stayed busy for ${entry.hash} through a full backoff`));
+		entry.retry = next.entry;
+		switch (next.state) {
+			case "held":
+				this.markHeld(entry);
+				return;
+			case "waiting":
+				this.schedule(entry, next.delayMs ?? 0);
+				return;
+			case "queued":
+				entry.state = "queued";
+				entry.nextAttemptAtMs = void 0;
+				if (this.running && !this.queue.includes(entry.hash)) this.queue.push(entry.hash);
+				return;
+			case "not-found":
+			case "failed":
+				entry.state = next.state;
+				entry.nextAttemptAtMs = void 0;
+				return;
+		}
+	}
+	markHeld(entry) {
+		entry.state = "held";
+		entry.nextAttemptAtMs = void 0;
+		this.entries.delete(entry.hash);
+		this.heldHashes.delete(entry.hash);
+		this.heldHashes.add(entry.hash);
+		for (const oldest of this.heldHashes) {
+			if (this.heldHashes.size <= this.heldHashLimit) break;
+			this.heldHashes.delete(oldest);
+		}
+	}
+	recordError(entry, error) {
+		const message = error instanceof Error ? error.message : String(error);
+		entry.lastError = message;
+		this.lastError = message;
+		this.onDiagnostic(`fetching attachment ${entry.hash} failed`, error);
+	}
+	schedule(entry, delayMs) {
+		entry.state = "waiting";
+		entry.nextAttemptAtMs = this.timers.now() + Math.min(Math.max(delayMs, 0), MAX_TIMER_DELAY_MS);
+		this.armTimer();
+	}
+	/** Keeps exactly one timer, set to the earliest outstanding deadline. */
+	armTimer() {
+		if (!this.running) return;
+		let earliest;
+		for (const entry of this.entries.values()) {
+			if (entry.state !== "waiting" || entry.nextAttemptAtMs === void 0) continue;
+			if (earliest === void 0 || entry.nextAttemptAtMs < earliest) earliest = entry.nextAttemptAtMs;
+		}
+		if (earliest === void 0) {
+			this.cancelTimer();
+			return;
+		}
+		if (this.timerAtMs !== void 0 && this.timerAtMs <= earliest) return;
+		this.cancelTimer();
+		this.timerAtMs = earliest;
+		this.timerHandle = this.timers.setTimer(() => this.onTimer(), Math.max(earliest - this.timers.now(), 0));
+	}
+	onTimer() {
+		this.timerHandle = void 0;
+		this.timerAtMs = void 0;
+		if (!this.running) return;
+		const nowMs = this.timers.now();
+		for (const entry of this.entries.values()) if (entry.state === "waiting" && entry.nextAttemptAtMs !== void 0 && entry.nextAttemptAtMs <= nowMs) {
+			entry.state = "queued";
+			entry.nextAttemptAtMs = void 0;
+			if (!this.queue.includes(entry.hash)) this.queue.push(entry.hash);
+		}
+		this.pump();
+		this.armTimer();
+	}
+	cancelTimer() {
+		if (this.timerHandle !== void 0) this.timers.clearTimer(this.timerHandle);
+		this.timerHandle = void 0;
+		this.timerAtMs = void 0;
+	}
+	settleIdle() {
+		if (this.queue.length > 0 || this.inFlight > 0) return;
+		for (const resolve of this.idleWaiters.splice(0)) resolve();
+	}
+};
+/** A scanner over a plain list, for a host without a reference index. */
+function staticAttachmentReferenceScanner(references) {
+	return { listReferences: (cursor, limit) => {
+		const start = cursor === void 0 ? 0 : Number(cursor);
+		const page = references.slice(start, start + limit);
+		const next = start + page.length;
+		return Promise.resolve({
+			references: page,
+			nextCursor: next < references.length ? String(next) : void 0
+		});
+	} };
+}
+//#endregion
+//#region src/replication/operation-attachment-refs.ts
+/**
+* The production {@link IOperationAttachmentRefs}: the compiled, schema-driven
+* extractor, reused rather than reimplemented.
+*
+* This is the same `(registry, compiler)` pair `AttachmentReferenceReadModel`
+* runs, so a ref the index records and a ref the replicator chases are found by
+* one piece of code -- including the compiler's per-module/per-action cache,
+* which is held by the compiler instance a host shares between the two. A host
+* with no read model to share one with takes the default compiler.
+*
+* Extraction failures do NOT propagate. A malformed ref or an unregistered
+* document type must not take down the event-bus subscriber the replicator
+* runs on: that would turn an attachment problem into a reactor-wide write
+* failure, since `IEventBus.emit` aggregates subscriber errors back to the
+* emitter. The read model is the component whose job is to refuse a bad ref
+* loudly; this one is a best-effort byte chaser, so it reports and moves on.
+*/
+var SchemaCompiledOperationRefs = class {
+	registry;
+	compiler;
+	onDiagnostic;
+	constructor(registry, compiler = new AttachmentSchemaCompiler(), onDiagnostic = () => void 0) {
+		this.registry = registry;
+		this.compiler = compiler;
+		this.onDiagnostic = onDiagnostic;
+	}
+	refsOf(item) {
+		const { operation, context } = item;
+		if (isPurgeMarker(operation) || operation.error !== void 0) return [];
+		try {
+			const module = this.registry.getModule(context.documentType);
+			return this.compiler.forModuleAction(module, operation.action.type).extract(operation.action);
+		} catch (error) {
+			this.onDiagnostic(`extracting attachment refs from ${context.documentType}/${operation.action.type} failed`, error);
+			return [];
+		}
+	}
+};
+//#endregion
+//#region src/storage/local/idb-attachment-backend.ts
+/** Metadata rows, keyed by content hash. */
+const IDB_RECORD_STORE = "records";
+/** Blob rows (`{ hash, bytes }`), keyed by the same content hash. */
+const IDB_BLOB_STORE = "blobs";
+/** Index over {@link LocalAttachmentRecord.status}; what `storageUsed()` scans. */
+const IDB_STATUS_INDEX = "by_status";
+/** Default database name. One database holds one reactor's attachment store. */
+const DEFAULT_IDB_DATABASE = "ph-attachments";
+const IDB_VERSION = 1;
+function requestResult(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB request failed"));
+	});
+}
+function transactionDone(transaction) {
+	return new Promise((resolve, reject) => {
+		transaction.oncomplete = () => resolve();
+		transaction.onabort = () => reject(transaction.error ?? /* @__PURE__ */ new Error("IndexedDB transaction aborted"));
+		transaction.onerror = () => reject(transaction.error ?? /* @__PURE__ */ new Error("IndexedDB transaction failed"));
+	});
+}
+function toArrayBuffer(bytes) {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+}
+/**
+* An IndexedDB-backed {@link ILocalAttachmentBackend}: the browser-resident
+* attachment store a reactor in a tab or a SharedWorker replicates into.
+*
+* Two object stores, written in one transaction so a record and its blob land
+* or fail together (the atomicity {@link ILocalAttachmentBackend.write}
+* requires). Bytes are kept as `ArrayBuffer` rather than `Blob`: both are
+* structured-clone-safe values IndexedDB stores natively, and an ArrayBuffer
+* needs no async read to get back to the `Uint8Array` the store serves.
+*
+* OPFS is the obvious later alternative for large blobs -- it streams and does
+* not hold a whole attachment in the realm's heap -- and nothing above this
+* interface would change: it is one more backend.
+*
+* The database handle is opened lazily on first use and reused, so constructing
+* this in a realm that has no `indexedDB` (a Node import of the barrel) costs
+* nothing and fails only if something actually reads or writes.
+*/
+var IdbAttachmentBackend = class {
+	databaseName;
+	factory;
+	opening;
+	database;
+	closed = false;
+	constructor(options = {}) {
+		this.databaseName = options.databaseName ?? "ph-attachments";
+		this.factory = options.indexedDB ?? globalThis.indexedDB;
+	}
+	async readRecord(hash) {
+		return await requestResult((await this.open()).transaction("records", "readonly").objectStore("records").get(hash)) ?? void 0;
+	}
+	async write(record, bytes) {
+		const transaction = (await this.open()).transaction([IDB_RECORD_STORE, IDB_BLOB_STORE], "readwrite");
+		const row = {
+			hash: record.hash,
+			bytes: toArrayBuffer(bytes)
+		};
+		transaction.objectStore(IDB_RECORD_STORE).put(record);
+		transaction.objectStore(IDB_BLOB_STORE).put(row);
+		await transactionDone(transaction);
+	}
+	async readBytes(hash) {
+		const row = await requestResult((await this.open()).transaction(IDB_BLOB_STORE, "readonly").objectStore(IDB_BLOB_STORE).get(hash));
+		return row ? new Uint8Array(row.bytes) : void 0;
+	}
+	async evict(record) {
+		const transaction = (await this.open()).transaction([IDB_RECORD_STORE, IDB_BLOB_STORE], "readwrite");
+		transaction.objectStore(IDB_RECORD_STORE).put(record);
+		transaction.objectStore(IDB_BLOB_STORE).delete(record.hash);
+		await transactionDone(transaction);
+	}
+	async touch(hash, lastAccessedAtUtc) {
+		const transaction = (await this.open()).transaction(IDB_RECORD_STORE, "readwrite");
+		const store = transaction.objectStore(IDB_RECORD_STORE);
+		const existing = await requestResult(store.get(hash));
+		if (existing) store.put({
+			...existing,
+			lastAccessedAtUtc
+		});
+		await transactionDone(transaction);
+	}
+	async availableBytes() {
+		return (await requestResult((await this.open()).transaction(IDB_RECORD_STORE, "readonly").objectStore(IDB_RECORD_STORE).index(IDB_STATUS_INDEX).getAll("available"))).reduce((total, row) => total + row.sizeBytes, 0);
+	}
+	close() {
+		this.closed = true;
+		this.database?.close();
+		this.database = void 0;
+		this.opening = void 0;
+		return Promise.resolve();
+	}
+	open() {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error(`IndexedDB attachment backend for database "${this.databaseName}" is closed`));
+		if (this.database) return Promise.resolve(this.database);
+		if (!this.opening) {
+			const opening = this.openDatabase();
+			this.opening = opening;
+			opening.catch(() => {
+				if (this.opening === opening) this.opening = void 0;
+			});
+		}
+		return this.opening;
+	}
+	openDatabase() {
+		const factory = this.factory;
+		if (!factory) return Promise.reject(/* @__PURE__ */ new Error("No IndexedDB in this realm; the IndexedDB attachment backend needs a browser realm or an injected IDBFactory"));
+		const request = factory.open(this.databaseName, IDB_VERSION);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains("records")) db.createObjectStore(IDB_RECORD_STORE, { keyPath: "hash" }).createIndex(IDB_STATUS_INDEX, "status", { unique: false });
+			if (!db.objectStoreNames.contains("blobs")) db.createObjectStore(IDB_BLOB_STORE, { keyPath: "hash" });
+		};
+		return requestResult(request).then((db) => {
+			if (this.closed) {
+				db.close();
+				throw new Error(`IndexedDB attachment backend for database "${this.databaseName}" is closed`);
+			}
+			this.database = db;
+			const forget = () => {
+				if (this.database === db) {
+					this.database = void 0;
+					this.opening = void 0;
+				}
+			};
+			db.onversionchange = () => {
+				db.close();
+				forget();
+			};
+			db.onclose = forget;
+			return db;
+		});
+	}
+};
+//#endregion
+//#region src/storage/local/local-attachment-store.ts
+function headerOf(record) {
+	return {
+		hash: record.hash,
+		mimeType: record.mimeType,
+		fileName: record.fileName,
+		sizeBytes: record.sizeBytes,
+		extension: record.extension,
+		status: record.status,
+		source: record.source,
+		createdAtUtc: record.createdAtUtc,
+		lastAccessedAtUtc: record.lastAccessedAtUtc,
+		expiresAtUtc: null
+	};
+}
+/**
+* A realm-resident, content-addressed {@link IAttachmentStore} over a
+* {@link ILocalAttachmentBackend} -- the browser-capable half of attachment
+* byte movement.
+*
+* The same class serves both backends, so an IndexedDB store in a tab and the
+* memory twin a Node test runs cannot diverge in behaviour: every semantic the
+* `IAttachmentStore` contract states is implemented once, here.
+*
+* Differences from `KyselyAttachmentStore`, all of them deliberate:
+*
+* - No reservation table, so `stat()`/`get()` never synthesize `pending` from
+*   local state. `pending` only ever arrives as a TRANSPORT answer, which
+*   `get()` raises as {@link AttachmentPending} exactly as the Kysely store
+*   does for a remote pending.
+* - `get()` reads the whole blob before it hands back a stream, so there is no
+*   such thing as an in-flight read for `evict()` to destroy. The contract's
+*   "skip hashes with active readers" clause is satisfied by construction
+*   rather than by a refcount; a caller already holding a stream holds a
+*   snapshot.
+* - `sizeBytes` is the measured length of the bytes received, not the
+*   producer's `AttachmentMetadata.sizeBytes` claim, so `storageUsed()` cannot
+*   be talked into a wrong number by a remote.
+*/
+var LocalAttachmentStore = class {
+	backend;
+	transport;
+	now;
+	constructor(backend, transport, now = () => /* @__PURE__ */ new Date()) {
+		this.backend = backend;
+		this.transport = transport;
+		this.now = now;
+	}
+	async stat(hash) {
+		const record = await this.backend.readRecord(hash);
+		if (!record) throw new AttachmentNotFound(hash);
+		return headerOf(record);
+	}
+	async has(hash) {
+		return (await this.backend.readRecord(hash))?.status === "available";
+	}
+	async get(hash, signal, documentId) {
+		const record = await this.backend.readRecord(hash);
+		if (!record || record.status === "evicted") return this.fetchRemote(hash, signal, documentId);
+		const bytes = await this.backend.readBytes(hash);
+		if (!bytes) return this.fetchRemote(hash, signal, documentId);
+		const accessedAt = this.now().toISOString();
+		await this.backend.touch(hash, accessedAt);
+		return {
+			header: {
+				...headerOf(record),
+				lastAccessedAtUtc: accessedAt
+			},
+			body: streamFromBytes(bytes)
+		};
+	}
+	put(hash, metadata, data) {
+		return this.store(hash, metadata, data, "sync", false);
+	}
+	async evict(hash) {
+		const record = await this.backend.readRecord(hash);
+		if (!record || record.status === "evicted") return;
+		await this.backend.evict({
+			...record,
+			status: "evicted"
+		});
+	}
+	storageUsed() {
+		return this.backend.availableBytes();
+	}
+	/** Releases the backend handle. */
+	close() {
+		return this.backend.close();
+	}
+	/**
+	* Stores bytes this realm produced itself, as `source: "local"`.
+	*
+	* `put()` is the transport's entry point and marks everything `sync`, which
+	* is the right provenance for a replicated blob and the wrong one for a blob
+	* that originated here. The server-side store gets `source: "local"` rows
+	* from its upload handles; a local store has no upload handle, so this is
+	* how a producer (an editor that just hashed a file, a test that seeds a
+	* peer) says the bytes are its own.
+	*/
+	putLocal(hash, metadata, data) {
+		return this.store(hash, metadata, data, "local", false);
+	}
+	/**
+	* `overwrite` skips the available-hash dedup check.
+	*
+	* Only {@link fetchRemote} sets it, and only because it is reached when the
+	* local copy is unusable -- including the torn case where the record says
+	* `available` over a missing blob. Without it, that record would deduplicate
+	* away its own repair and the hash could never be restored.
+	*/
+	async store(hash, metadata, data, source, overwrite) {
+		const existing = await this.backend.readRecord(hash);
+		if (!overwrite && existing?.status === "available") {
+			await data.cancel();
+			return;
+		}
+		const bytes = await collectStream(data);
+		await this.backend.write({
+			hash,
+			mimeType: metadata.mimeType,
+			fileName: metadata.fileName,
+			sizeBytes: bytes.byteLength,
+			extension: metadata.extension ?? null,
+			status: "available",
+			source: existing?.source ?? source,
+			createdAtUtc: existing?.createdAtUtc ?? metadata.createdAtUtc,
+			lastAccessedAtUtc: this.now().toISOString()
+		}, bytes);
+	}
+	/**
+	* Restores `hash` from the transport on behalf of `documentId`, persists it
+	* through the same write path `put` uses (so provenance follows one rule)
+	* and serves the result from the store rather than from the transport's
+	* stream, which has already been consumed.
+	*
+	* The fetched bytes are hashed and refused when they are not what was asked
+	* for, mirroring {@link AttachmentReplicator}: a transport peer is another
+	* reactor rather than a trusted server, and a content-addressed store that
+	* accepts bytes it never verified is no longer content-addressed. A mismatch
+	* is surfaced as an error and nothing is written, so a lying peer cannot
+	* poison the store.
+	*/
+	async fetchRemote(hash, signal, documentId) {
+		if (documentId === void 0) throw new AttachmentNotFound(hash);
+		const remote = await this.transport.fetch(hash, documentId, signal);
+		if (remote.kind === "pending") throw new AttachmentPending(hash, remote.expiresAtUtc);
+		if (remote.kind === "not-found") throw new AttachmentNotFound(hash);
+		const fetchedBytes = await collectStream(remote.response.body);
+		const actual = await sha256Hex(fetchedBytes);
+		if (actual !== hash) throw new Error(`Attachment bytes for ${hash} hashed to ${actual}; the transport served content that is not what was asked for`);
+		await this.store(hash, remote.response.metadata, streamFromBytes(fetchedBytes), "sync", true);
+		const record = await this.backend.readRecord(hash);
+		const bytes = await this.backend.readBytes(hash);
+		if (!record || record.status !== "available" || !bytes) throw new AttachmentNotFound(hash);
+		return {
+			header: headerOf(record),
+			body: streamFromBytes(bytes)
+		};
+	}
+};
+//#endregion
+//#region src/storage/local/memory-attachment-backend.ts
+/**
+* The in-realm memory twin of {@link IdbAttachmentBackend}.
+*
+* It exists so the whole {@link LocalAttachmentStore} contract -- and the
+* replicator above it -- is testable in Node without an IndexedDB shim, and so
+* a reactor that wants a deliberately ephemeral attachment store (a test, a
+* throwaway reactor) has one. The backend contract suite runs against
+* this and against the IndexedDB backend, so the two answer identically.
+*
+* Records are copied in and out: a caller mutating a returned record must not
+* be able to change what the store holds, which is the behaviour a real
+* persistence layer has for free.
+*/
+var MemoryAttachmentBackend = class {
+	records = /* @__PURE__ */ new Map();
+	blobs = /* @__PURE__ */ new Map();
+	readRecord(hash) {
+		const record = this.records.get(hash);
+		return Promise.resolve(record ? { ...record } : void 0);
+	}
+	write(record, bytes) {
+		this.records.set(record.hash, { ...record });
+		this.blobs.set(record.hash, bytes.slice());
+		return Promise.resolve();
+	}
+	readBytes(hash) {
+		const bytes = this.blobs.get(hash);
+		return Promise.resolve(bytes ? bytes.slice() : void 0);
+	}
+	evict(record) {
+		this.records.set(record.hash, { ...record });
+		this.blobs.delete(record.hash);
+		return Promise.resolve();
+	}
+	touch(hash, lastAccessedAtUtc) {
+		const record = this.records.get(hash);
+		if (record) this.records.set(hash, {
+			...record,
+			lastAccessedAtUtc
+		});
+		return Promise.resolve();
+	}
+	availableBytes() {
+		let total = 0;
+		for (const record of this.records.values()) if (record.status === "available") total += record.sizeBytes;
+		return Promise.resolve(total);
+	}
+	close() {
+		this.records.clear();
+		this.blobs.clear();
+		return Promise.resolve();
+	}
+};
+//#endregion
+export { ATTACHMENT_READ_BRANCH, ATTACHMENT_READ_SCOPE, AttachmentPeerLinks, AttachmentReplicator, DEFAULT_ATTACHMENT_BACKLOG_PAGE_SIZE, DEFAULT_ATTACHMENT_HELD_HASH_LIMIT, DEFAULT_ATTACHMENT_REPLICATION_CONCURRENCY, DEFAULT_ATTACHMENT_RETRY_POLICY, DEFAULT_IDB_DATABASE, DEFAULT_LOCAL_CHUNK_BYTES, DEFAULT_LOCAL_MAX_CONCURRENT_SERVES, DEFAULT_LOCAL_REQUEST_TIMEOUT_MS, IDB_BLOB_STORE, IDB_RECORD_STORE, IDB_STATUS_INDEX, IdbAttachmentBackend, LOCAL_ATTACHMENT_PROTOCOL, LocalAttachmentServer, LocalAttachmentStore, LocalAttachmentTransport, MemoryAttachmentBackend, PeeredAttachmentTransport, SYSTEM_REPLICATION_TIMERS, SchemaCompiledOperationRefs, attachmentOriginOf, collectStream, isAttachmentHash, isLocalAttachmentRequest, isLocalAttachmentResponse, readGateAllowsAttachmentRead, readGateAttachmentAuthorizer, scopeGateAllowsAttachmentRead, sha256Hex, staticAttachmentReferenceScanner, streamFromBytes };
+
+//# sourceMappingURL=replication.js.map