@dxos/teleport-extension-object-sync 0.10.0 → 0.11.1

package/dist/lib/index.mjs

@@ -0,0 +1,688 @@
+import { DeferredTask, Mutex, Trigger, sleep, synchronized, trackLeaks } from "@dxos/async";
+import { Context, cancelWithContext } from "@dxos/context";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { RpcClosedError } from "@dxos/protocols";
+import { schema } from "@dxos/protocols/proto";
+import { RpcExtension } from "@dxos/teleport";
+import { BitField, ComplexMap, arrayToBuffer } from "@dxos/util";
+import { PublicKey } from "@dxos/keys";
+import { BlobMeta } from "@dxos/protocols/proto/dxos/echo/blob";
+import * as EffectContext from "effect/Context";
+import path from "@dxos/node-std/path";
+import { subtleCrypto } from "@dxos/crypto";
+import * as SqlClient from "@effect/sql/SqlClient";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { RuntimeProvider } from "@dxos/effect";
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/blob-sync-extension.ts
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/core/mesh/teleport-extension-object-sync/src/blob-sync-extension.ts";
+var MIN_WANT_LIST_UPDATE_INTERVAL = process.env.NODE_ENV === "test" ? 5 : 500;
+var MAX_CONCURRENT_UPLOADS = 20;
+/**
+* Manages replication between a set of feeds for a single teleport session.
+*/
+var BlobSyncExtension = class extends RpcExtension {
+	_params;
+	_ctx = new Context({ onError: (err) => log.catch(err, void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 35,
+		S: this
+	}) }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 35
+	});
+	_lastWantListUpdate = 0;
+	_localWantList = { blobs: [] };
+	_updateWantList = new DeferredTask(this._ctx, async () => {
+		if (this._lastWantListUpdate + MIN_WANT_LIST_UPDATE_INTERVAL > Date.now()) {
+			await sleep(this._lastWantListUpdate + MIN_WANT_LIST_UPDATE_INTERVAL - Date.now());
+			if (this._ctx.disposed) return;
+		}
+		log("want", { list: this._localWantList }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 49,
+			S: this
+		});
+		await this.rpc.BlobSyncService.want(this._localWantList);
+		this._lastWantListUpdate = Date.now();
+	});
+	_currentUploads = 0;
+	_upload = new DeferredTask(this._ctx, async () => {
+		if (this._currentUploads >= MAX_CONCURRENT_UPLOADS) return;
+		const blobChunks = await this._pickBlobChunks(MAX_CONCURRENT_UPLOADS - this._currentUploads);
+		if (!blobChunks) return;
+		for (const blobChunk of blobChunks) {
+			if (this._ctx.disposed) break;
+			this._currentUploads++;
+			this.push(blobChunk).catch((err) => {
+				if (err instanceof RpcClosedError) return;
+				log.warn("push failed", { err }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$3,
+					L: 76,
+					S: this
+				});
+			}).finally(() => {
+				this._currentUploads--;
+				this.reconcileUploads();
+			});
+		}
+	});
+	/**
+	* Set of id's remote peer wants.
+	*/
+	remoteWantList = { blobs: [] };
+	constructor(_params) {
+		super({
+			exposed: { BlobSyncService: schema.getService("dxos.mesh.teleport.blobsync.BlobSyncService") },
+			requested: { BlobSyncService: schema.getService("dxos.mesh.teleport.blobsync.BlobSyncService") },
+			timeout: 2e4,
+			encodingOptions: { preserveAny: true }
+		});
+		this._params = _params;
+	}
+	async onOpen(context) {
+		log("open", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 108,
+			S: this
+		});
+		await super.onOpen(context);
+		await this._params.onOpen();
+	}
+	async onClose(err) {
+		log("close", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 114,
+			S: this
+		});
+		await this._ctx.dispose();
+		await this._params.onClose();
+		await super.onClose(err);
+	}
+	async onAbort(err) {
+		log("abort", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 121,
+			S: this
+		});
+		await this._ctx.dispose();
+		await this._params.onAbort();
+		await super.onAbort(err);
+	}
+	async getHandlers() {
+		return { BlobSyncService: {
+			want: async (wantList) => {
+				log("remote want", { remoteWantList: wantList }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$3,
+					L: 131,
+					S: this
+				});
+				this.remoteWantList = wantList;
+				this.reconcileUploads();
+			},
+			push: async (data) => {
+				log("received", { data }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$3,
+					L: 136,
+					S: this
+				});
+				await this._params.onPush(data);
+			}
+		} };
+	}
+	async push(data) {
+		if (this._ctx.disposed) return;
+		log("push", { data }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 148,
+			S: this
+		});
+		await this.rpc.BlobSyncService.push(data);
+	}
+	updateWantList(wantList) {
+		if (this._ctx.disposed) return;
+		this._localWantList = wantList;
+		this._updateWantList.schedule();
+	}
+	reconcileUploads() {
+		if (this._ctx.disposed) return;
+		this._upload.schedule();
+	}
+	async _pickBlobChunks(amount = 1) {
+		if (this._ctx.disposed) return;
+		if (!this.remoteWantList.blobs || this.remoteWantList.blobs?.length === 0) return;
+		const shuffled = [...this.remoteWantList.blobs].sort(() => Math.random() - .5);
+		const chunks = [];
+		for (const header of shuffled) {
+			const meta = await this._params.blobStore.getMeta(header.id);
+			if (!meta) continue;
+			invariant(meta.bitfield, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 187,
+				S: this,
+				A: ["meta.bitfield", ""]
+			});
+			invariant(meta.chunkSize, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 188,
+				S: this,
+				A: ["meta.chunkSize", ""]
+			});
+			invariant(meta.length, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 189,
+				S: this,
+				A: ["meta.length", ""]
+			});
+			if (header.chunkSize && header.chunkSize !== meta.chunkSize) {
+				log.warn("Invalid chunk size", {
+					header,
+					meta
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$3,
+					L: 192,
+					S: this
+				});
+				continue;
+			}
+			const requestBitfield = header.bitfield ?? BitField.ones(meta.length / meta.chunkSize);
+			const presentData = BitField.and(requestBitfield, meta.bitfield);
+			const chunkIndices = BitField.findIndexes(presentData).sort(() => Math.random() - .5);
+			for (const idx of chunkIndices) {
+				const chunkData = await this._params.blobStore.get(header.id, {
+					offset: idx * meta.chunkSize,
+					length: Math.min(meta.chunkSize, meta.length - idx * meta.chunkSize)
+				});
+				chunks.push({
+					id: header.id,
+					totalLength: meta.length,
+					chunkSize: meta.chunkSize,
+					chunkOffset: idx * meta.chunkSize,
+					payload: chunkData
+				});
+				if (chunks.length >= amount) return chunks;
+			}
+		}
+		return chunks;
+	}
+};
+__decorate([synchronized], BlobSyncExtension.prototype, "push", null);
+//#endregion
+//#region src/blob-sync.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/core/mesh/teleport-extension-object-sync/src/blob-sync.ts";
+var BlobSync = class BlobSync {
+	_params;
+	_ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$2,
+		L: 30
+	});
+	_mutex = new Mutex();
+	_downloadRequests = new ComplexMap((key) => PublicKey.from(key).toHex());
+	_extensions = /* @__PURE__ */ new Set();
+	constructor(_params) {
+		this._params = _params;
+	}
+	async open() {}
+	async close() {
+		await this._ctx.dispose();
+	}
+	/**
+	* Resolves when the object with the given id is fully downloaded in the blob store.
+	*
+	* @param id hex-encoded id of the object to download.
+	*/
+	async download(ctx, id) {
+		log("download", { id }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 53,
+			S: this
+		});
+		const request = await this._mutex.executeSynchronized(async () => {
+			const existingRequest = this._downloadRequests.get(id);
+			if (existingRequest) {
+				existingRequest.counter++;
+				return existingRequest;
+			}
+			const meta = await this._params.blobStore.getMeta(id);
+			const request = {
+				trigger: new Trigger(),
+				counter: 1,
+				want: {
+					id,
+					chunkSize: meta?.chunkSize,
+					bitfield: meta?.bitfield && Uint8Array.from(BitField.invert(meta.bitfield))
+				}
+			};
+			if (meta?.state === BlobMeta.State.FULLY_PRESENT) request.trigger.wake();
+			else {
+				this._downloadRequests.set(id, request);
+				this._updateExtensionsWantList();
+			}
+			return request;
+		});
+		ctx?.onDispose(() => this._mutex.executeSynchronized(async () => {
+			const request = this._downloadRequests.get(id);
+			if (!request) return;
+			if (--request.counter === 0) this._downloadRequests.delete(id);
+			this._updateExtensionsWantList();
+		}));
+		return ctx ? cancelWithContext(ctx, request.trigger.wait()) : request.trigger.wait();
+	}
+	createExtension() {
+		const extension = new BlobSyncExtension({
+			blobStore: this._params.blobStore,
+			onOpen: async () => {
+				log("extension opened", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 105,
+					S: this
+				});
+				this._extensions.add(extension);
+				extension.updateWantList(this._getWantList());
+			},
+			onClose: async () => {
+				log("extension closed", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 110,
+					S: this
+				});
+				this._extensions.delete(extension);
+			},
+			onAbort: async () => {
+				log("extension aborted", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 114,
+					S: this
+				});
+				this._extensions.delete(extension);
+			},
+			onPush: async (blobChunk) => {
+				if (!this._downloadRequests.has(blobChunk.id)) return;
+				log("received", { blobChunk }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 121,
+					S: this
+				});
+				const meta = await this._params.blobStore.setChunk(blobChunk);
+				if (meta.state === BlobMeta.State.FULLY_PRESENT) {
+					this._downloadRequests.get(blobChunk.id)?.trigger.wake();
+					this._downloadRequests.delete(blobChunk.id);
+				} else {
+					invariant(meta.bitfield, void 0, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$2,
+						L: 127,
+						S: this,
+						A: ["meta.bitfield", ""]
+					});
+					this._downloadRequests.get(blobChunk.id).want.bitfield = BitField.invert(meta.bitfield);
+				}
+				this._updateExtensionsWantList();
+				this._reconcileUploads();
+			}
+		});
+		return extension;
+	}
+	/**
+	* Notify extensions that a blob with the given id was added to the blob store.
+	*/
+	async notifyBlobAdded(_id) {
+		this._reconcileUploads();
+	}
+	_getWantList() {
+		return { blobs: Array.from(this._downloadRequests.values()).map((request) => request.want) };
+	}
+	_reconcileUploads() {
+		for (const extension of this._extensions) extension.reconcileUploads();
+	}
+	_updateExtensionsWantList() {
+		for (const extension of this._extensions) extension.updateWantList(this._getWantList());
+	}
+};
+BlobSync = __decorate([trackLeaks("open", "close")], BlobSync);
+//#endregion
+//#region src/blob-store.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/mesh/teleport-extension-object-sync/src/blob-store.ts";
+var DEFAULT_CHUNK_SIZE = 4096;
+/**
+* Effect service tag for {@link BlobStoreApi}.
+*/
+var BlobStoreApiService = class extends EffectContext.Tag("@dxos/teleport-extension-object-sync/BlobStoreApi")() {};
+var BlobMetaCodec$1 = schema.getCodecForType("dxos.echo.blob.BlobMeta");
+var BlobStore = class {
+	_directory;
+	constructor(_directory) {
+		this._directory = _directory;
+	}
+	async getMeta(id) {
+		return this._getMeta(id);
+	}
+	/**
+	* @throws If range is not available.
+	*/
+	async get(id, options = {}) {
+		const metadata = await this._getMeta(id);
+		if (!metadata) throw new Error("Blob not available");
+		const { offset = 0, length = metadata.length } = options;
+		if (offset + length > metadata.length) throw new Error("Invalid range");
+		if (metadata.state === BlobMeta.State.FULLY_PRESENT) return this._getDataFile(id).read(offset, length);
+		else if (options.offset === void 0 && options.length === void 0) throw new Error("Blob not available");
+		const beginChunk = Math.floor(offset / metadata.chunkSize);
+		const endChunk = Math.ceil((offset + length) / metadata.chunkSize);
+		invariant(metadata.bitfield, "Bitfield not present", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 81,
+			S: this,
+			A: ["metadata.bitfield", "'Bitfield not present'"]
+		});
+		invariant(metadata.bitfield.length * 8 >= endChunk, "Invalid bitfield length", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 82,
+			S: this,
+			A: ["metadata.bitfield.length * 8 >= endChunk", "'Invalid bitfield length'"]
+		});
+		if (!(BitField.count(metadata.bitfield, beginChunk, endChunk) === endChunk - beginChunk)) throw new Error("Blob not available");
+		return this._getDataFile(id).read(offset, length);
+	}
+	async list() {
+		const files = new Set((await this._directory.list()).map((f) => f.split("_")[0]));
+		const res = [];
+		for (const file of files) {
+			const id = PublicKey.from(file).asUint8Array();
+			const meta = await this._getMeta(id);
+			if (meta) res.push(meta);
+		}
+		return res;
+	}
+	async set(data) {
+		const id = new Uint8Array(await subtleCrypto.digest("SHA-256", data));
+		const bitfield = BitField.ones(data.length / DEFAULT_CHUNK_SIZE);
+		const meta = {
+			id,
+			state: BlobMeta.State.FULLY_PRESENT,
+			length: data.length,
+			chunkSize: DEFAULT_CHUNK_SIZE,
+			bitfield,
+			created: /* @__PURE__ */ new Date(),
+			updated: /* @__PURE__ */ new Date()
+		};
+		await this._getDataFile(id).write(0, arrayToBuffer(data));
+		await this._writeMeta(id, meta);
+		return meta;
+	}
+	async setChunk(chunk) {
+		let meta = await this._getMeta(chunk.id);
+		if (!meta) {
+			invariant(chunk.totalLength, "totalLength is not present", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 144,
+				S: this,
+				A: ["chunk.totalLength", "'totalLength is not present'"]
+			});
+			meta = {
+				id: chunk.id,
+				state: BlobMeta.State.PARTIALLY_PRESENT,
+				length: chunk.totalLength,
+				chunkSize: chunk.chunkSize ?? 4096,
+				created: /* @__PURE__ */ new Date()
+			};
+			meta.bitfield = BitField.zeros(meta.length / meta.chunkSize);
+		}
+		if (chunk.chunkSize && chunk.chunkSize !== meta.chunkSize) throw new Error("Invalid chunk size");
+		invariant(meta.bitfield, "Bitfield not present", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 159,
+			S: this,
+			A: ["meta.bitfield", "'Bitfield not present'"]
+		});
+		invariant(chunk.chunkOffset !== void 0, "chunkOffset is not present", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 160,
+			S: this,
+			A: ["chunk.chunkOffset !== undefined", "'chunkOffset is not present'"]
+		});
+		await this._getDataFile(chunk.id).write(chunk.chunkOffset, arrayToBuffer(chunk.payload));
+		BitField.set(meta.bitfield, Math.floor(chunk.chunkOffset / meta.chunkSize), true);
+		if (BitField.count(meta.bitfield, 0, meta.length) * meta.chunkSize >= meta.length) meta.state = BlobMeta.State.FULLY_PRESENT;
+		meta.updated = /* @__PURE__ */ new Date();
+		await this._writeMeta(chunk.id, meta);
+		return meta;
+	}
+	async _writeMeta(id, meta) {
+		const encoded = arrayToBuffer(BlobMetaCodec$1.encode(meta));
+		const data = Buffer.alloc(encoded.length + 4);
+		data.writeUInt32LE(encoded.length, 0);
+		encoded.copy(data, 4);
+		await this._getMetaFile(id).write(0, data);
+	}
+	async _getMeta(id) {
+		const file = this._getMetaFile(id);
+		const size = (await file.stat()).size;
+		if (size === 0) return;
+		const data = await file.read(0, size);
+		const protoSize = data.readUInt32LE(0);
+		return BlobMetaCodec$1.decode(data.subarray(4, protoSize + 4));
+	}
+	_getMetaFile(id) {
+		return this._directory.getOrCreateFile(path.join(arrayToBuffer(id).toString("hex"), "meta"));
+	}
+	_getDataFile(id) {
+		return this._directory.getOrCreateFile(path.join(arrayToBuffer(id).toString("hex"), "data"));
+	}
+};
+__decorate([synchronized], BlobStore.prototype, "getMeta", null);
+__decorate([synchronized], BlobStore.prototype, "get", null);
+__decorate([synchronized], BlobStore.prototype, "list", null);
+__decorate([synchronized], BlobStore.prototype, "set", null);
+__decorate([synchronized], BlobStore.prototype, "setChunk", null);
+//#endregion
+//#region src/sqlite-blob-store.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/teleport-extension-object-sync/src/sqlite-blob-store.ts";
+var BlobMetaCodec = schema.getCodecForType("dxos.echo.blob.BlobMeta");
+/**
+* SQLite-backed BlobStore.
+* Stores blob metadata and data in `blobs_meta` and `blobs_data` tables.
+*/
+var SqliteBlobStore = class {
+	#runtime;
+	constructor({ runtime }) {
+		this.#runtime = runtime;
+	}
+	/**
+	* Creates the blobs_meta and blobs_data tables if they do not exist.
+	*/
+	migrate = Effect.fn("SqliteBlobStore.migrate")(() => Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		yield* sql`CREATE TABLE IF NOT EXISTS blobs_meta (
+          id TEXT PRIMARY KEY,
+          meta BLOB NOT NULL
+        )`;
+		yield* sql`CREATE TABLE IF NOT EXISTS blobs_data (
+          id TEXT PRIMARY KEY,
+          data BLOB NOT NULL
+        )`;
+		log("blobs tables ready", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 59,
+			S: this
+		});
+	}).pipe(Effect.withSpan("SqliteBlobStore.migrate")))();
+	async getMeta(id) {
+		return this.#getMeta(id);
+	}
+	async get(id, options = {}) {
+		const metadata = await this.#getMeta(id);
+		if (!metadata) throw new Error("Blob not available");
+		const { offset = 0, length = metadata.length } = options;
+		if (!Number.isInteger(offset) || !Number.isInteger(length) || offset < 0 || length < 0 || offset + length > metadata.length) throw new Error("Invalid range");
+		if (metadata.state === BlobMeta.State.FULLY_PRESENT) {
+			const data = await this.#getData(id);
+			if (!data) throw new Error("Blob data missing");
+			return data.subarray(offset, offset + length);
+		} else if (options.offset === void 0 && options.length === void 0) throw new Error("Blob not available");
+		const beginChunk = Math.floor(offset / metadata.chunkSize);
+		const endChunk = Math.ceil((offset + length) / metadata.chunkSize);
+		invariant(metadata.bitfield, "Bitfield not present", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 98,
+			S: this,
+			A: ["metadata.bitfield", "'Bitfield not present'"]
+		});
+		invariant(metadata.bitfield.length * 8 >= endChunk, "Invalid bitfield length", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 99,
+			S: this,
+			A: ["metadata.bitfield.length * 8 >= endChunk", "'Invalid bitfield length'"]
+		});
+		if (!(BitField.count(metadata.bitfield, beginChunk, endChunk) === endChunk - beginChunk)) throw new Error("Blob not available");
+		const data = await this.#getData(id);
+		if (!data) throw new Error("Blob data missing");
+		return data.subarray(offset, offset + length);
+	}
+	async list() {
+		return (await RuntimeProvider.runPromise(this.#runtime)(Effect.gen(function* () {
+			return yield* (yield* SqlClient.SqlClient)`SELECT id, meta FROM blobs_meta`;
+		}))).map((row) => BlobMetaCodec.decode(row.meta));
+	}
+	async set(data) {
+		const id = new Uint8Array(await subtleCrypto.digest("SHA-256", data));
+		const bitfield = BitField.ones(Math.ceil(data.length / DEFAULT_CHUNK_SIZE));
+		const meta = {
+			id,
+			state: BlobMeta.State.FULLY_PRESENT,
+			length: data.length,
+			chunkSize: DEFAULT_CHUNK_SIZE,
+			bitfield,
+			created: /* @__PURE__ */ new Date(),
+			updated: /* @__PURE__ */ new Date()
+		};
+		const idHex = arrayToBuffer(id).toString("hex");
+		const encodedMeta = arrayToBuffer(BlobMetaCodec.encode(meta));
+		await RuntimeProvider.runPromise(this.#runtime)(Effect.gen(function* () {
+			const sql = yield* SqlClient.SqlClient;
+			yield* sql`INSERT OR REPLACE INTO blobs_meta (id, meta) VALUES (${idHex}, ${encodedMeta})`;
+			yield* sql`INSERT OR REPLACE INTO blobs_data (id, data) VALUES (${idHex}, ${data})`;
+		}));
+		return meta;
+	}
+	async setChunk(chunk) {
+		const idHex = arrayToBuffer(chunk.id).toString("hex");
+		let meta = await this.#getMeta(chunk.id);
+		if (!meta) {
+			invariant(chunk.totalLength, "totalLength is not present", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 155,
+				S: this,
+				A: ["chunk.totalLength", "'totalLength is not present'"]
+			});
+			meta = {
+				id: chunk.id,
+				state: BlobMeta.State.PARTIALLY_PRESENT,
+				length: chunk.totalLength,
+				chunkSize: chunk.chunkSize ?? 4096,
+				created: /* @__PURE__ */ new Date()
+			};
+			meta.bitfield = BitField.zeros(Math.ceil(meta.length / meta.chunkSize));
+		}
+		if (chunk.chunkSize && chunk.chunkSize !== meta.chunkSize) throw new Error("Invalid chunk size");
+		invariant(meta.bitfield, "Bitfield not present", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 170,
+			S: this,
+			A: ["meta.bitfield", "'Bitfield not present'"]
+		});
+		invariant(chunk.chunkOffset !== void 0, "chunkOffset is not present", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 171,
+			S: this,
+			A: ["chunk.chunkOffset !== undefined", "'chunkOffset is not present'"]
+		});
+		if (chunk.chunkOffset < 0 || chunk.chunkOffset + chunk.payload.length > meta.length) throw new Error("Invalid chunk range");
+		const existingData = await this.#getData(chunk.id) ?? new Uint8Array(meta.length);
+		const newData = Buffer.from(existingData);
+		Buffer.from(chunk.payload).copy(newData, chunk.chunkOffset);
+		BitField.set(meta.bitfield, Math.floor(chunk.chunkOffset / meta.chunkSize), true);
+		const totalChunks = Math.ceil(meta.length / meta.chunkSize);
+		if (BitField.count(meta.bitfield, 0, totalChunks) === totalChunks) meta.state = BlobMeta.State.FULLY_PRESENT;
+		meta.updated = /* @__PURE__ */ new Date();
+		const encodedMeta = arrayToBuffer(BlobMetaCodec.encode(meta));
+		chunk.id;
+		await RuntimeProvider.runPromise(this.#runtime)(Effect.gen(function* () {
+			const sql = yield* SqlClient.SqlClient;
+			yield* sql`INSERT OR REPLACE INTO blobs_meta (id, meta) VALUES (${idHex}, ${encodedMeta})`;
+			yield* sql`INSERT OR REPLACE INTO blobs_data (id, data) VALUES (${idHex}, ${newData})`;
+		}));
+		return meta;
+	}
+	async #getMeta(id) {
+		const idHex = arrayToBuffer(id).toString("hex");
+		const rows = await RuntimeProvider.runPromise(this.#runtime)(Effect.gen(function* () {
+			return yield* (yield* SqlClient.SqlClient)`SELECT meta FROM blobs_meta WHERE id = ${idHex}`;
+		}));
+		if (rows.length === 0) return;
+		return BlobMetaCodec.decode(rows[0].meta);
+	}
+	async #getData(id) {
+		const idHex = arrayToBuffer(id).toString("hex");
+		const rows = await RuntimeProvider.runPromise(this.#runtime)(Effect.gen(function* () {
+			return yield* (yield* SqlClient.SqlClient)`SELECT data FROM blobs_data WHERE id = ${idHex}`;
+		}));
+		if (rows.length === 0) return;
+		return rows[0].data;
+	}
+};
+__decorate([synchronized], SqliteBlobStore.prototype, "getMeta", null);
+__decorate([synchronized], SqliteBlobStore.prototype, "get", null);
+__decorate([synchronized], SqliteBlobStore.prototype, "list", null);
+__decorate([synchronized], SqliteBlobStore.prototype, "set", null);
+__decorate([synchronized], SqliteBlobStore.prototype, "setChunk", null);
+/**
+* Effect Layer constructing a {@link SqliteBlobStore} from the ambient SQL runtime.
+*/
+var SqliteBlobStoreLayer = () => Layer.effect(BlobStoreApiService, Effect.gen(function* () {
+	return new SqliteBlobStore({ runtime: yield* RuntimeProvider.currentRuntime() });
+}));
+//#endregion
+export { BlobStore, BlobStoreApiService, BlobSync, BlobSyncExtension, DEFAULT_CHUNK_SIZE, SqliteBlobStore, SqliteBlobStoreLayer };
+
+//# sourceMappingURL=index.mjs.map