@byearlybird/starling 0.1.2 → 0.2.0

package/dist/index.js

@@ -1,454 +1,439 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+import { t as __export } from "./chunk-Bp6m_JJh.js";
 
-// lib/core/crdt/operations.ts
-function encode(obj, eventstamp) {
-  const result = {};
-  function step(target, output) {
-    for (const key in target) {
-      if (!Object.hasOwn(target, key))
-        continue;
-      const value = target[key];
-      if (value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype) {
-        output[key] = {};
-        step(value, output[key]);
-      } else {
-        output[key] = {
-          __value: value,
-          __eventstamp: eventstamp
-        };
-      }
-    }
-  }
-  step(obj, result);
-  return result;
-}
-function decode(obj) {
-  const result = {};
-  function step(source, output) {
-    for (const key in source) {
-      if (!Object.hasOwn(source, key))
-        continue;
-      if (key === "__deleted")
-        continue;
-      const value = source[key];
-      if (value && "__value" in value && "__eventstamp" in value) {
-        output[key] = value.__value;
-      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        output[key] = {};
-        step(value, output[key]);
-      }
-    }
-  }
-  step(obj, result);
-  return result;
-}
-function merge(obj1, obj2) {
-  const result = {};
-  let changed = false;
-  function isEncodedValue(val) {
-    return val != null && typeof val === "object" && "__value" in val && "__eventstamp" in val;
-  }
-  function step(v1, v2, output) {
-    for (const key in v1) {
-      if (!Object.hasOwn(v1, key))
-        continue;
-      const value1 = v1[key];
-      const value2 = v2[key];
-      if (isEncodedValue(value1) && isEncodedValue(value2)) {
-        if (value1.__eventstamp >= value2.__eventstamp) {
-          output[key] = value1;
-        } else {
-          output[key] = value2;
-          changed = true;
-        }
-      } else if (isEncodedValue(value1)) {
-        output[key] = value1;
-      } else if (value1 && value2 && typeof value1 === "object" && typeof value2 === "object") {
-        output[key] = {};
-        step(value1, value2, output[key]);
-      } else if (value1) {
-        output[key] = value1;
-      }
-    }
-    for (const key in v2) {
-      if (!Object.hasOwn(v2, key) || Object.hasOwn(result, key))
-        continue;
-      const value = v2[key];
-      if (value) {
-        output[key] = value;
-        changed = true;
-      }
-    }
-  }
-  step(obj1, obj2, result);
-  return [result, changed];
-}
-function mergeArray(current, updates) {
-  const updatesMap = new Map(updates.map((item) => [item.key, item.value]));
-  const result = [];
-  let changed = false;
-  const seenKeys = new Set;
-  for (const { key, value: obj1 } of current) {
-    seenKeys.add(key);
-    const obj2 = updatesMap.get(key);
-    if (obj2) {
-      const [merged, objChanged] = merge(obj1, obj2);
-      result.push({ key, value: merged });
-      if (objChanged) {
-        changed = true;
-      }
-    } else {
-      result.push({ key, value: obj1 });
-    }
-  }
-  for (const { key, value: obj2 } of updates) {
-    if (!seenKeys.has(key)) {
-      result.push({ key, value: obj2 });
-      changed = true;
-    }
-  }
-  return [result, changed];
-}
-var encodeMany = (data, eventstampFn) => data.map(({ key, value }) => ({ key, value: encode(value, eventstampFn()) }));
-// lib/core/crdt/clock.ts
-var formatEventstamp = (timestampMs, counter) => {
-  const isoString = new Date(timestampMs).toISOString();
-  return `${isoString}|${counter.toString(16).padStart(8, "0")}`;
+//#region src/eventstamp.ts
+var eventstamp_exports = /* @__PURE__ */ __export({
+	decode: () => decode$3,
+	encode: () => encode$3
+});
+const encode$3 = (timestampMs, counter) => {
+	return `${new Date(timestampMs).toISOString()}|${counter.toString(16).padStart(8, "0")}`;
 };
-var parseEventstamp = (eventstamp) => {
-  const pipeIndex = eventstamp.indexOf("|");
-  const isoString = eventstamp.slice(0, pipeIndex);
-  const hexCounter = eventstamp.slice(pipeIndex + 1);
-  return {
-    timestampMs: new Date(isoString).getTime(),
-    counter: parseInt(hexCounter, 16)
-  };
+const decode$3 = (eventstamp) => {
+	const pipeIndex = eventstamp.indexOf("|");
+	const isoString = eventstamp.slice(0, pipeIndex);
+	const hexCounter = eventstamp.slice(pipeIndex + 1);
+	return {
+		timestampMs: new Date(isoString).getTime(),
+		counter: parseInt(hexCounter, 16)
+	};
 };
-var createClock = () => {
-  let counter = 0;
-  let lastMs = Date.now();
-  return {
-    now() {
-      const nowMs = Date.now();
-      if (nowMs <= lastMs) {
-        counter++;
-      } else {
-        lastMs = nowMs;
-        counter = 0;
-      }
-      return formatEventstamp(nowMs, counter);
-    },
-    latest() {
-      return formatEventstamp(lastMs, counter);
-    },
-    forward(eventstamp) {
-      const latest = this.latest();
-      if (eventstamp > latest) {
-        const newer = parseEventstamp(eventstamp);
-        lastMs = newer.timestampMs;
-        counter = newer.counter;
-      }
-    }
-  };
+
+//#endregion
+//#region src/clock.ts
+var clock_exports = /* @__PURE__ */ __export({ create: () => create });
+const create = () => {
+	let counter = 0;
+	let lastMs = Date.now();
+	return {
+		now: () => {
+			const nowMs = Date.now();
+			if (nowMs <= lastMs) counter++;
+			else {
+				lastMs = nowMs;
+				counter = 0;
+			}
+			return encode$3(nowMs, counter);
+		},
+		latest() {
+			return encode$3(lastMs, counter);
+		},
+		forward(eventstamp) {
+			if (eventstamp > this.latest()) {
+				const newer = decode$3(eventstamp);
+				lastMs = newer.timestampMs;
+				counter = newer.counter;
+			}
+		}
+	};
 };
 
-// lib/core/shared/utils.ts
-function mapToArray(map) {
-  return Array.from(map.entries()).map(([key, value]) => ({ key, value }));
-}
-var mergeItems = (map, items) => {
-  const merged = [];
-  for (const { key, value } of items) {
-    const current = map.get(key);
-    if (!current)
-      continue;
-    const [mergedValue, changed] = merge(current, value);
-    if (changed) {
-      merged.push({ key, value: mergedValue });
-    }
-  }
-  return merged;
+//#endregion
+//#region src/value.ts
+var value_exports = /* @__PURE__ */ __export({
+	decode: () => decode$2,
+	encode: () => encode$2,
+	isEncoded: () => isEncoded,
+	merge: () => merge$2
+});
+const encode$2 = (value, eventstamp) => ({
+	__value: value,
+	__eventstamp: eventstamp
+});
+const decode$2 = (value) => value.__value;
+const merge$2 = (into, from$1) => ({
+	__value: into.__eventstamp > from$1.__eventstamp ? into.__value : from$1.__value,
+	__eventstamp: into.__eventstamp > from$1.__eventstamp ? into.__eventstamp : from$1.__eventstamp
+});
+const isEncoded = (value) => !!(typeof value === "object" && value !== null && "__value" in value && "__eventstamp" in value);
+
+//#endregion
+//#region src/record.ts
+var record_exports = /* @__PURE__ */ __export({
+	decode: () => decode$1,
+	encode: () => encode$1,
+	merge: () => merge$1
+});
+const isObject = (value) => !!(value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype);
+const encode$1 = (obj, eventstamp) => {
+	const result = {};
+	const step = (target, output) => {
+		for (const key in target) {
+			if (!Object.hasOwn(target, key)) continue;
+			const value = target[key];
+			if (isObject(value)) {
+				output[key] = {};
+				step(value, output[key]);
+			} else output[key] = encode$2(value, eventstamp);
+		}
+	};
+	step(obj, result);
+	return result;
+};
+const decode$1 = (obj) => {
+	const result = {};
+	const step = (source, output) => {
+		for (const key in source) {
+			if (!Object.hasOwn(source, key)) continue;
+			const value = source[key];
+			if (isEncoded(value)) output[key] = decode$2(value);
+			else if (isObject(value)) {
+				output[key] = {};
+				step(value, output[key]);
+			}
+		}
+	};
+	step(obj, result);
+	return result;
+};
+const merge$1 = (into, from$1) => {
+	const result = {};
+	const step = (v1, v2, output) => {
+		for (const key in v1) {
+			if (!Object.hasOwn(v1, key)) continue;
+			const value1 = v1[key];
+			const value2 = v2[key];
+			if (isEncoded(value1) && isEncoded(value2)) output[key] = merge$2(value1, value2);
+			else if (isEncoded(value1)) output[key] = value1;
+			else if (isObject(value1) && isObject(value2)) {
+				output[key] = {};
+				step(value1, value2, output[key]);
+			} else if (value1) output[key] = value1;
+		}
+		for (const key in v2) {
+			if (!Object.hasOwn(v2, key) || Object.hasOwn(output, key)) continue;
+			const value = v2[key];
+			if (value !== void 0) output[key] = value;
+		}
+	};
+	step(into, from$1, result);
+	return result;
 };
 
-// node_modules/.bun/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
-function mitt_default(n) {
-  return { all: n = n || new Map, on: function(t, e) {
-    var i = n.get(t);
-    i ? i.push(e) : n.set(t, [e]);
-  }, off: function(t, e) {
-    var i = n.get(t);
-    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
-  }, emit: function(t, e) {
-    var i = n.get(t);
-    i && i.slice().map(function(n2) {
-      n2(e);
-    }), (i = n.get("*")) && i.slice().map(function(n2) {
-      n2(t, e);
-    });
-  } };
-}
+//#endregion
+//#region src/document.ts
+var document_exports = /* @__PURE__ */ __export({
+	decode: () => decode,
+	del: () => del$1,
+	encode: () => encode,
+	merge: () => merge
+});
+const encode = (id, obj, eventstamp, deletedAt = null) => ({
+	__id: id,
+	__data: encode$1(obj, eventstamp),
+	__deletedAt: deletedAt
+});
+const decode = (doc) => ({
+	__id: doc.__id,
+	__data: decode$1(doc.__data),
+	__deletedAt: doc.__deletedAt
+});
+const merge = (into, from$1) => ({
+	__id: into.__id,
+	__data: merge$1(into.__data, from$1.__data),
+	__deletedAt: into.__deletedAt && from$1.__deletedAt ? into.__deletedAt > from$1.__deletedAt ? into.__deletedAt : from$1.__deletedAt : into.__deletedAt || from$1.__deletedAt || null
+});
+const del$1 = (doc, eventstamp) => ({
+	...doc,
+	__deletedAt: eventstamp
+});
 
-// lib/core/store/mutations.ts
-var createPutMany = (map, clock, emitter) => {
-  return (data) => {
-    encodeMany(data, () => clock.now()).forEach(({ key, value }) => {
-      map.set(key, value);
-    });
-    emitter.emit("put", data);
-  };
+//#endregion
+//#region src/collection.ts
+var collection_exports = /* @__PURE__ */ __export({
+	del: () => del,
+	from: () => from,
+	insert: () => insert,
+	update: () => update
+});
+const insert = (collection, doc) => {
+	if (collection.has(doc.__id)) throw new Error(`Key already exists: ${doc.__id}`);
+	return new Map(collection).set(doc.__id, doc);
 };
-var createUpdateMany = (map, clock, emitter) => {
-  return (data) => {
-    const validData = data.filter((d) => map.has(d.key));
-    if (validData.length === 0)
-      return;
-    const updateEvents = [];
-    let anyChanged = false;
-    for (const { key, value } of validData) {
-      const current = map.get(key);
-      if (!current)
-        continue;
-      const encoded = encode(value, clock.now());
-      const [mergedValue, itemChanged] = merge(current, encoded);
-      if (itemChanged) {
-        map.set(key, mergedValue);
-        updateEvents.push({ key, value: decode(mergedValue) });
-        anyChanged = true;
-      }
-    }
-    if (!anyChanged)
-      return;
-    emitter.emit("update", updateEvents);
-  };
+const update = (collection, doc) => {
+	const current = collection.get(doc.__id);
+	if (!current) throw new Error(`Key not found: ${doc.__id}`);
+	const merged = merge(current, doc);
+	return new Map(collection).set(merged.__id, merged);
 };
-var createDeleteMany = (map, clock, emitter) => {
-  return (keys) => {
-    const validKeys = keys.filter((key) => map.has(key));
-    if (validKeys.length === 0)
-      return;
-    const deletionMarkers = encodeMany(validKeys.map((key) => ({ key, value: { __deleted: true } })), () => clock.now());
-    const merged = mergeItems(map, deletionMarkers);
-    if (merged.length === 0)
-      return;
-    const deleteEvents = [];
-    merged.forEach(({ key, value }) => {
-      map.set(key, value);
-      deleteEvents.push({ key });
-    });
-    emitter.emit("delete", deleteEvents);
-  };
+const del = (collection, id) => {
+	if (!collection.has(id)) throw new Error(`Key not found: ${id}`);
+	const final = new Map(collection);
+	final.delete(id);
+	return final;
 };
-var createMerge = (map, emitter) => {
-  return (snapshot, opts = { silent: false }) => {
-    const putEvents = [];
-    const updateEvents = [];
-    const deleteEvents = [];
-    for (const { key, value: snapshotValue } of snapshot) {
-      const currentValue = map.get(key);
-      if (!currentValue) {
-        putEvents.push({ key, value: decode(snapshotValue) });
-        map.set(key, snapshotValue);
-      } else {
-        const [mergedValue, changed] = merge(currentValue, snapshotValue);
-        if (changed) {
-          const wasDeleted = currentValue.__deleted !== undefined;
-          const isDeleted = mergedValue.__deleted !== undefined;
-          if (!wasDeleted && isDeleted) {
-            map.set(key, mergedValue);
-            deleteEvents.push({ key });
-          } else {
-            map.set(key, mergedValue);
-            updateEvents.push({ key, value: decode(mergedValue) });
-          }
-        }
-      }
-    }
-    if (opts.silent)
-      return;
-    if (putEvents.length > 0) {
-      emitter.emit("put", putEvents);
-    }
-    if (updateEvents.length > 0) {
-      emitter.emit("update", updateEvents);
-    }
-    if (deleteEvents.length > 0) {
-      emitter.emit("delete", deleteEvents);
-    }
-  };
+const from = (docs) => {
+	const final = /* @__PURE__ */ new Map();
+	for (const doc of docs) {
+		if (final.has(doc.__id)) throw new Error(`Duplicate key found: ${doc.__id}`);
+		final.set(doc.__id, doc);
+	}
+	return final;
 };
 
-// lib/core/store/query.ts
-var createQuery = (map, queries) => {
-  return (predicate) => {
-    const results = new Map;
-    for (const [key, rawValue] of map.entries()) {
-      const value = decode(rawValue);
-      if (predicate(value)) {
-        results.set(key, value);
-      }
-    }
-    const internal = {
-      predicate,
-      results,
-      callbacks: new Set
-    };
-    queries.add(internal);
-    return {
-      results() {
-        return results;
-      },
-      onChange: (callback) => {
-        internal.callbacks.add(callback);
-        return () => {
-          internal.callbacks.delete(callback);
-        };
-      },
-      dispose: () => {
-        internal.callbacks.clear();
-        queries.delete(internal);
-      }
-    };
-  };
+//#endregion
+//#region src/map.ts
+var map_exports = /* @__PURE__ */ __export({ create: () => create$2 });
+const create$2 = (iterable) => {
+	let readMap = new Map(iterable);
+	function cloneMap(src) {
+		return new Map(src);
+	}
+	return {
+		get(key) {
+			return readMap.get(key) ?? null;
+		},
+		has(key) {
+			return readMap.has(key);
+		},
+		values() {
+			return readMap.values();
+		},
+		entries() {
+			return readMap.entries();
+		},
+		get size() {
+			return readMap.size;
+		},
+		put(key, value) {
+			const next = cloneMap(readMap);
+			next.set(key, value);
+			readMap = next;
+		},
+		patch(key, value) {
+			const next = cloneMap(readMap);
+			const prev = next.get(key);
+			next.set(key, prev ? merge(prev, value) : value);
+			readMap = next;
+		},
+		del(key, eventstamp) {
+			const next = cloneMap(readMap);
+			const prev = next.get(key);
+			if (prev) next.set(key, del$1(prev, eventstamp));
+			readMap = next;
+		},
+		begin() {
+			const staging = cloneMap(readMap);
+			let committed = false;
+			return {
+				put(key, value) {
+					staging.set(key, value);
+				},
+				patch(key, value) {
+					const prev = staging.get(key);
+					staging.set(key, prev ? merge(prev, value) : value);
+				},
+				del(key, eventstamp) {
+					const prev = staging.get(key);
+					if (prev) staging.set(key, del$1(prev, eventstamp));
+				},
+				commit() {
+					if (committed) return;
+					committed = true;
+					readMap = staging;
+				},
+				rollback() {
+					committed = true;
+				}
+			};
+		}
+	};
 };
 
-// lib/core/store/store.ts
-var createStore = (collectionKey) => {
-  const $map = new Map;
-  const $emitter = mitt_default();
-  const $clock = createClock();
-  const $handles = new Set;
-  const $queries = new Set;
-  $emitter.on("*", (event) => {
-    if (event === "change")
-      return;
-    $emitter.emit("change");
-  });
-  const runCallbacks = (dirtyQueries) => {
-    for (const query2 of dirtyQueries) {
-      for (const callback of query2.callbacks) {
-        callback();
-      }
-    }
-    dirtyQueries.clear();
-  };
-  $emitter.on("put", (data) => {
-    const dirtyQueries = new Set;
-    for (const query2 of $queries) {
-      for (const item of data) {
-        if (query2.predicate(item.value)) {
-          query2.results.set(item.key, item.value);
-          dirtyQueries.add(query2);
-        }
-      }
-    }
-    runCallbacks(dirtyQueries);
-  });
-  $emitter.on("delete", (data) => {
-    const dirtyQueries = new Set;
-    for (const query2 of $queries) {
-      for (const item of data) {
-        if (query2.results.has(item.key)) {
-          query2.results.delete(item.key);
-          dirtyQueries.add(query2);
-        }
-      }
-    }
-    runCallbacks(dirtyQueries);
-  });
-  $emitter.on("update", (data) => {
-    const dirtyQueries = new Set;
-    for (const query2 of $queries) {
-      for (const item of data) {
-        const matches = query2.predicate(item.value);
-        const inResults = query2.results.has(item.key);
-        if (matches) {
-          query2.results.set(item.key, item.value);
-          dirtyQueries.add(query2);
-        } else if (inResults) {
-          query2.results.delete(item.key);
-          dirtyQueries.add(query2);
-        }
-      }
-    }
-    runCallbacks(dirtyQueries);
-  });
-  const putMany = createPutMany($map, $clock, $emitter);
-  const updateMany = createUpdateMany($map, $clock, $emitter);
-  const deleteMany = createDeleteMany($map, $clock, $emitter);
-  const merge2 = createMerge($map, $emitter);
-  const query = createQuery($map, $queries);
-  return {
-    collectionKey,
-    putMany,
-    updateMany,
-    deleteMany,
-    merge: merge2,
-    put(key, value) {
-      this.putMany([{ key, value }]);
-    },
-    update(key, value) {
-      this.updateMany([{ key, value }]);
-    },
-    delete(key) {
-      this.deleteMany([key]);
-    },
-    values() {
-      const result = [];
-      for (const [key, value] of $map) {
-        if (!value.__deleted) {
-          result.push({ key, value: decode(value) });
-        }
-      }
-      return result;
-    },
-    query,
-    snapshot() {
-      return mapToArray($map);
-    },
-    on(event, callback) {
-      $emitter.on(event, callback);
-      return () => {
-        $emitter.off(event, callback);
-      };
-    },
-    use(plugin) {
-      $handles.add(plugin(this));
-      return this;
-    },
-    async init() {
-      for (const handle of $handles) {
-        await handle.init();
-      }
-      return this;
-    },
-    async dispose() {
-      $handles.forEach(async (handle) => {
-        await handle.dispose();
-      });
-      $emitter.all.clear();
-    }
-  };
-};
-export {
-  mergeArray,
-  merge,
-  encode,
-  decode,
-  createStore
+//#endregion
+//#region src/store.ts
+var store_exports = /* @__PURE__ */ __export({ create: () => create$1 });
+const create$1 = ({ hooks } = {}) => {
+	const clock = create();
+	const encodeValue = (key, value) => encode(key, value, clock.now());
+	const kv = create$2();
+	const listeners = {
+		beforePut: /* @__PURE__ */ new Set(),
+		beforePatch: /* @__PURE__ */ new Set(),
+		beforeDel: /* @__PURE__ */ new Set(),
+		put: /* @__PURE__ */ new Set(),
+		patch: /* @__PURE__ */ new Set(),
+		del: /* @__PURE__ */ new Set()
+	};
+	const initializers = /* @__PURE__ */ new Set();
+	const disposers = /* @__PURE__ */ new Set();
+	const decodeActive = (doc) => {
+		if (!doc || doc.__deletedAt) return null;
+		return decode(doc).__data;
+	};
+	return {
+		get(key) {
+			return decodeActive(kv.get(key));
+		},
+		has(key) {
+			return decodeActive(kv.get(key)) !== null;
+		},
+		values() {
+			function* iterator() {
+				for (const doc of kv.values()) {
+					const data = decodeActive(doc);
+					if (data) yield data;
+				}
+			}
+			return iterator();
+		},
+		entries() {
+			function* iterator() {
+				for (const [key, doc] of kv.entries()) {
+					const data = decodeActive(doc);
+					if (data) yield [key, data];
+				}
+			}
+			return iterator();
+		},
+		get size() {
+			let count = 0;
+			for (const doc of kv.values()) if (doc && !doc.__deletedAt) count++;
+			return count;
+		},
+		put(key, value) {
+			const tx = this.begin();
+			tx.put(key, value);
+			tx.commit();
+		},
+		patch(key, value) {
+			const tx = this.begin();
+			tx.patch(key, value);
+			tx.commit();
+		},
+		del(key) {
+			const tx = this.begin();
+			tx.del(key);
+			tx.commit();
+		},
+		begin() {
+			const tx = kv.begin();
+			const putKeyValues = [];
+			const patchKeyValues = [];
+			const deleteKeys = [];
+			const txState = /* @__PURE__ */ new Map();
+			return {
+				put(key, value) {
+					hooks?.onBeforePut?.(key, value);
+					for (const fn of listeners.beforePut) fn(key, value);
+					tx.put(key, encodeValue(key, value));
+					txState.set(key, value);
+					putKeyValues.push([key, value]);
+				},
+				patch(key, value) {
+					hooks?.onBeforePatch?.(key, value);
+					for (const fn of listeners.beforePatch) fn(key, value);
+					tx.patch(key, encode(key, value, clock.now()));
+					let baseValue;
+					if (txState.has(key)) baseValue = txState.get(key) ?? null;
+					else baseValue = decodeActive(kv.get(key));
+					if (baseValue) {
+						const merged = {
+							...baseValue,
+							...value
+						};
+						txState.set(key, merged);
+						patchKeyValues.push([key, merged]);
+					}
+				},
+				del(key) {
+					hooks?.onBeforeDelete?.(key);
+					for (const fn of listeners.beforeDel) fn(key);
+					if (!(txState.get(key) ?? kv.get(key))) return;
+					tx.del(key, clock.now());
+					deleteKeys.push(key);
+				},
+				commit() {
+					tx.commit();
+					if (putKeyValues.length > 0 && hooks?.onPut) hooks.onPut(Object.freeze([...putKeyValues]));
+					if (patchKeyValues.length > 0 && hooks?.onPatch) hooks.onPatch(Object.freeze([...patchKeyValues]));
+					if (deleteKeys.length > 0 && hooks?.onDelete) hooks.onDelete(Object.freeze([...deleteKeys]));
+					if (putKeyValues.length > 0) for (const fn of listeners.put) fn(Object.freeze([...putKeyValues]));
+					if (patchKeyValues.length > 0) for (const fn of listeners.patch) fn(Object.freeze([...patchKeyValues]));
+					if (deleteKeys.length > 0) for (const fn of listeners.del) fn(Object.freeze([...deleteKeys]));
+				},
+				rollback() {
+					tx.rollback();
+				}
+			};
+		},
+		use(plugin) {
+			const { hooks: pluginHooks, init, dispose } = plugin(this);
+			if (pluginHooks) {
+				if (pluginHooks.onBeforePut) {
+					const callback = pluginHooks.onBeforePut;
+					listeners.beforePut.add(callback);
+					disposers.add(() => {
+						listeners.beforePut.delete(callback);
+					});
+				}
+				if (pluginHooks.onBeforePatch) {
+					const callback = pluginHooks.onBeforePatch;
+					listeners.beforePatch.add(callback);
+					disposers.add(() => {
+						listeners.beforePatch.delete(callback);
+					});
+				}
+				if (pluginHooks.onBeforeDelete) {
+					const callback = pluginHooks.onBeforeDelete;
+					listeners.beforeDel.add(callback);
+					disposers.add(() => {
+						listeners.beforeDel.delete(callback);
+					});
+				}
+				if (pluginHooks.onPut) {
+					const callback = pluginHooks.onPut;
+					listeners.put.add(callback);
+					disposers.add(() => {
+						listeners.put.delete(callback);
+					});
+				}
+				if (pluginHooks.onPatch) {
+					const callback = pluginHooks.onPatch;
+					listeners.patch.add(callback);
+					disposers.add(() => {
+						listeners.patch.delete(callback);
+					});
+				}
+				if (pluginHooks.onDelete) {
+					const callback = pluginHooks.onDelete;
+					listeners.del.add(callback);
+					disposers.add(() => {
+						listeners.del.delete(callback);
+					});
+				}
+			}
+			initializers.add(init);
+			disposers.add(dispose);
+			return this;
+		},
+		async init() {
+			for (const fn of initializers) await fn();
+		},
+		async dispose() {
+			for (const fn of Array.from(disposers).toReversed()) await fn();
+		}
+	};
 };
+
+//#endregion
+export { clock_exports as $clock, collection_exports as $collection, document_exports as $document, eventstamp_exports as $eventsamp, map_exports as $map, record_exports as $record, store_exports as $store, value_exports as $value };