any-store-js 0.1.0

package/dist/lib.es.js

@@ -0,0 +1,668 @@
+var ASYNC_SET_HANDLER = Symbol("row.asyncSetHandler"), DELETE_HANDLER = Symbol("row.deleteHandler"), Row = class {
+	rowID;
+	fields;
+	[ASYNC_SET_HANDLER];
+	[DELETE_HANDLER];
+	constructor(C, w, T, E) {
+		this.rowID = C, this.fields = { ...w }, Object.defineProperty(this, ASYNC_SET_HANDLER, {
+			value: T,
+			enumerable: !1,
+			configurable: !1,
+			writable: !1
+		}), Object.defineProperty(this, DELETE_HANDLER, {
+			value: E,
+			enumerable: !1,
+			configurable: !1,
+			writable: !1
+		});
+	}
+	get id() {
+		return this.rowID;
+	}
+	readField(e) {
+		return this.fields[e];
+	}
+	writeField(e, S) {
+		this.fields[e] = S;
+	}
+	async setAsync(S) {
+		await this[ASYNC_SET_HANDLER](this.rowID, S);
+	}
+	delete() {
+		return this[DELETE_HANDLER](this.rowID);
+	}
+	snapshot() {
+		return {
+			id: this.rowID,
+			...this.fields
+		};
+	}
+}, Table = class {
+	RowClass;
+	nextID = 1;
+	rowsByID = /* @__PURE__ */ new Map();
+	indexesByField = /* @__PURE__ */ new Map();
+	constructor(e, S, C) {
+		this.store = e, this.name = S, this.schema = C, this.RowClass = this.createRowClass();
+	}
+	insert(e) {
+		if (!this.store._canInsertRows()) throw Error("Cannot insert rows after replication is initialized");
+		return this.insertRow(e, !0);
+	}
+	insertRow(e, S, C, w) {
+		this.validateInput(e);
+		let T = this.tryUpsertUniqueIndexRow(e, S, w);
+		if (T) return T;
+		let E = typeof C == "number" ? C : this.nextID, D = this.createRow(E, e);
+		return this.nextID = Math.max(this.nextID, D.id + 1), this.rowsByID.set(D.id, D), this.indexRow(D), S && this.store._emitChange(this.store._buildChange({
+			kind: "row:insert",
+			tableName: this.name,
+			rowID: D.id,
+			fields: { ...e }
+		}, w)), D;
+	}
+	addIndexToField(e, S) {
+		if (!(e in this.schema)) throw TypeError(`Unknown field ${this.name}.${e}`);
+		if (this.indexesByField.has(e)) throw Error(`Index for field ${this.name}.${e} already exists`);
+		if (S.kind !== "hashmap") throw TypeError(`Unsupported index kind ${S.kind}`);
+		let C = {
+			kind: "hashmap",
+			unique: S.unique ?? !1,
+			rowIDsByEncodedValue: /* @__PURE__ */ new Map()
+		};
+		this.indexesByField.set(e, C);
+		for (let S of this.rowsByID.values()) this.indexRowField(S, e, C);
+	}
+	getByIndex(e, S) {
+		let C = this.indexesByField.get(e);
+		if (!C) throw Error(`Index for field ${this.name}.${e} does not exist`);
+		let w = this.encodeIndexValue(S), T = C.rowIDsByEncodedValue.get(w);
+		if (!T || T.size === 0) return null;
+		for (let e of T) {
+			let S = this.rowsByID.get(e);
+			if (S) return S;
+		}
+		return null;
+	}
+	get(e) {
+		return this.rowsByID.get(e) ?? null;
+	}
+	all() {
+		return Array.from(this.rowsByID.values());
+	}
+	values() {
+		return this.rowsByID.values();
+	}
+	filter(e) {
+		let S = [];
+		for (let C of this.rowsByID.values()) e(C) && S.push(C);
+		return S;
+	}
+	count() {
+		return this.rowsByID.size;
+	}
+	getByID(e) {
+		return this.get(e);
+	}
+	update(e, S) {
+		let C = this.rowsByID.get(e);
+		if (C) return this.validateInput(S, !0), Object.assign(C, S), C;
+	}
+	delete(e) {
+		if (!this.store._canSynchronouslyMutateRows()) throw Error("Replica rows cannot be modified synchronously; use setAsync instead");
+		return this.deleteByID(e, !0);
+	}
+	deleteByID(e, S) {
+		let C = this.rowsByID.get(e);
+		return C ? (this.unindexRow(C), this.rowsByID.delete(e), S && this.store._emitChange(this.store._buildChange({
+			kind: "row:delete",
+			tableName: this.name,
+			rowID: e
+		})), !0) : !1;
+	}
+	clear() {
+		this.rowsByID.clear();
+		for (let e of this.indexesByField.values()) e.rowIDsByEncodedValue.clear();
+		this.nextID = 1;
+	}
+	serialize() {
+		let e = {};
+		for (let S of Object.keys(this.schema)) e[S] = { kind: "key" };
+		return {
+			name: this.name,
+			schema: e,
+			indexes: Array.from(this.indexesByField.entries()).map(([e, S]) => ({
+				field: e,
+				kind: "hashmap",
+				unique: S.unique
+			})),
+			rows: Array.from(this.rowsByID.values(), (e) => e.snapshot())
+		};
+	}
+	_hydrate(e) {
+		this.clear();
+		for (let S of e) {
+			let { id: e, ...C } = S;
+			this.validateInput(C), this.insertRow(C, !1, e);
+		}
+	}
+	_applyChange(e) {
+		if (e.tableName !== this.name) return;
+		if (e.kind === "row:delete") {
+			this.store._runWithoutBroadcast(() => {
+				this.deleteByID(e.rowID, !1);
+			});
+			return;
+		}
+		if (e.kind === "row:insert") {
+			this.store._runWithoutBroadcast(() => {
+				this.insertRow(e.fields, !1, e.rowID, {
+					requestId: e.requestId,
+					sourceStoreId: e.sourceStoreId,
+					timestamp: e.timestamp,
+					version: e.version
+				});
+			});
+			return;
+		}
+		if (e.kind !== "row:update") return;
+		let S = this.rowsByID.get(e.rowID);
+		S && this.store._runWithoutBroadcast(() => {
+			this.setRowField(S, e.field, e.value, !1);
+		});
+	}
+	_processChangeRequest(e) {
+		if (e.kind !== "row:set-async" || e.tableName !== this.name) return;
+		let S = this.rowsByID.get(e.rowID);
+		if (!S) throw Error(`Row ${this.name}.${e.rowID} does not exist`);
+		let C = e.patch;
+		this.validateInput(C, !0);
+		for (let [C, w] of Object.entries(e.patch)) this.setRowField(S, C, w, !0, {
+			requestId: e.requestId,
+			sourceStoreId: e.sourceStoreId
+		});
+	}
+	createRow(e, S) {
+		let C = new this.RowClass(e, S);
+		return Object.preventExtensions(C), C;
+	}
+	createRowClass() {
+		let e = this;
+		class S extends Row {
+			constructor(S, C) {
+				super(S, C, async (S, C) => {
+					let w = e.store._buildChangeRequest({
+						kind: "row:set-async",
+						tableName: e.name,
+						rowID: S,
+						patch: C
+					});
+					await e.store.requestChange(e.store._encodeChangeRequest(w));
+				}, (S) => e.delete(S));
+			}
+		}
+		for (let C of Object.keys(this.schema)) Object.defineProperty(S.prototype, C, {
+			enumerable: !0,
+			configurable: !1,
+			get() {
+				return this.readField(C);
+			},
+			set(S) {
+				if (!e.store._canSynchronouslyMutateRows()) throw Error("Replica rows cannot be modified synchronously; use setAsync instead");
+				e.setRowField(this, C, S, !0);
+			}
+		});
+		return S;
+	}
+	setRowField(e, S, C, w, T) {
+		if (S === "id") throw TypeError("Row ID is immutable");
+		if (!(S in this.schema)) throw TypeError(`Unknown field ${this.name}.${S}`);
+		let E = this.toStoredFieldValue(S, C), D = this.indexesByField.get(S);
+		if (D) {
+			let C = e.readField(S);
+			this.unindexRowField(e, S, D, C);
+		}
+		e.writeField(S, E), D && this.indexRowField(e, S, D), w && this.store._emitChange(this.store._buildChange({
+			kind: "row:update",
+			tableName: this.name,
+			rowID: e.id,
+			field: S,
+			value: E
+		}, T));
+	}
+	validateInput(e, S = !1) {
+		for (let C in this.schema) {
+			if (!(C in e)) {
+				if (S) continue;
+				throw TypeError(`Missing required field ${this.name}.${C}`);
+			}
+			e[C];
+		}
+	}
+	toStoredFieldValue(e, S) {
+		return S;
+	}
+	indexRow(e) {
+		for (let [S, C] of this.indexesByField.entries()) this.indexRowField(e, S, C);
+	}
+	unindexRow(e) {
+		for (let [S, C] of this.indexesByField.entries()) this.unindexRowField(e, S, C);
+	}
+	indexRowField(e, S, C) {
+		let w = e.readField(S), T = this.encodeIndexValue(w), E = C.rowIDsByEncodedValue.get(T);
+		if (E || (E = /* @__PURE__ */ new Set(), C.rowIDsByEncodedValue.set(T, E)), C.unique && E.size > 0 && !E.has(e.id)) throw Error(`Unique index violation for field ${this.name}.${S} value ${T}`);
+		E.add(e.id);
+	}
+	tryUpsertUniqueIndexRow(e, S, C) {
+		let w = null;
+		for (let [S, C] of this.indexesByField.entries()) {
+			if (!C.unique || !(S in e)) continue;
+			let T = this.getIndexedRow(S, e[S]);
+			if (T) {
+				if (w && w.id !== T.id) throw Error(`Unique index conflict for insert into ${this.name}: indexes point to different existing rows`);
+				w = T;
+			}
+		}
+		if (!w) return null;
+		for (let [T, E] of Object.entries(e)) this.setRowField(w, T, E, S, C);
+		return w;
+	}
+	getIndexedRow(e, S) {
+		let C = this.indexesByField.get(e);
+		if (!C) return null;
+		let w = this.encodeIndexValue(S), T = C.rowIDsByEncodedValue.get(w);
+		if (!T || T.size === 0) return null;
+		for (let e of T) {
+			let S = this.rowsByID.get(e);
+			if (S) return S;
+		}
+		return null;
+	}
+	unindexRowField(e, S, C, w) {
+		let T = w ?? e.readField(S), E = this.encodeIndexValue(T), D = C.rowIDsByEncodedValue.get(E);
+		D && (D.delete(e.id), D.size === 0 && C.rowIDsByEncodedValue.delete(E));
+	}
+	encodeIndexValue(e) {
+		if (e === null) return "null";
+		let S = typeof e;
+		return S === "string" ? `s:${e}` : S === "number" ? `n:${e}` : S === "boolean" ? `b:${e}` : `j:${JSON.stringify(e)}`;
+	}
+}, OP_CHANGE = 1, OP_CHANGE_REQUEST = 2, OP_CHANGE_BATCH = 3, CHANGE_ROW_INSERT = 1, CHANGE_ROW_UPDATE = 2, CHANGE_ROW_DELETE = 3, VALUE_NULL = 0, VALUE_STRING = 1, VALUE_NUMBER = 2, VALUE_BOOLEAN = 3, VALUE_ARRAY = 4, VALUE_OBJECT = 5, BinaryWriter = class {
+	buffer;
+	view;
+	bytes;
+	offset = 0;
+	constructor(e = 256) {
+		this.buffer = new ArrayBuffer(e), this.view = new DataView(this.buffer), this.bytes = new Uint8Array(this.buffer);
+	}
+	ensureCapacity(e) {
+		let S = this.offset + e;
+		if (S <= this.buffer.byteLength) return;
+		let C = this.buffer.byteLength;
+		for (; C < S;) C *= 2;
+		let w = new ArrayBuffer(C), T = new Uint8Array(w);
+		T.set(this.bytes.subarray(0, this.offset)), this.buffer = w, this.bytes = T, this.view = new DataView(w);
+	}
+	writeByte(e) {
+		this.ensureCapacity(1), this.bytes[this.offset] = e & 255, this.offset += 1;
+	}
+	writeFloat64(e) {
+		this.ensureCapacity(8), this.view.setFloat64(this.offset, e, !0), this.offset += 8;
+	}
+	writeUint32(e) {
+		this.ensureCapacity(4), this.view.setUint32(this.offset, e, !0), this.offset += 4;
+	}
+	writeString(e) {
+		let S = new TextEncoder().encode(e);
+		this.writeUint32(S.length), this.ensureCapacity(S.length), this.bytes.set(S, this.offset), this.offset += S.length;
+	}
+	writeValue(e) {
+		if (e === null) {
+			this.writeByte(VALUE_NULL);
+			return;
+		}
+		if (typeof e == "string") {
+			this.writeByte(VALUE_STRING), this.writeString(e);
+			return;
+		}
+		if (typeof e == "number") {
+			this.writeByte(VALUE_NUMBER), this.writeFloat64(e);
+			return;
+		}
+		if (typeof e == "boolean") {
+			this.writeByte(VALUE_BOOLEAN), this.writeByte(e ? 1 : 0);
+			return;
+		}
+		if (Array.isArray(e)) {
+			this.writeByte(VALUE_ARRAY), this.writeUint32(e.length);
+			for (let S of e) this.writeValue(S);
+			return;
+		}
+		this.writeByte(VALUE_OBJECT);
+		let S = Object.entries(e);
+		this.writeUint32(S.length);
+		for (let [e, C] of S) this.writeString(e), this.writeValue(C);
+	}
+	toUint8Array() {
+		return this.bytes.slice(0, this.offset);
+	}
+}, BinaryReader = class {
+	offset = 0;
+	constructor(e) {
+		this.input = e;
+	}
+	readByte() {
+		this.ensureAvailable(1);
+		let e = this.input[this.offset];
+		return this.offset += 1, e;
+	}
+	readFloat64() {
+		this.ensureAvailable(8);
+		let e = new DataView(this.input.buffer, this.input.byteOffset + this.offset, 8).getFloat64(0, !0);
+		return this.offset += 8, e;
+	}
+	readUint32() {
+		this.ensureAvailable(4);
+		let e = new DataView(this.input.buffer, this.input.byteOffset + this.offset, 4).getUint32(0, !0);
+		return this.offset += 4, e;
+	}
+	readString() {
+		let e = this.readUint32();
+		this.ensureAvailable(e);
+		let S = new TextDecoder().decode(this.input.subarray(this.offset, this.offset + e));
+		return this.offset += e, S;
+	}
+	readValue() {
+		let e = this.readByte();
+		if (e === VALUE_NULL) return null;
+		if (e === VALUE_STRING) return this.readString();
+		if (e === VALUE_NUMBER) return this.readFloat64();
+		if (e === VALUE_BOOLEAN) return this.readByte() === 1;
+		if (e === VALUE_ARRAY) {
+			let e = this.readUint32(), S = [];
+			for (let C = 0; C < e; C += 1) S.push(this.readValue());
+			return S;
+		}
+		if (e === VALUE_OBJECT) {
+			let e = this.readUint32(), S = {};
+			for (let C = 0; C < e; C += 1) {
+				let e = this.readString();
+				S[e] = this.readValue();
+			}
+			return S;
+		}
+		throw Error(`Unknown value kind ${e}`);
+	}
+	assertFullyRead() {
+		if (this.offset !== this.input.length) throw Error("Unexpected trailing bytes");
+	}
+	ensureAvailable(e) {
+		if (this.offset + e > this.input.length) throw Error("Unexpected end of binary payload");
+	}
+};
+function writeMeta(e, S) {
+	e.writeString(S.requestId), e.writeString(S.sourceStoreId), e.writeFloat64(S.timestamp), e.writeByte(typeof S.version == "number" ? 1 : 0), typeof S.version == "number" && e.writeFloat64(S.version);
+}
+function readMeta(e) {
+	let S = e.readString(), C = e.readString(), w = e.readFloat64(), T = e.readByte() === 1 ? e.readFloat64() : void 0;
+	return typeof T == "number" ? {
+		requestId: S,
+		sourceStoreId: C,
+		timestamp: w,
+		version: T
+	} : {
+		requestId: S,
+		sourceStoreId: C,
+		timestamp: w
+	};
+}
+function writeStoreChangeBody(e, S) {
+	if (S.kind === "row:insert" ? e.writeByte(CHANGE_ROW_INSERT) : S.kind === "row:update" ? e.writeByte(CHANGE_ROW_UPDATE) : e.writeByte(CHANGE_ROW_DELETE), e.writeString(S.tableName), e.writeFloat64(S.rowID), S.kind === "row:insert") {
+		let C = Object.entries(S.fields);
+		e.writeUint32(C.length);
+		for (let [S, w] of C) e.writeString(S), e.writeValue(w);
+	}
+	S.kind === "row:update" && (e.writeString(S.field), e.writeValue(S.value)), writeMeta(e, S);
+}
+function readStoreChangeBody(e) {
+	let S = e.readByte(), C = e.readString(), w = e.readFloat64();
+	if (S === CHANGE_ROW_INSERT) {
+		let S = e.readUint32(), T = {};
+		for (let C = 0; C < S; C += 1) {
+			let S = e.readString();
+			T[S] = e.readValue();
+		}
+		return {
+			kind: "row:insert",
+			tableName: C,
+			rowID: w,
+			fields: T,
+			...readMeta(e)
+		};
+	}
+	if (S === CHANGE_ROW_DELETE) return {
+		kind: "row:delete",
+		tableName: C,
+		rowID: w,
+		...readMeta(e)
+	};
+	if (S !== CHANGE_ROW_UPDATE) throw Error(`Unknown change kind ${S}`);
+	return {
+		kind: "row:update",
+		tableName: C,
+		rowID: w,
+		field: e.readString(),
+		value: e.readValue(),
+		...readMeta(e)
+	};
+}
+function encodeStoreChange(e) {
+	let S = new BinaryWriter();
+	return S.writeByte(OP_CHANGE), writeStoreChangeBody(S, e), S.toUint8Array();
+}
+function encodeStoreChanges(e) {
+	let S = new BinaryWriter();
+	S.writeByte(OP_CHANGE_BATCH), S.writeUint32(e.length);
+	for (let C of e) writeStoreChangeBody(S, C);
+	return S.toUint8Array();
+}
+function decodeStoreChange(e) {
+	let S = new BinaryReader(e), C = S.readByte();
+	if (C !== OP_CHANGE) throw Error(`Unexpected operation kind ${C}, expected change`);
+	let w = readStoreChangeBody(S);
+	return S.assertFullyRead(), w;
+}
+function decodeStoreChanges(e) {
+	let S = new BinaryReader(e), C = S.readByte();
+	if (C === OP_CHANGE) {
+		let e = readStoreChangeBody(S);
+		return S.assertFullyRead(), [e];
+	}
+	if (C !== OP_CHANGE_BATCH) throw Error(`Unexpected operation kind ${C}, expected change batch`);
+	let w = S.readUint32(), E = [];
+	for (let e = 0; e < w; e += 1) E.push(readStoreChangeBody(S));
+	return S.assertFullyRead(), E;
+}
+function encodeStoreChangeRequest(e) {
+	let S = new BinaryWriter();
+	S.writeByte(OP_CHANGE_REQUEST), S.writeString(e.tableName), S.writeFloat64(e.rowID);
+	let C = Object.entries(e.patch);
+	S.writeUint32(C.length);
+	for (let [e, w] of C) S.writeString(e), S.writeValue(w);
+	return writeMeta(S, e), S.toUint8Array();
+}
+function decodeStoreChangeRequest(e) {
+	let S = new BinaryReader(e), C = S.readByte();
+	if (C !== OP_CHANGE_REQUEST) throw Error(`Unexpected operation kind ${C}, expected request`);
+	let w = S.readString(), T = S.readFloat64(), D = S.readUint32(), O = {};
+	for (let e = 0; e < D; e += 1) {
+		let e = S.readString();
+		O[e] = S.readValue();
+	}
+	let k = readMeta(S);
+	return S.assertFullyRead(), {
+		kind: "row:set-async",
+		tableName: w,
+		rowID: T,
+		patch: O,
+		...k
+	};
+}
+var AnyStore = class e {
+	static nextStoreNumber = 1;
+	static nextRequestNumber = 1;
+	tables = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	requestListeners = /* @__PURE__ */ new Set();
+	storeID = `store-${e.nextStoreNumber++}`;
+	rowsLocked = !1;
+	muted = !1;
+	version = 0;
+	pendingChanges = [];
+	changeFlushScheduled = !1;
+	constructor(e) {
+		this.rowsLocked = e;
+	}
+	static create() {
+		return e.createPrimary();
+	}
+	static createPrimary() {
+		return new e(!1);
+	}
+	static replica(S) {
+		return e.createReplica(S);
+	}
+	static createReplica(S) {
+		let C = new e(!0);
+		for (let w of S.tables) {
+			let S = C.createTable(w.name, e._fromSerializedSchema(w.schema)), T = w.indexes ?? w.indexedFields?.map((e) => ({
+				field: e,
+				kind: "hashmap",
+				unique: !1
+			})) ?? [];
+			for (let e of T) S.addIndexToField(e.field, {
+				kind: e.kind,
+				unique: e.unique
+			});
+			S._hydrate(w.rows);
+		}
+		return C;
+	}
+	static key() {
+		return { kind: "key" };
+	}
+	createTable(e, S) {
+		if (this.tables.has(e)) throw Error(`Table ${e} already exists`);
+		let C = new Table(this, e, S);
+		return this.tables.set(e, C), C;
+	}
+	getTable(e) {
+		let S = this.tables.get(e);
+		if (!S) throw Error(`Table ${e} does not exist`);
+		return S;
+	}
+	hasTable(e) {
+		return this.tables.has(e);
+	}
+	dropTable(e) {
+		return this.tables.delete(e);
+	}
+	clear() {
+		this.tables.clear();
+	}
+	serialize() {
+		return this.pendingChanges.length > 0 && this.flushPendingChanges(), { tables: Array.from(this.tables.values()).map((e) => e.serialize()) };
+	}
+	applyChange(e) {
+		let S = decodeStoreChanges(e);
+		for (let e of S) {
+			let S = this.tables.get(e.tableName);
+			S && S._applyChange(e);
+		}
+	}
+	onChange(e) {
+		return this.listeners.add(e), () => {
+			this.listeners.delete(e);
+		};
+	}
+	onChangeRequest(e) {
+		return this.requestListeners.add(e), () => {
+			this.requestListeners.delete(e);
+		};
+	}
+	async requestChange(e) {
+		if (!this.rowsLocked) {
+			this.processChangeRequest(e);
+			return;
+		}
+		if (this.requestListeners.size === 0) throw Error("No change-request listeners are registered");
+		await Promise.all(Array.from(this.requestListeners, (S) => S(e)));
+	}
+	processChangeRequest(e) {
+		let S = decodeStoreChangeRequest(e), C = this.tables.get(S.tableName);
+		if (!C) throw Error(`Table ${S.tableName} does not exist`);
+		C._processChangeRequest(S);
+	}
+	_canInsertRows() {
+		return !this.rowsLocked;
+	}
+	_canSynchronouslyMutateRows() {
+		return !this.rowsLocked;
+	}
+	_buildChange(e, S) {
+		return this.version += 1, {
+			...e,
+			requestId: S?.requestId ?? this.nextRequestID(),
+			sourceStoreId: S?.sourceStoreId ?? this.storeID,
+			timestamp: S?.timestamp ?? Date.now(),
+			version: S?.version ?? this.version
+		};
+	}
+	_buildChangeRequest(e, S) {
+		return {
+			...e,
+			requestId: S?.requestId ?? this.nextRequestID(),
+			sourceStoreId: S?.sourceStoreId ?? this.storeID,
+			timestamp: S?.timestamp ?? Date.now(),
+			version: S?.version
+		};
+	}
+	_encodeChangeRequest(e) {
+		return encodeStoreChangeRequest(e);
+	}
+	_emitChange(e) {
+		this.muted || (typeof e.version == "number" && (this.version = Math.max(this.version, e.version)), this.pendingChanges.push(e), !this.changeFlushScheduled && (this.changeFlushScheduled = !0, queueMicrotask(() => {
+			this.flushPendingChanges();
+		})));
+	}
+	_runWithoutBroadcast(e) {
+		this.muted = !0;
+		try {
+			e();
+		} finally {
+			this.muted = !1;
+		}
+	}
+	nextRequestID() {
+		return `req-${e.nextRequestNumber++}`;
+	}
+	flushPendingChanges() {
+		if (this.changeFlushScheduled = !1, this.pendingChanges.length === 0) return;
+		let e = this.pendingChanges;
+		this.pendingChanges = [];
+		let S = encodeStoreChanges(e);
+		for (let e of this.listeners) e(S);
+	}
+	static _fromSerializedSchema(S) {
+		let C = {};
+		for (let [w, T] of Object.entries(S)) {
+			if (T.kind !== "key") throw Error(`Unsupported serialized schema kind ${T.kind} for field ${w}`);
+			C[w] = e.key();
+		}
+		return C;
+	}
+};
+function identity(e) {
+	return e;
+}
+export { AnyStore, Row, Table, decodeStoreChange, decodeStoreChangeRequest, decodeStoreChanges, encodeStoreChange, encodeStoreChangeRequest, encodeStoreChanges, identity };

package/dist/src/any-store.d.ts

@@ -0,0 +1,35 @@
+import { Table } from './table';
+import { BinaryStoreChange, BinaryStoreChangeRequest, KeyFieldDefinition, PrimitiveFieldValue, SerializedStore, TableSchema } from './types';
+export declare class AnyStore {
+    private static nextStoreNumber;
+    private static nextRequestNumber;
+    private readonly tables;
+    private readonly listeners;
+    private readonly requestListeners;
+    private readonly storeID;
+    private rowsLocked;
+    private muted;
+    private version;
+    private pendingChanges;
+    private changeFlushScheduled;
+    private constructor();
+    static create(): AnyStore;
+    static createPrimary(): AnyStore;
+    static replica(state: SerializedStore): AnyStore;
+    static createReplica(state: SerializedStore): AnyStore;
+    static key<TValue extends PrimitiveFieldValue>(): KeyFieldDefinition<TValue>;
+    createTable<Name extends string, const Schema extends TableSchema>(name: Name, schema: Schema): Table<Schema>;
+    getTable<Schema extends TableSchema = TableSchema>(name: string): Table<Schema>;
+    hasTable(name: string): boolean;
+    dropTable(name: string): boolean;
+    clear(): void;
+    serialize(): SerializedStore;
+    applyChange(change: BinaryStoreChange): void;
+    onChange(listener: (change: BinaryStoreChange) => void): () => void;
+    onChangeRequest(listener: (request: BinaryStoreChangeRequest) => void | Promise<void>): () => void;
+    requestChange(request: BinaryStoreChangeRequest): Promise<void>;
+    processChangeRequest(request: BinaryStoreChangeRequest): void;
+    private nextRequestID;
+    private flushPendingChanges;
+    private static _fromSerializedSchema;
+}

package/dist/src/binary-codec.d.ts

@@ -0,0 +1,7 @@
+import { StoreChange, StoreChangeRequest } from './types';
+export declare function encodeStoreChange(change: StoreChange): Uint8Array;
+export declare function encodeStoreChanges(changes: readonly StoreChange[]): Uint8Array;
+export declare function decodeStoreChange(payload: Uint8Array): StoreChange;
+export declare function decodeStoreChanges(payload: Uint8Array): StoreChange[];
+export declare function encodeStoreChangeRequest(request: StoreChangeRequest): Uint8Array;
+export declare function decodeStoreChangeRequest(payload: Uint8Array): StoreChangeRequest;

package/dist/src/lib.d.ts

@@ -0,0 +1,6 @@
+export declare function identity<T>(value: T): T;
+export { Row } from './row';
+export { AnyStore } from './any-store';
+export { Table } from './table';
+export { decodeStoreChange, decodeStoreChanges, decodeStoreChangeRequest, encodeStoreChange, encodeStoreChanges, encodeStoreChangeRequest, } from './binary-codec';
+export type { BinaryStoreChange, BinaryStoreChangeRequest, SerializedStore, StoreChange, StoreChangeRequest, TableRow, TableSchema, InsertInput, UpdateInput, PrimitiveFieldValue, } from './types';

package/dist/src/row.d.ts

@@ -0,0 +1,21 @@
+import { PrimitiveFieldValue } from './types';
+type AsyncSetHandler = (rowID: number, patch: Record<string, PrimitiveFieldValue>) => Promise<void>;
+type DeleteHandler = (rowID: number) => boolean;
+declare const ASYNC_SET_HANDLER: unique symbol;
+declare const DELETE_HANDLER: unique symbol;
+export declare class Row {
+    private readonly rowID;
+    private readonly fields;
+    private readonly [ASYNC_SET_HANDLER];
+    private readonly [DELETE_HANDLER];
+    constructor(id: number, fields: Record<string, PrimitiveFieldValue>, asyncSetHandler: AsyncSetHandler, deleteHandler: DeleteHandler);
+    get id(): number;
+    readField(field: string): PrimitiveFieldValue;
+    writeField(field: string, value: PrimitiveFieldValue): void;
+    setAsync(patch: Record<string, PrimitiveFieldValue>): Promise<void>;
+    delete(): boolean;
+    snapshot(): Record<string, PrimitiveFieldValue> & {
+        id: number;
+    };
+}
+export {};

package/dist/src/table.d.ts

@@ -0,0 +1,41 @@
+import { InsertInput, SerializedTable, TableRow, TableSchema, UpdateInput } from './types';
+export declare class Table<Schema extends TableSchema> {
+    private readonly store;
+    private readonly name;
+    private readonly schema;
+    private readonly RowClass;
+    private nextID;
+    private readonly rowsByID;
+    private readonly indexesByField;
+    constructor(store: StoreHooks, name: string, schema: Schema);
+    insert(input: InsertInput<Schema>): TableRow<Schema>;
+    private insertRow;
+    addIndexToField<FieldName extends Extract<keyof Schema, string>>(field: FieldName, config: {
+        kind: "hashmap";
+        unique?: boolean;
+    }): void;
+    getByIndex<FieldName extends Extract<keyof Schema, string>>(field: FieldName, value: TableRow<Schema>[FieldName]): TableRow<Schema> | null;
+    get(id: number): TableRow<Schema> | null;
+    all(): readonly TableRow<Schema>[];
+    values(): IterableIterator<TableRow<Schema>>;
+    filter(predicate: (row: TableRow<Schema>) => boolean): TableRow<Schema>[];
+    count(): number;
+    getByID(id: number): TableRow<Schema> | null;
+    update(id: number, patch: UpdateInput<Schema>): TableRow<Schema> | undefined;
+    delete(id: number): boolean;
+    private deleteByID;
+    clear(): void;
+    serialize(): SerializedTable;
+    private createRow;
+    private createRowClass;
+    private setRowField;
+    private validateInput;
+    private toStoredFieldValue;
+    private indexRow;
+    private unindexRow;
+    private indexRowField;
+    private tryUpsertUniqueIndexRow;
+    private getIndexedRow;
+    private unindexRowField;
+    private encodeIndexValue;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,78 @@
+export type PrimitiveFieldValue = string | number | boolean | null | PrimitiveFieldValue[] | {
+    [key: string]: PrimitiveFieldValue;
+};
+declare const KEY_VALUE_TYPE: unique symbol;
+export type KeyFieldDefinition<TValue extends PrimitiveFieldValue> = {
+    kind: "key";
+    [KEY_VALUE_TYPE]: TValue;
+};
+export type TableSchema = Record<string, KeyFieldDefinition<PrimitiveFieldValue>>;
+type FieldValueForDefinition<Definition extends KeyFieldDefinition<PrimitiveFieldValue>> = Definition extends KeyFieldDefinition<infer TValue> ? NonNullable<TValue> : never;
+export type InsertInput<Schema extends TableSchema> = {
+    -readonly [K in keyof Schema]: FieldValueForDefinition<Schema[K]>;
+};
+export type UpdateInput<Schema extends TableSchema> = Partial<InsertInput<Schema>>;
+export type TableRow<Schema extends TableSchema> = {
+    -readonly [K in keyof Schema]: FieldValueForDefinition<Schema[K]>;
+} & {
+    id: number;
+    delete(): boolean;
+    setAsync(patch: UpdateInput<Schema>): Promise<void>;
+};
+export type EnvelopeMeta = {
+    requestId: string;
+    sourceStoreId: string;
+    timestamp: number;
+    version?: number;
+};
+export type RowUpdateChangePayload = {
+    kind: "row:update";
+    tableName: string;
+    rowID: number;
+    field: string;
+    value: PrimitiveFieldValue;
+};
+export type RowInsertChangePayload = {
+    kind: "row:insert";
+    tableName: string;
+    rowID: number;
+    fields: Record<string, PrimitiveFieldValue>;
+};
+export type RowDeleteChangePayload = {
+    kind: "row:delete";
+    tableName: string;
+    rowID: number;
+};
+export type StoreChangePayload = RowInsertChangePayload | RowUpdateChangePayload | RowDeleteChangePayload;
+export type StoreChange = StoreChangePayload & EnvelopeMeta;
+export type BinaryStoreChange = Uint8Array;
+export type StoreChangeRequestPayload = {
+    kind: "row:set-async";
+    tableName: string;
+    rowID: number;
+    patch: Record<string, PrimitiveFieldValue>;
+};
+export type StoreChangeRequest = StoreChangeRequestPayload & EnvelopeMeta;
+export type BinaryStoreChangeRequest = Uint8Array;
+export type SerializedPrimitiveField = {
+    kind: "key";
+};
+export type SerializedFieldSchema = SerializedPrimitiveField;
+export type SerializedTableSchema = Record<string, SerializedFieldSchema>;
+export type SerializedTableIndex = {
+    field: string;
+    kind: "hashmap";
+    unique?: boolean;
+};
+export type SerializedTable = {
+    name: string;
+    schema: SerializedTableSchema;
+    indexes?: SerializedTableIndex[];
+    rows: Array<Record<string, PrimitiveFieldValue> & {
+        id: number;
+    }>;
+};
+export type SerializedStore = {
+    tables: SerializedTable[];
+};
+export {};

package/dist/tests/binary-codec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/lib.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/lib.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/smoke.browser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "any-store-js",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/lib.es.js",
+  "types": "./dist/src/lib.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/lib.es.js",
+      "types": "./dist/src/lib.d.ts"
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "npm run check && vite build",
+    "preview": "vite preview",
+    "check": "tsc --build",
+    "test": "vitest",
+    "bench": "vitest bench",
+    "test:browser": "vitest --config=vitest.browser.config.ts",
+    "test-ci": "vitest --run && vitest --config=vitest.browser.config.ts --run --browser.headless",
+    "deploy": "npm run build && npm publish --access public"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@vitest/browser-playwright": "^4.0.18",
+    "tsx": "^4.21.0",
+    "typescript": "~5.9.3",
+    "vite": "npm:rolldown-vite@7.2.5",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.16"
+  },
+  "overrides": {
+    "vite": "npm:rolldown-vite@7.2.5"
+  }
+}