@rlabs-inc/fsdb 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2656 @@
+import { createRequire } from "node:module";
+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 __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/@rlabs-inc/signals/dist/index.mjs
+var equals = (oldValue, newValue) => Object.is(oldValue, newValue);
+var DERIVED = 1 << 1;
+var EFFECT = 1 << 2;
+var RENDER_EFFECT = 1 << 3;
+var ROOT_EFFECT = 1 << 4;
+var BRANCH_EFFECT = 1 << 5;
+var USER_EFFECT = 1 << 6;
+var BLOCK_EFFECT = 1 << 7;
+var CLEAN = 1 << 10;
+var DIRTY = 1 << 11;
+var MAYBE_DIRTY = 1 << 12;
+var REACTION_IS_UPDATING = 1 << 13;
+var DESTROYED = 1 << 14;
+var INERT = 1 << 15;
+var EFFECT_RAN = 1 << 16;
+var EFFECT_PRESERVED = 1 << 17;
+var UNOWNED = 1 << 8;
+var DISCONNECTED = 1 << 9;
+var INSPECT_EFFECT = 1 << 18;
+var UNINITIALIZED = Symbol.for("rlabs.signals.uninitialized");
+var STALE_REACTION = Symbol.for("rlabs.signals.stale_reaction");
+var STATE_SYMBOL = Symbol.for("rlabs.signals.state");
+var REACTIVE_MARKER = Symbol.for("rlabs.signals.reactive");
+var STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
+var activeReaction = null;
+var activeEffect = null;
+var untracking = false;
+var writeVersion = 1;
+var readVersion = 0;
+var newDeps = null;
+var skippedDeps = 0;
+var untrackedWrites = null;
+var batchDepth = 0;
+var pendingReactions = new Set;
+var queuedRootEffects = [];
+var isFlushingSync = false;
+function setActiveReaction(reaction) {
+  const prev = activeReaction;
+  activeReaction = reaction;
+  return prev;
+}
+function setActiveEffect(effect) {
+  const prev = activeEffect;
+  activeEffect = effect;
+  return prev;
+}
+function incrementWriteVersion() {
+  return ++writeVersion;
+}
+function incrementReadVersion() {
+  return ++readVersion;
+}
+function setNewDeps(deps) {
+  const prev = newDeps;
+  newDeps = deps;
+  return prev;
+}
+function setSkippedDeps(count) {
+  const prev = skippedDeps;
+  skippedDeps = count;
+  return prev;
+}
+function setUntrackedWrites(writes) {
+  const prev = untrackedWrites;
+  untrackedWrites = writes;
+  return prev;
+}
+function addUntrackedWrite(signal) {
+  if (untrackedWrites === null) {
+    untrackedWrites = [signal];
+  } else {
+    untrackedWrites.push(signal);
+  }
+}
+function addPendingReaction(reaction) {
+  pendingReactions.add(reaction);
+}
+function clearQueuedRootEffects() {
+  const prev = queuedRootEffects;
+  queuedRootEffects = [];
+  return prev;
+}
+function addQueuedRootEffect(effect) {
+  queuedRootEffects.push(effect);
+}
+function scheduleEffect(reaction) {
+  addPendingReaction(reaction);
+  if (batchDepth > 0) {
+    return;
+  }
+  let effect = reaction;
+  while (effect.parent !== null) {
+    effect = effect.parent;
+    const flags = effect.f;
+    if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
+      if ((flags & CLEAN) === 0) {
+        return;
+      }
+      effect.f ^= CLEAN;
+    }
+  }
+  addQueuedRootEffect(effect);
+  if (!isFlushingSync) {
+    queueMicrotask(flushEffects);
+  }
+}
+var updateEffectImpl = () => {
+  throw new Error("updateEffect not initialized - import effect.ts first");
+};
+function setUpdateEffectImpl(impl) {
+  updateEffectImpl = impl;
+}
+function flushEffects() {
+  const roots = clearQueuedRootEffects();
+  for (const root of roots) {
+    if (isDirty(root)) {
+      updateEffectImpl(root);
+    }
+    processEffectTree(root);
+  }
+}
+function processEffectTree(effect) {
+  let child = effect.first;
+  while (child !== null) {
+    const next = child.next;
+    if (isDirty(child)) {
+      updateEffectImpl(child);
+    }
+    if (child.first !== null) {
+      processEffectTree(child);
+    }
+    child = next;
+  }
+}
+function get(signal) {
+  if (activeReaction !== null && !untracking) {
+    if ((activeReaction.f & REACTION_IS_UPDATING) !== 0) {
+      if (signal.rv < readVersion) {
+        signal.rv = readVersion;
+        const deps = activeReaction.deps;
+        if (newDeps === null && deps !== null && deps[skippedDeps] === signal) {
+          setSkippedDeps(skippedDeps + 1);
+        } else {
+          if (newDeps === null) {
+            setNewDeps([signal]);
+          } else {
+            newDeps.push(signal);
+          }
+        }
+      }
+    } else {
+      if (activeReaction.deps === null) {
+        activeReaction.deps = [signal];
+      } else if (!activeReaction.deps.includes(signal)) {
+        activeReaction.deps.push(signal);
+      }
+      if (signal.reactions === null) {
+        signal.reactions = [activeReaction];
+      } else if (!signal.reactions.includes(activeReaction)) {
+        signal.reactions.push(activeReaction);
+      }
+    }
+  }
+  if ((signal.f & DERIVED) !== 0) {
+    const derived = signal;
+    if (isDirty(derived)) {
+      updateDerived(derived);
+    }
+  }
+  return signal.v;
+}
+function set(signal, value) {
+  if (activeReaction !== null && (activeReaction.f & DERIVED) !== 0) {
+    throw new Error("Cannot write to signals inside a derived. " + "Deriveds should be pure computations with no side effects.");
+  }
+  if (!signal.equals(signal.v, value)) {
+    signal.v = value;
+    signal.wv = incrementWriteVersion();
+    markReactions(signal, DIRTY);
+    if (activeEffect !== null && (activeEffect.f & CLEAN) !== 0 && (activeEffect.f & (ROOT_EFFECT | BRANCH_EFFECT)) === 0) {
+      addUntrackedWrite(signal);
+    }
+  }
+  return value;
+}
+function markReactions(signal, status) {
+  const reactions = signal.reactions;
+  if (reactions === null)
+    return;
+  for (let i = 0;i < reactions.length; i++) {
+    const reaction = reactions[i];
+    const flags = reaction.f;
+    const notDirty = (flags & DIRTY) === 0;
+    if (notDirty) {
+      setSignalStatus(reaction, status);
+    }
+    if ((flags & DERIVED) !== 0) {
+      markReactions(reaction, MAYBE_DIRTY);
+    } else if (notDirty) {
+      scheduleEffect(reaction);
+    }
+  }
+}
+function setSignalStatus(signal, status) {
+  signal.f = signal.f & STATUS_MASK | status;
+}
+function isDirty(reaction) {
+  if ((reaction.f & DIRTY) !== 0) {
+    return true;
+  }
+  if ((reaction.f & MAYBE_DIRTY) !== 0) {
+    const deps = reaction.deps;
+    if (deps !== null) {
+      for (let i = 0;i < deps.length; i++) {
+        const dep = deps[i];
+        if ((dep.f & DERIVED) !== 0) {
+          if (isDirty(dep)) {
+            updateDerived(dep);
+          }
+        }
+        if (dep.wv > reaction.wv) {
+          return true;
+        }
+      }
+    }
+    setSignalStatus(reaction, CLEAN);
+  }
+  return false;
+}
+var updateDerivedImpl = () => {
+  throw new Error("updateDerived not initialized - import derived.ts first");
+};
+function updateDerived(derived) {
+  updateDerivedImpl(derived);
+}
+function setUpdateDerivedImpl(impl) {
+  updateDerivedImpl = impl;
+}
+function removeReactions(reaction, start) {
+  const deps = reaction.deps;
+  if (deps === null)
+    return;
+  for (let i = start;i < deps.length; i++) {
+    removeReaction(reaction, deps[i]);
+  }
+}
+function removeReaction(reaction, dep) {
+  const reactions = dep.reactions;
+  if (reactions === null)
+    return;
+  const index = reactions.indexOf(reaction);
+  if (index !== -1) {
+    const last = reactions.length - 1;
+    if (index !== last) {
+      reactions[index] = reactions[last];
+    }
+    reactions.pop();
+    if (reactions.length === 0) {
+      dep.reactions = null;
+    }
+  }
+}
+function updateReaction(reaction) {
+  const prevNewDeps = newDeps;
+  const prevSkippedDeps = skippedDeps;
+  const prevReaction = activeReaction;
+  const prevUntrackedWrites = untrackedWrites;
+  setNewDeps(null);
+  setSkippedDeps(0);
+  setActiveReaction(reaction);
+  setUntrackedWrites(null);
+  const prevReadVersion = readVersion;
+  incrementReadVersion();
+  reaction.f |= REACTION_IS_UPDATING;
+  try {
+    const result = reaction.fn();
+    const deps = reaction.deps;
+    if (newDeps !== null) {
+      removeReactions(reaction, skippedDeps);
+      if (deps !== null && skippedDeps > 0) {
+        deps.length = skippedDeps + newDeps.length;
+        for (let i = 0;i < newDeps.length; i++) {
+          deps[skippedDeps + i] = newDeps[i];
+        }
+      } else {
+        reaction.deps = newDeps;
+      }
+      const finalDeps = reaction.deps;
+      for (let i = skippedDeps;i < finalDeps.length; i++) {
+        const dep = finalDeps[i];
+        if (dep.reactions === null) {
+          dep.reactions = [reaction];
+        } else {
+          dep.reactions.push(reaction);
+        }
+      }
+    } else if (deps !== null && skippedDeps < deps.length) {
+      removeReactions(reaction, skippedDeps);
+      deps.length = skippedDeps;
+    }
+    if (untrackedWrites !== null && reaction.deps !== null && (reaction.f & EFFECT) !== 0 && (reaction.f & DERIVED) === 0) {
+      for (const signal of untrackedWrites) {
+        if (reaction.deps.includes(signal)) {
+          setSignalStatus(reaction, DIRTY);
+          scheduleEffect(reaction);
+          break;
+        }
+      }
+    }
+    return result;
+  } finally {
+    reaction.f &= ~REACTION_IS_UPDATING;
+    setNewDeps(prevNewDeps);
+    setSkippedDeps(prevSkippedDeps);
+    setActiveReaction(prevReaction);
+    if (untrackedWrites !== null) {
+      if (prevUntrackedWrites === null) {
+        setUntrackedWrites(untrackedWrites);
+      } else {
+        prevUntrackedWrites.push(...untrackedWrites);
+        setUntrackedWrites(prevUntrackedWrites);
+      }
+    } else {
+      setUntrackedWrites(prevUntrackedWrites);
+    }
+  }
+}
+function source(initialValue, options) {
+  return {
+    f: 0,
+    v: initialValue,
+    equals: options?.equals ?? equals,
+    reactions: null,
+    rv: 0,
+    wv: 0
+  };
+}
+function signal(initialValue, options) {
+  const src = source(initialValue, options);
+  return {
+    get value() {
+      return get(src);
+    },
+    set value(newValue) {
+      set(src, newValue);
+    }
+  };
+}
+var proxyFn = null;
+function setProxyFn(fn) {
+  proxyFn = fn;
+}
+function shouldProxy(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === Array.prototype || proto === null;
+}
+function isProxy(value) {
+  return value !== null && typeof value === "object" && STATE_SYMBOL in value;
+}
+function isWritable(target, prop) {
+  const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+  return descriptor === undefined || descriptor.writable === true;
+}
+function proxy(value) {
+  if (!shouldProxy(value) || isProxy(value)) {
+    return value;
+  }
+  const sources = new Map;
+  const version = source(0);
+  const isArray = Array.isArray(value);
+  if (isArray) {
+    sources.set("length", source(value.length));
+  }
+  const parentReadVersion = readVersion;
+  const withParent = (fn) => {
+    if (readVersion === parentReadVersion) {
+      return fn();
+    }
+    const prevReaction = activeReaction;
+    setActiveReaction(null);
+    try {
+      return fn();
+    } finally {
+      setActiveReaction(prevReaction);
+    }
+  };
+  const getSource = (prop, initialValue) => {
+    let s = sources.get(prop);
+    if (s === undefined) {
+      s = withParent(() => {
+        const proxied = shouldProxy(initialValue) ? proxy(initialValue) : initialValue;
+        return source(proxied);
+      });
+      sources.set(prop, s);
+    }
+    return s;
+  };
+  const proxyObj = new Proxy(value, {
+    get(target, prop, receiver) {
+      if (prop === STATE_SYMBOL) {
+        return value;
+      }
+      const exists = prop in target;
+      const currentValue = Reflect.get(target, prop, receiver);
+      if (isArray && typeof currentValue === "function") {
+        get(version);
+        return currentValue.bind(proxyObj);
+      }
+      if (exists || isWritable(target, prop)) {
+        const s = getSource(prop, currentValue);
+        const val = get(s);
+        if (val === UNINITIALIZED) {
+          return;
+        }
+        return val;
+      }
+      return currentValue;
+    },
+    set(target, prop, newValue, receiver) {
+      const exists = prop in target;
+      let s = sources.get(prop);
+      if (s === undefined) {
+        if (!exists && !isWritable(target, prop)) {
+          return false;
+        }
+        s = withParent(() => source(undefined));
+        sources.set(prop, s);
+      }
+      const proxied = withParent(() => shouldProxy(newValue) ? proxy(newValue) : newValue);
+      set(s, proxied);
+      Reflect.set(target, prop, newValue, receiver);
+      if (isArray && prop === "length") {
+        const oldLength = s.v;
+        const newLength = newValue;
+        for (let i = newLength;i < oldLength; i++) {
+          const indexKey = String(i);
+          const indexSource = sources.get(indexKey);
+          if (indexSource !== undefined) {
+            set(indexSource, UNINITIALIZED);
+          } else if (i in target) {
+            const deletedSource = withParent(() => source(UNINITIALIZED));
+            sources.set(indexKey, deletedSource);
+          }
+        }
+      }
+      if (isArray && typeof prop === "string") {
+        const index = Number(prop);
+        if (Number.isInteger(index) && index >= 0) {
+          const lengthSource = sources.get("length");
+          if (lengthSource !== undefined && index >= lengthSource.v) {
+            set(lengthSource, index + 1);
+          }
+        }
+      }
+      if (!exists) {
+        set(version, get(version) + 1);
+      }
+      return true;
+    },
+    deleteProperty(target, prop) {
+      const exists = prop in target;
+      if (exists) {
+        let s = sources.get(prop);
+        if (s === undefined) {
+          s = withParent(() => source(UNINITIALIZED));
+          sources.set(prop, s);
+        } else {
+          set(s, UNINITIALIZED);
+        }
+        set(version, get(version) + 1);
+      }
+      return Reflect.deleteProperty(target, prop);
+    },
+    has(target, prop) {
+      if (prop === STATE_SYMBOL) {
+        return true;
+      }
+      get(version);
+      const s = sources.get(prop);
+      if (s !== undefined) {
+        const val = get(s);
+        if (val === UNINITIALIZED) {
+          return false;
+        }
+      }
+      return Reflect.has(target, prop);
+    },
+    ownKeys(target) {
+      get(version);
+      const keys = Reflect.ownKeys(target).filter((key) => {
+        const s = sources.get(key);
+        return s === undefined || s.v !== UNINITIALIZED;
+      });
+      for (const [key, s] of sources) {
+        const k = key;
+        if (s.v !== UNINITIALIZED && !(key in target) && !keys.includes(k)) {
+          keys.push(k);
+        }
+      }
+      return keys;
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      const s = sources.get(prop);
+      if (s !== undefined && s.v === UNINITIALIZED) {
+        return;
+      }
+      return Reflect.getOwnPropertyDescriptor(target, prop);
+    }
+  });
+  return proxyObj;
+}
+function createDerived(fn, options) {
+  let flags = DERIVED | DIRTY;
+  const parentDerived = activeReaction !== null && (activeReaction.f & DERIVED) !== 0 ? activeReaction : null;
+  if (activeEffect === null || parentDerived !== null && (parentDerived.f & UNOWNED) !== 0) {
+    flags |= UNOWNED;
+  }
+  const derived = {
+    f: flags,
+    fn,
+    v: UNINITIALIZED,
+    equals: options?.equals ?? equals,
+    reactions: null,
+    deps: null,
+    effects: null,
+    parent: parentDerived ?? activeEffect,
+    rv: 0,
+    wv: 0
+  };
+  return derived;
+}
+function executeDerived(derived) {
+  destroyDerivedEffects(derived);
+  const value = updateReaction(derived);
+  return value;
+}
+function updateDerived2(derived) {
+  const value = executeDerived(derived);
+  if (!derived.equals(derived.v, value)) {
+    derived.v = value;
+    derived.wv = incrementWriteVersion();
+  }
+  const status = (derived.f & UNOWNED) !== 0 && derived.deps !== null ? MAYBE_DIRTY : CLEAN;
+  setSignalStatus(derived, status);
+}
+setUpdateDerivedImpl(updateDerived2);
+var destroyEffectImpl = () => {};
+function setDestroyEffectImpl(impl) {
+  destroyEffectImpl = impl;
+}
+function destroyDerivedEffects(derived) {
+  const effects = derived.effects;
+  if (effects !== null) {
+    derived.effects = null;
+    for (let i = 0;i < effects.length; i++) {
+      destroyEffectImpl(effects[i]);
+    }
+  }
+}
+function derived(fn, options) {
+  const d = createDerived(fn, options);
+  return {
+    get value() {
+      return get(d);
+    }
+  };
+}
+derived.by = derived;
+function createEffect(type, fn, sync, push = true) {
+  const parent = activeEffect;
+  const effect = {
+    f: type | DIRTY,
+    fn,
+    deps: null,
+    teardown: null,
+    parent,
+    first: null,
+    last: null,
+    prev: null,
+    next: null,
+    wv: 0
+  };
+  if (sync) {
+    updateEffect(effect);
+    effect.f |= EFFECT_RAN;
+  } else if (fn !== null) {
+    scheduleEffect(effect);
+  }
+  if (push && parent !== null) {
+    pushEffect(effect, parent);
+  }
+  return effect;
+}
+function pushEffect(effect, parent) {
+  const parentLast = parent.last;
+  if (parentLast === null) {
+    parent.first = parent.last = effect;
+  } else {
+    parentLast.next = effect;
+    effect.prev = parentLast;
+    parent.last = effect;
+  }
+}
+function updateEffect(effect) {
+  if ((effect.f & DESTROYED) !== 0)
+    return;
+  setSignalStatus(effect, CLEAN);
+  const prevEffect = activeEffect;
+  setActiveEffect(effect);
+  try {
+    destroyEffectChildren(effect);
+    executeTeardown(effect);
+    const teardown = updateReaction(effect);
+    effect.teardown = typeof teardown === "function" ? teardown : null;
+    effect.wv = incrementWriteVersion();
+  } finally {
+    setActiveEffect(prevEffect);
+  }
+}
+setUpdateEffectImpl(updateEffect);
+function destroyEffect(effect, removeFromParent = true) {
+  destroyEffectChildren(effect);
+  removeReactions(effect, 0);
+  setSignalStatus(effect, DESTROYED);
+  executeTeardown(effect);
+  if (removeFromParent && effect.parent !== null) {
+    unlinkEffect(effect);
+  }
+  effect.fn = null;
+  effect.teardown = null;
+  effect.deps = null;
+  effect.first = null;
+  effect.last = null;
+  effect.prev = null;
+  effect.next = null;
+}
+setDestroyEffectImpl(destroyEffect);
+function destroyEffectChildren(effect) {
+  let child = effect.first;
+  effect.first = null;
+  effect.last = null;
+  while (child !== null) {
+    const next = child.next;
+    if ((child.f & (EFFECT_PRESERVED | ROOT_EFFECT)) === 0) {
+      destroyEffect(child, false);
+    }
+    child = next;
+  }
+}
+function executeTeardown(effect) {
+  const teardown = effect.teardown;
+  if (teardown !== null) {
+    effect.teardown = null;
+    teardown();
+  }
+}
+function unlinkEffect(effect) {
+  const { parent, prev, next } = effect;
+  if (prev !== null) {
+    prev.next = next;
+  }
+  if (next !== null) {
+    next.prev = prev;
+  }
+  if (parent !== null) {
+    if (parent.first === effect) {
+      parent.first = next;
+    }
+    if (parent.last === effect) {
+      parent.last = prev;
+    }
+  }
+  effect.prev = null;
+  effect.next = null;
+}
+function effect(fn) {
+  const eff = createEffect(EFFECT | USER_EFFECT, fn, false);
+  return () => destroyEffect(eff);
+}
+effect.pre = function effectPre(fn) {
+  const eff = createEffect(RENDER_EFFECT | USER_EFFECT, fn, true);
+  return () => destroyEffect(eff);
+};
+effect.root = function effectRoot(fn) {
+  const eff = createEffect(ROOT_EFFECT | EFFECT_PRESERVED, fn, true);
+  return () => destroyEffect(eff);
+};
+effect.tracking = function effectTracking() {
+  return activeEffect !== null;
+};
+class ReactiveMap extends Map {
+  #keySignals = new Map;
+  #version = source(0);
+  #size;
+  constructor(entries) {
+    super(entries);
+    this.#size = source(super.size);
+  }
+  #getKeySignal(key) {
+    let sig = this.#keySignals.get(key);
+    if (sig === undefined) {
+      sig = source(0);
+      this.#keySignals.set(key, sig);
+    }
+    return sig;
+  }
+  #increment(sig) {
+    set(sig, sig.v + 1);
+  }
+  get size() {
+    get(this.#size);
+    return super.size;
+  }
+  has(key) {
+    const sig = this.#keySignals.get(key);
+    if (sig === undefined) {
+      if (!super.has(key)) {
+        get(this.#version);
+        return false;
+      }
+      const newSig = this.#getKeySignal(key);
+      get(newSig);
+      return true;
+    }
+    get(sig);
+    return super.has(key);
+  }
+  get(key) {
+    const sig = this.#keySignals.get(key);
+    if (sig === undefined) {
+      const val = super.get(key);
+      if (val !== undefined) {
+        const newSig = this.#getKeySignal(key);
+        get(newSig);
+        return val;
+      }
+      get(this.#version);
+      return;
+    }
+    get(sig);
+    return super.get(key);
+  }
+  set(key, value) {
+    const isNew = !super.has(key);
+    const oldValue = super.get(key);
+    super.set(key, value);
+    const sig = this.#getKeySignal(key);
+    if (isNew) {
+      set(this.#size, super.size);
+      this.#increment(this.#version);
+      this.#increment(sig);
+    } else if (!Object.is(oldValue, value)) {
+      this.#increment(sig);
+      const versionReactions = this.#version.reactions;
+      const keyReactions = sig.reactions;
+      if (keyReactions !== null && (versionReactions === null || !keyReactions.every((r) => versionReactions.includes(r)))) {
+        this.#increment(this.#version);
+      }
+    }
+    return this;
+  }
+  delete(key) {
+    const existed = super.has(key);
+    if (existed) {
+      super.delete(key);
+      const sig = this.#keySignals.get(key);
+      if (sig !== undefined) {
+        set(sig, -1);
+        this.#keySignals.delete(key);
+      }
+      set(this.#size, super.size);
+      this.#increment(this.#version);
+    }
+    return existed;
+  }
+  clear() {
+    if (super.size > 0) {
+      for (const [key, sig] of this.#keySignals) {
+        set(sig, -1);
+      }
+      this.#keySignals.clear();
+      super.clear();
+      set(this.#size, 0);
+      this.#increment(this.#version);
+    }
+  }
+  keys() {
+    get(this.#version);
+    return super.keys();
+  }
+  values() {
+    get(this.#version);
+    return super.values();
+  }
+  entries() {
+    get(this.#version);
+    return super.entries();
+  }
+  forEach(callbackfn, thisArg) {
+    get(this.#version);
+    super.forEach(callbackfn, thisArg);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+
+class ReactiveSet extends Set {
+  #itemSignals = new Map;
+  #version = source(0);
+  #size;
+  constructor(values) {
+    super(values);
+    this.#size = source(super.size);
+  }
+  #getItemSignal(item) {
+    let sig = this.#itemSignals.get(item);
+    if (sig === undefined) {
+      sig = source(super.has(item));
+      this.#itemSignals.set(item, sig);
+    }
+    return sig;
+  }
+  #incrementVersion() {
+    set(this.#version, this.#version.v + 1);
+  }
+  get size() {
+    get(this.#size);
+    return super.size;
+  }
+  has(item) {
+    const sig = this.#itemSignals.get(item);
+    if (sig === undefined) {
+      const exists = super.has(item);
+      if (exists) {
+        const newSig = this.#getItemSignal(item);
+        get(newSig);
+        return true;
+      }
+      get(this.#version);
+      return false;
+    }
+    get(sig);
+    return super.has(item);
+  }
+  add(item) {
+    const isNew = !super.has(item);
+    super.add(item);
+    if (isNew) {
+      const sig = this.#getItemSignal(item);
+      set(sig, true);
+      set(this.#size, super.size);
+      this.#incrementVersion();
+    }
+    return this;
+  }
+  delete(item) {
+    const existed = super.has(item);
+    if (existed) {
+      super.delete(item);
+      const sig = this.#itemSignals.get(item);
+      if (sig !== undefined) {
+        set(sig, false);
+        this.#itemSignals.delete(item);
+      }
+      set(this.#size, super.size);
+      this.#incrementVersion();
+    }
+    return existed;
+  }
+  clear() {
+    if (super.size > 0) {
+      for (const [item, sig] of this.#itemSignals) {
+        set(sig, false);
+      }
+      this.#itemSignals.clear();
+      super.clear();
+      set(this.#size, 0);
+      this.#incrementVersion();
+    }
+  }
+  keys() {
+    get(this.#version);
+    return super.keys();
+  }
+  values() {
+    get(this.#version);
+    return super.values();
+  }
+  entries() {
+    get(this.#version);
+    return super.entries();
+  }
+  forEach(callbackfn, thisArg) {
+    get(this.#version);
+    super.forEach(callbackfn, thisArg);
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+}
+
+class ReactiveDate extends Date {
+  #time;
+  constructor(...args) {
+    super(...args);
+    this.#time = source(super.getTime());
+  }
+  #update() {
+    const time = super.getTime();
+    set(this.#time, time);
+    return time;
+  }
+  getTime() {
+    get(this.#time);
+    return super.getTime();
+  }
+  getFullYear() {
+    get(this.#time);
+    return super.getFullYear();
+  }
+  getMonth() {
+    get(this.#time);
+    return super.getMonth();
+  }
+  getDate() {
+    get(this.#time);
+    return super.getDate();
+  }
+  getDay() {
+    get(this.#time);
+    return super.getDay();
+  }
+  getHours() {
+    get(this.#time);
+    return super.getHours();
+  }
+  getMinutes() {
+    get(this.#time);
+    return super.getMinutes();
+  }
+  getSeconds() {
+    get(this.#time);
+    return super.getSeconds();
+  }
+  getMilliseconds() {
+    get(this.#time);
+    return super.getMilliseconds();
+  }
+  getUTCFullYear() {
+    get(this.#time);
+    return super.getUTCFullYear();
+  }
+  getUTCMonth() {
+    get(this.#time);
+    return super.getUTCMonth();
+  }
+  getUTCDate() {
+    get(this.#time);
+    return super.getUTCDate();
+  }
+  getUTCDay() {
+    get(this.#time);
+    return super.getUTCDay();
+  }
+  getUTCHours() {
+    get(this.#time);
+    return super.getUTCHours();
+  }
+  getUTCMinutes() {
+    get(this.#time);
+    return super.getUTCMinutes();
+  }
+  getUTCSeconds() {
+    get(this.#time);
+    return super.getUTCSeconds();
+  }
+  getUTCMilliseconds() {
+    get(this.#time);
+    return super.getUTCMilliseconds();
+  }
+  getTimezoneOffset() {
+    get(this.#time);
+    return super.getTimezoneOffset();
+  }
+  setTime(time) {
+    super.setTime(time);
+    return this.#update();
+  }
+  setFullYear(year, month, date) {
+    if (date !== undefined) {
+      super.setFullYear(year, month, date);
+    } else if (month !== undefined) {
+      super.setFullYear(year, month);
+    } else {
+      super.setFullYear(year);
+    }
+    return this.#update();
+  }
+  setMonth(month, date) {
+    if (date !== undefined) {
+      super.setMonth(month, date);
+    } else {
+      super.setMonth(month);
+    }
+    return this.#update();
+  }
+  setDate(date) {
+    super.setDate(date);
+    return this.#update();
+  }
+  setHours(hours, min, sec, ms) {
+    if (ms !== undefined) {
+      super.setHours(hours, min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setHours(hours, min, sec);
+    } else if (min !== undefined) {
+      super.setHours(hours, min);
+    } else {
+      super.setHours(hours);
+    }
+    return this.#update();
+  }
+  setMinutes(min, sec, ms) {
+    if (ms !== undefined) {
+      super.setMinutes(min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setMinutes(min, sec);
+    } else {
+      super.setMinutes(min);
+    }
+    return this.#update();
+  }
+  setSeconds(sec, ms) {
+    if (ms !== undefined) {
+      super.setSeconds(sec, ms);
+    } else {
+      super.setSeconds(sec);
+    }
+    return this.#update();
+  }
+  setMilliseconds(ms) {
+    super.setMilliseconds(ms);
+    return this.#update();
+  }
+  setUTCFullYear(year, month, date) {
+    if (date !== undefined) {
+      super.setUTCFullYear(year, month, date);
+    } else if (month !== undefined) {
+      super.setUTCFullYear(year, month);
+    } else {
+      super.setUTCFullYear(year);
+    }
+    return this.#update();
+  }
+  setUTCMonth(month, date) {
+    if (date !== undefined) {
+      super.setUTCMonth(month, date);
+    } else {
+      super.setUTCMonth(month);
+    }
+    return this.#update();
+  }
+  setUTCDate(date) {
+    super.setUTCDate(date);
+    return this.#update();
+  }
+  setUTCHours(hours, min, sec, ms) {
+    if (ms !== undefined) {
+      super.setUTCHours(hours, min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setUTCHours(hours, min, sec);
+    } else if (min !== undefined) {
+      super.setUTCHours(hours, min);
+    } else {
+      super.setUTCHours(hours);
+    }
+    return this.#update();
+  }
+  setUTCMinutes(min, sec, ms) {
+    if (ms !== undefined) {
+      super.setUTCMinutes(min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setUTCMinutes(min, sec);
+    } else {
+      super.setUTCMinutes(min);
+    }
+    return this.#update();
+  }
+  setUTCSeconds(sec, ms) {
+    if (ms !== undefined) {
+      super.setUTCSeconds(sec, ms);
+    } else {
+      super.setUTCSeconds(sec);
+    }
+    return this.#update();
+  }
+  setUTCMilliseconds(ms) {
+    super.setUTCMilliseconds(ms);
+    return this.#update();
+  }
+  toString() {
+    get(this.#time);
+    return super.toString();
+  }
+  toDateString() {
+    get(this.#time);
+    return super.toDateString();
+  }
+  toTimeString() {
+    get(this.#time);
+    return super.toTimeString();
+  }
+  toISOString() {
+    get(this.#time);
+    return super.toISOString();
+  }
+  toUTCString() {
+    get(this.#time);
+    return super.toUTCString();
+  }
+  toLocaleString(locales, options) {
+    get(this.#time);
+    return super.toLocaleString(locales, options);
+  }
+  toLocaleDateString(locales, options) {
+    get(this.#time);
+    return super.toLocaleDateString(locales, options);
+  }
+  toLocaleTimeString(locales, options) {
+    get(this.#time);
+    return super.toLocaleTimeString(locales, options);
+  }
+  toJSON() {
+    get(this.#time);
+    return super.toJSON();
+  }
+  valueOf() {
+    get(this.#time);
+    return super.valueOf();
+  }
+}
+setProxyFn(proxy);
+
+// src/core/registry.ts
+function createRegistry() {
+  const idToIndex = new ReactiveMap;
+  const indexToId = new ReactiveMap;
+  const allocatedIndices = new ReactiveSet;
+  const freeIndices = [];
+  const _nextIndex = signal(0);
+  const registry = {
+    idToIndex,
+    indexToId,
+    allocatedIndices,
+    freeIndices,
+    get nextIndex() {
+      return _nextIndex.value;
+    },
+    set nextIndex(value) {
+      _nextIndex.value = value;
+    },
+    allocate(id) {
+      const existingIndex = idToIndex.get(id);
+      if (existingIndex !== undefined) {
+        return existingIndex;
+      }
+      let index;
+      if (freeIndices.length > 0) {
+        index = freeIndices.pop();
+      } else {
+        index = _nextIndex.value;
+        _nextIndex.value++;
+      }
+      idToIndex.set(id, index);
+      indexToId.set(index, id);
+      allocatedIndices.add(index);
+      return index;
+    },
+    release(id) {
+      const index = idToIndex.get(id);
+      if (index === undefined) {
+        return false;
+      }
+      idToIndex.delete(id);
+      indexToId.delete(index);
+      allocatedIndices.delete(index);
+      freeIndices.push(index);
+      return true;
+    },
+    getIndex(id) {
+      return idToIndex.get(id) ?? -1;
+    },
+    getId(index) {
+      return indexToId.get(index);
+    },
+    has(id) {
+      return idToIndex.has(id);
+    },
+    getAllIds() {
+      return Array.from(idToIndex.keys());
+    },
+    getAllIndices() {
+      return Array.from(allocatedIndices);
+    },
+    get count() {
+      return idToIndex.size;
+    },
+    reset() {
+      idToIndex.clear();
+      indexToId.clear();
+      allocatedIndices.clear();
+      freeIndices.length = 0;
+      _nextIndex.value = 0;
+    }
+  };
+  return registry;
+}
+function generateId() {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${timestamp}-${random}`;
+}
+
+// src/core/constants.ts
+var DEFAULT_VALUES = {
+  string: "",
+  number: 0,
+  boolean: false,
+  timestamp: 0,
+  "string[]": [],
+  "number[]": [],
+  vector: null
+};
+var WATCHER_DEBOUNCE_MS = 100;
+var SAVE_GRACE_PERIOD_MS = 200;
+var DEFAULT_PAGE_SIZE = 20;
+
+// src/core/columns.ts
+function parseColumnType(type) {
+  if (type === "string")
+    return { baseType: "string" };
+  if (type === "number")
+    return { baseType: "number" };
+  if (type === "boolean")
+    return { baseType: "boolean" };
+  if (type === "timestamp")
+    return { baseType: "timestamp" };
+  if (type === "string[]")
+    return { baseType: "array", arrayType: "string" };
+  if (type === "number[]")
+    return { baseType: "array", arrayType: "number" };
+  const vectorMatch = type.match(/^vector:(\d+)$/);
+  if (vectorMatch) {
+    return {
+      baseType: "vector",
+      vectorDimensions: parseInt(vectorMatch[1], 10)
+    };
+  }
+  throw new Error(`Unknown column type: ${type}`);
+}
+function getDefaultValue(type) {
+  const parsed = parseColumnType(type);
+  switch (parsed.baseType) {
+    case "string":
+      return DEFAULT_VALUES.string;
+    case "number":
+    case "timestamp":
+      return DEFAULT_VALUES.number;
+    case "boolean":
+      return DEFAULT_VALUES.boolean;
+    case "array":
+      return parsed.arrayType === "string" ? [...DEFAULT_VALUES["string[]"]] : [...DEFAULT_VALUES["number[]"]];
+    case "vector":
+      return DEFAULT_VALUES.vector;
+    default:
+      return null;
+  }
+}
+function parseSchema(definition) {
+  const columns = Object.keys(definition);
+  const vectorColumns = [];
+  const parsedTypes = new Map;
+  for (const col of columns) {
+    const parsed = parseColumnType(definition[col]);
+    parsedTypes.set(col, parsed);
+    if (parsed.baseType === "vector") {
+      vectorColumns.push(col);
+    }
+  }
+  return {
+    definition,
+    columns,
+    vectorColumns,
+    parsedTypes
+  };
+}
+function createColumns(definition) {
+  const schema = parseSchema(definition);
+  const columns = new Map;
+  for (const col of schema.columns) {
+    columns.set(col, signal([]));
+  }
+  const manager = {
+    schema,
+    getColumn(name) {
+      const col = columns.get(name);
+      if (!col) {
+        throw new Error(`Unknown column: ${String(name)}`);
+      }
+      return col;
+    },
+    get(column, index) {
+      const col = columns.get(column);
+      if (!col) {
+        throw new Error(`Unknown column: ${String(column)}`);
+      }
+      return col.value[index];
+    },
+    set(column, index, value) {
+      const col = columns.get(column);
+      if (!col) {
+        throw new Error(`Unknown column: ${String(column)}`);
+      }
+      const parsed = schema.parsedTypes.get(column);
+      if (parsed?.baseType === "vector" && Array.isArray(value)) {
+        value = new Float32Array(value);
+      }
+      const arr = col.value;
+      while (arr.length <= index) {
+        arr.push(getDefaultValue(definition[column]));
+      }
+      arr[index] = value;
+      col.value = arr;
+    },
+    getRecord(index) {
+      const record = {};
+      for (const col of schema.columns) {
+        record[col] = manager.get(col, index);
+      }
+      return record;
+    },
+    setRecord(index, record) {
+      for (const col of schema.columns) {
+        if (col in record) {
+          manager.set(col, index, record[col]);
+        } else {
+          const defaultValue = getDefaultValue(definition[col]);
+          manager.set(col, index, defaultValue);
+        }
+      }
+    },
+    clearAt(index) {
+      for (const col of schema.columns) {
+        const defaultValue = getDefaultValue(definition[col]);
+        manager.set(col, index, defaultValue);
+      }
+    },
+    reset() {
+      for (const col of schema.columns) {
+        const colSignal = columns.get(col);
+        if (colSignal) {
+          colSignal.value = [];
+        }
+      }
+    }
+  };
+  return manager;
+}
+
+// src/core/collection.ts
+function createMetadataArrays() {
+  return {
+    created: signal([]),
+    updated: signal([]),
+    stale: signal([])
+  };
+}
+function createCollection(name, options) {
+  const { schema, contentColumn } = options;
+  const registry = createRegistry();
+  const columns = createColumns(schema);
+  const metadata = createMetadataArrays();
+  function buildRecord(index) {
+    const id = registry.getId(index);
+    if (!id)
+      throw new Error(`No ID for index ${index}`);
+    const data = columns.getRecord(index);
+    return {
+      ...data,
+      id,
+      created: metadata.created.value[index] ?? 0,
+      updated: metadata.updated.value[index] ?? 0,
+      stale: metadata.stale.value[index] ?? false
+    };
+  }
+  function setMetadataAt(index, created, updated, stale) {
+    const createdArr = metadata.created.value;
+    const updatedArr = metadata.updated.value;
+    const staleArr = metadata.stale.value;
+    while (createdArr.length <= index)
+      createdArr.push(0);
+    while (updatedArr.length <= index)
+      updatedArr.push(0);
+    while (staleArr.length <= index)
+      staleArr.push(false);
+    createdArr[index] = created;
+    updatedArr[index] = updated;
+    staleArr[index] = stale;
+    metadata.created.value = createdArr;
+    metadata.updated.value = updatedArr;
+    metadata.stale.value = staleArr;
+  }
+  const collection = {
+    name,
+    schema,
+    contentColumn,
+    registry,
+    columns,
+    insert(data) {
+      const id = data.id ?? generateId();
+      const index = registry.allocate(id);
+      const now = Date.now();
+      columns.setRecord(index, data);
+      setMetadataAt(index, now, now, false);
+      return id;
+    },
+    insertMany(records) {
+      return records.map((record) => collection.insert(record));
+    },
+    get(id) {
+      const index = registry.getIndex(id);
+      if (index === -1)
+        return;
+      return buildRecord(index);
+    },
+    all() {
+      const indices = registry.getAllIndices();
+      return indices.map((index) => buildRecord(index));
+    },
+    find(filter) {
+      const results = [];
+      const indices = registry.getAllIndices();
+      for (const index of indices) {
+        const data = columns.getRecord(index);
+        if (filter(data, index)) {
+          results.push(buildRecord(index));
+        }
+      }
+      return results;
+    },
+    findOne(filter) {
+      const indices = registry.getAllIndices();
+      for (const index of indices) {
+        const data = columns.getRecord(index);
+        if (filter(data, index)) {
+          return buildRecord(index);
+        }
+      }
+      return;
+    },
+    update(id, data) {
+      const index = registry.getIndex(id);
+      if (index === -1)
+        return false;
+      for (const key of Object.keys(data)) {
+        columns.set(key, index, data[key]);
+      }
+      const updatedArr = metadata.updated.value;
+      updatedArr[index] = Date.now();
+      metadata.updated.value = updatedArr;
+      return true;
+    },
+    updateField(id, field, value) {
+      const index = registry.getIndex(id);
+      if (index === -1)
+        return false;
+      columns.set(field, index, value);
+      const updatedArr = metadata.updated.value;
+      updatedArr[index] = Date.now();
+      metadata.updated.value = updatedArr;
+      return true;
+    },
+    updateMany(filter, data) {
+      let count = 0;
+      const indices = registry.getAllIndices();
+      const now = Date.now();
+      for (const index of indices) {
+        const record = columns.getRecord(index);
+        if (filter(record, index)) {
+          for (const key of Object.keys(data)) {
+            columns.set(key, index, data[key]);
+          }
+          const updatedArr = metadata.updated.value;
+          updatedArr[index] = now;
+          metadata.updated.value = updatedArr;
+          count++;
+        }
+      }
+      return count;
+    },
+    delete(id) {
+      const index = registry.getIndex(id);
+      if (index === -1)
+        return false;
+      columns.clearAt(index);
+      const createdArr = metadata.created.value;
+      const updatedArr = metadata.updated.value;
+      const staleArr = metadata.stale.value;
+      if (index < createdArr.length)
+        createdArr[index] = 0;
+      if (index < updatedArr.length)
+        updatedArr[index] = 0;
+      if (index < staleArr.length)
+        staleArr[index] = false;
+      metadata.created.value = createdArr;
+      metadata.updated.value = updatedArr;
+      metadata.stale.value = staleArr;
+      registry.release(id);
+      return true;
+    },
+    deleteMany(filter) {
+      const toDelete = [];
+      const indices = registry.getAllIndices();
+      for (const index of indices) {
+        const data = columns.getRecord(index);
+        if (filter(data, index)) {
+          const id = registry.getId(index);
+          if (id)
+            toDelete.push(id);
+        }
+      }
+      for (const id of toDelete) {
+        collection.delete(id);
+      }
+      return toDelete.length;
+    },
+    count(filter) {
+      if (!filter) {
+        return registry.count;
+      }
+      let count = 0;
+      const indices = registry.getAllIndices();
+      for (const index of indices) {
+        const data = columns.getRecord(index);
+        if (filter(data, index))
+          count++;
+      }
+      return count;
+    },
+    reactiveCount: derived(() => registry.count),
+    getByIndex(index) {
+      if (!registry.allocatedIndices.has(index))
+        return;
+      return buildRecord(index);
+    },
+    getIndices() {
+      return registry.getAllIndices();
+    },
+    has(id) {
+      return registry.has(id);
+    },
+    isStale(id) {
+      const index = registry.getIndex(id);
+      if (index === -1)
+        return false;
+      return metadata.stale.value[index] ?? false;
+    },
+    getStaleIds() {
+      const ids = [];
+      const staleArr = metadata.stale.value;
+      for (const index of registry.getAllIndices()) {
+        if (staleArr[index]) {
+          const id = registry.getId(index);
+          if (id)
+            ids.push(id);
+        }
+      }
+      return ids;
+    },
+    setStale(id, stale) {
+      const index = registry.getIndex(id);
+      if (index === -1)
+        return;
+      const staleArr = metadata.stale.value;
+      while (staleArr.length <= index)
+        staleArr.push(false);
+      staleArr[index] = stale;
+      metadata.stale.value = staleArr;
+    },
+    clear() {
+      registry.reset();
+      columns.reset();
+      metadata.created.value = [];
+      metadata.updated.value = [];
+      metadata.stale.value = [];
+    }
+  };
+  return collection;
+}
+
+// src/persistence/markdown.ts
+function idToFilename(id) {
+  return id.replace(/[<>:"/\\|?*\x00-\x1f]/g, "_") + ".md";
+}
+function filenameToId(filename) {
+  return filename.replace(/\.md$/, "");
+}
+function parseMarkdown(text) {
+  const frontmatter = {};
+  let content = "";
+  if (!text.startsWith("---")) {
+    return { frontmatter, content: text.trim() };
+  }
+  const endIndex = text.indexOf(`
+---`, 3);
+  if (endIndex === -1) {
+    return { frontmatter, content: text.trim() };
+  }
+  const yamlText = text.slice(4, endIndex);
+  const lines = yamlText.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    frontmatter[key] = parseYamlValue(value);
+  }
+  content = text.slice(endIndex + 4).trim();
+  return { frontmatter, content };
+}
+function parseYamlValue(value) {
+  if (value === "null" || value === "~" || value === "") {
+    return null;
+  }
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (/^-?\d+$/.test(value)) {
+    return parseInt(value, 10);
+  }
+  if (/^-?\d+\.\d+$/.test(value)) {
+    return parseFloat(value);
+  }
+  if (value.startsWith("[") && value.endsWith("]")) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function toYamlValue(value) {
+  if (value === null || value === undefined) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  if (value instanceof Float32Array) {
+    return JSON.stringify(Array.from(value));
+  }
+  if (typeof value === "string") {
+    if (value.includes(":") || value.includes("#") || value.includes(`
+`) || value.startsWith('"') || value.startsWith("'") || value === "true" || value === "false" || value === "null") {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function generateMarkdown(record, schema, contentColumn) {
+  const lines = ["---"];
+  lines.push(`id: ${toYamlValue(record.id)}`);
+  lines.push(`created: ${record.created}`);
+  lines.push(`updated: ${record.updated}`);
+  for (const key of Object.keys(schema)) {
+    if (key === contentColumn)
+      continue;
+    const value = record[key];
+    lines.push(`${String(key)}: ${toYamlValue(value)}`);
+  }
+  lines.push("---");
+  lines.push("");
+  if (contentColumn) {
+    const content = record[contentColumn];
+    if (typeof content === "string") {
+      lines.push(content);
+    }
+  }
+  return lines.join(`
+`);
+}
+async function loadFromMarkdown(filepath, schema, contentColumn) {
+  try {
+    const file = Bun.file(filepath);
+    if (!await file.exists()) {
+      return null;
+    }
+    const text = await file.text();
+    const { frontmatter, content } = parseMarkdown(text);
+    const id = frontmatter.id;
+    if (!id) {
+      const filename = filepath.split("/").pop() || "";
+      return null;
+    }
+    const record = {
+      id,
+      created: frontmatter.created || Date.now(),
+      updated: frontmatter.updated || Date.now(),
+      stale: false
+    };
+    for (const key of Object.keys(schema)) {
+      if (key === contentColumn) {
+        record[key] = content;
+      } else if (key in frontmatter) {
+        let value = frontmatter[key];
+        const parsed = parseColumnType(schema[key]);
+        if (parsed.baseType === "vector" && Array.isArray(value)) {
+          value = new Float32Array(value);
+        }
+        record[key] = value;
+      }
+    }
+    return { id, record };
+  } catch {
+    return null;
+  }
+}
+async function saveToMarkdown(filepath, record, schema, contentColumn) {
+  try {
+    const markdown = generateMarkdown(record, schema, contentColumn);
+    await Bun.write(filepath, markdown);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadFromDirectory(dirpath, schema, contentColumn) {
+  const results = [];
+  try {
+    const glob = new Bun.Glob("*.md");
+    const files = glob.scanSync({ cwd: dirpath });
+    for (const filename of files) {
+      const filepath = `${dirpath}/${filename}`;
+      const result = await loadFromMarkdown(filepath, schema, contentColumn);
+      if (result) {
+        results.push(result);
+      }
+    }
+  } catch {}
+  return results;
+}
+async function deleteMarkdownFile(filepath) {
+  try {
+    const fs = await import("fs/promises");
+    await fs.unlink(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDirectory(dirpath) {
+  const fs = await import("fs/promises");
+  await fs.mkdir(dirpath, { recursive: true });
+}
+
+// src/persistence/watcher.ts
+import { watch } from "fs";
+function createFileWatcher(options) {
+  const {
+    dirpath,
+    schema,
+    contentColumn,
+    debounceMs = WATCHER_DEBOUNCE_MS
+  } = options;
+  const _isWatching = signal(false);
+  const _callbacks = new Set;
+  const _savingIds = new Set;
+  const _knownFiles = new Set;
+  const _pendingChanges = new Map;
+  let _watcher = null;
+  async function processChange(filename) {
+    if (!filename.endsWith(".md"))
+      return;
+    const id = filenameToId(filename);
+    const filepath = `${dirpath}/${filename}`;
+    if (_savingIds.has(id)) {
+      return;
+    }
+    const file = Bun.file(filepath);
+    const exists = await file.exists();
+    let event;
+    if (!exists) {
+      if (!_knownFiles.has(filename))
+        return;
+      _knownFiles.delete(filename);
+      event = {
+        type: "delete",
+        id,
+        filename,
+        filepath,
+        stale: false
+      };
+    } else {
+      const isNew = !_knownFiles.has(filename);
+      _knownFiles.add(filename);
+      const result = await loadFromMarkdown(filepath, schema, contentColumn);
+      if (!result)
+        return;
+      let stale = false;
+      if (options.isStaleCallback && contentColumn) {
+        const content = result.record[contentColumn];
+        if (content) {
+          stale = options.isStaleCallback(id, content);
+        }
+      }
+      event = {
+        type: isNew ? "create" : "update",
+        id,
+        filename,
+        filepath,
+        record: result.record,
+        stale
+      };
+    }
+    for (const callback of _callbacks) {
+      try {
+        await callback(event);
+      } catch (err) {
+        console.error("File watcher callback error:", err);
+      }
+    }
+  }
+  function handleChange(filename) {
+    const existing = _pendingChanges.get(filename);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timeout = setTimeout(() => {
+      _pendingChanges.delete(filename);
+      processChange(filename);
+    }, debounceMs);
+    _pendingChanges.set(filename, timeout);
+  }
+  const watcher = {
+    start() {
+      if (_isWatching.value)
+        return;
+      try {
+        const glob = new Bun.Glob("*.md");
+        for (const filename of glob.scanSync({ cwd: dirpath })) {
+          _knownFiles.add(filename);
+        }
+        _watcher = watch(dirpath, { recursive: false }, (eventType, filename) => {
+          if (filename && filename.endsWith(".md")) {
+            handleChange(filename);
+          }
+        });
+        _isWatching.value = true;
+      } catch (err) {
+        console.error("Failed to start file watcher:", err);
+      }
+    },
+    stop() {
+      if (!_isWatching.value)
+        return;
+      for (const timeout of _pendingChanges.values()) {
+        clearTimeout(timeout);
+      }
+      _pendingChanges.clear();
+      if (_watcher) {
+        _watcher.close();
+        _watcher = null;
+      }
+      _isWatching.value = false;
+    },
+    get isWatching() {
+      return _isWatching.value;
+    },
+    onChange(callback) {
+      _callbacks.add(callback);
+      return () => _callbacks.delete(callback);
+    },
+    markSaving(id) {
+      _savingIds.add(id);
+    },
+    clearSaving(id) {
+      setTimeout(() => {
+        _savingIds.delete(id);
+      }, SAVE_GRACE_PERIOD_MS);
+    }
+  };
+  return watcher;
+}
+
+// src/vector/search.ts
+function toFloat32Array(arr) {
+  if (arr instanceof Float32Array)
+    return arr;
+  return new Float32Array(arr);
+}
+function normalizeVector(vec) {
+  let sum = 0;
+  for (let i = 0;i < vec.length; i++) {
+    sum += vec[i] * vec[i];
+  }
+  const norm = Math.sqrt(sum);
+  if (norm > 0) {
+    for (let i = 0;i < vec.length; i++) {
+      vec[i] /= norm;
+    }
+  }
+  return vec;
+}
+function cosineSimilarity(a, b) {
+  const vecA = a instanceof Float32Array ? a : new Float32Array(a);
+  const vecB = b instanceof Float32Array ? b : new Float32Array(b);
+  if (vecA.length !== vecB.length) {
+    throw new Error(`Vector dimension mismatch: ${vecA.length} vs ${vecB.length}`);
+  }
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < vecA.length; i++) {
+    dot += vecA[i] * vecB[i];
+    normA += vecA[i] * vecA[i];
+    normB += vecB[i] * vecB[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denom === 0)
+    return 0;
+  return dot / denom;
+}
+function batchCosineSimilarity(query, vectors, indices, topK) {
+  let queryNorm = 0;
+  for (let i = 0;i < query.length; i++) {
+    queryNorm += query[i] * query[i];
+  }
+  queryNorm = Math.sqrt(queryNorm);
+  if (queryNorm === 0)
+    return [];
+  const results = [];
+  for (let i = 0;i < vectors.length; i++) {
+    const vec = vectors[i];
+    if (!vec)
+      continue;
+    let dot = 0;
+    let vecNorm = 0;
+    for (let j = 0;j < query.length; j++) {
+      dot += query[j] * vec[j];
+      vecNorm += vec[j] * vec[j];
+    }
+    vecNorm = Math.sqrt(vecNorm);
+    if (vecNorm === 0)
+      continue;
+    const similarity = dot / (queryNorm * vecNorm);
+    results.push({ index: indices[i], similarity });
+  }
+  results.sort((a, b) => b.similarity - a.similarity);
+  return results.slice(0, topK);
+}
+function createEmbeddingManager() {
+  const hashes = new ReactiveMap;
+  return {
+    setEmbedding(id, column, content) {
+      const hash = BigInt(Bun.hash(content));
+      let columnHashes = hashes.get(id);
+      if (!columnHashes) {
+        columnHashes = new Map;
+        hashes.set(id, columnHashes);
+      }
+      columnHashes.set(column, hash);
+    },
+    isStale(id, column, currentContent) {
+      const columnHashes = hashes.get(id);
+      if (!columnHashes)
+        return false;
+      const storedHash = columnHashes.get(column);
+      if (storedHash === undefined)
+        return false;
+      const currentHash = BigInt(Bun.hash(currentContent));
+      return storedHash !== currentHash;
+    },
+    getHash(id, column) {
+      return hashes.get(id)?.get(column);
+    },
+    clearHash(id, column) {
+      const columnHashes = hashes.get(id);
+      if (columnHashes) {
+        columnHashes.delete(column);
+        if (columnHashes.size === 0) {
+          hashes.delete(id);
+        }
+      }
+    },
+    reset() {
+      hashes.clear();
+    }
+  };
+}
+function vectorSearch(collection, vectorColumn, queryVector, options = {}) {
+  const { topK = 10, minSimilarity = 0, filter } = options;
+  const query = toFloat32Array(queryVector);
+  const vectors = [];
+  const vectorIndices = [];
+  for (const index of collection.getIndices()) {
+    if (filter) {
+      const data = collection.columns.getRecord(index);
+      if (!filter(data, index))
+        continue;
+    }
+    const vec = collection.columns.get(vectorColumn, index);
+    if (vec) {
+      vectors.push(vec);
+      vectorIndices.push(index);
+    }
+  }
+  const topResults = batchCosineSimilarity(query, vectors, vectorIndices, topK);
+  const results = [];
+  for (const { index, similarity } of topResults) {
+    if (similarity < minSimilarity)
+      continue;
+    const record = collection.getByIndex(index);
+    if (!record)
+      continue;
+    results.push({
+      record,
+      similarity,
+      stale: collection.isStale(record.id)
+    });
+  }
+  return results;
+}
+
+// src/core/database.ts
+function createPersistentCollection(name, options) {
+  const baseCollection = createCollection(name, options);
+  const { path, schema, contentColumn, autoSave = false, watchFiles = false, onExternalChange } = options;
+  const embeddingManager = createEmbeddingManager();
+  let fileWatcher = null;
+  const savingIds = new Set;
+  function getFilepath(id) {
+    return `${path}/${idToFilename(id)}`;
+  }
+  async function saveRecord(id) {
+    const record = baseCollection.get(id);
+    if (!record)
+      return false;
+    savingIds.add(id);
+    if (fileWatcher)
+      fileWatcher.markSaving(id);
+    const success = await saveToMarkdown(getFilepath(id), record, schema, contentColumn);
+    setTimeout(() => {
+      savingIds.delete(id);
+      if (fileWatcher)
+        fileWatcher.clearSaving(id);
+    }, 200);
+    return success;
+  }
+  async function deleteFile(id) {
+    return await deleteMarkdownFile(getFilepath(id));
+  }
+  function isContentStale(id, content) {
+    for (const col of baseCollection.columns.schema.vectorColumns) {
+      if (embeddingManager.isStale(id, String(col), content)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const persistentCollection = {
+    name: baseCollection.name,
+    schema: baseCollection.schema,
+    contentColumn: baseCollection.contentColumn,
+    registry: baseCollection.registry,
+    columns: baseCollection.columns,
+    reactiveCount: baseCollection.reactiveCount,
+    insert(data) {
+      const id = baseCollection.insert(data);
+      if (autoSave)
+        saveRecord(id);
+      return id;
+    },
+    insertMany(records) {
+      const ids = baseCollection.insertMany(records);
+      if (autoSave) {
+        for (const id of ids)
+          saveRecord(id);
+      }
+      return ids;
+    },
+    get: baseCollection.get.bind(baseCollection),
+    all: baseCollection.all.bind(baseCollection),
+    find: baseCollection.find.bind(baseCollection),
+    findOne: baseCollection.findOne.bind(baseCollection),
+    update(id, data) {
+      const success = baseCollection.update(id, data);
+      if (success && autoSave)
+        saveRecord(id);
+      return success;
+    },
+    updateField(id, field, value) {
+      const success = baseCollection.updateField(id, field, value);
+      if (success && autoSave)
+        saveRecord(id);
+      return success;
+    },
+    updateMany(filter, data) {
+      const count = baseCollection.updateMany(filter, data);
+      if (count > 0 && autoSave) {
+        const updated = baseCollection.find(filter);
+        for (const record of updated)
+          saveRecord(record.id);
+      }
+      return count;
+    },
+    delete(id) {
+      const success = baseCollection.delete(id);
+      if (success && autoSave)
+        deleteFile(id);
+      embeddingManager.clearHash(id, "*");
+      return success;
+    },
+    deleteMany(filter) {
+      const toDelete = baseCollection.find(filter).map((r) => r.id);
+      const count = baseCollection.deleteMany(filter);
+      if (autoSave) {
+        for (const id of toDelete)
+          deleteFile(id);
+      }
+      for (const id of toDelete) {
+        embeddingManager.clearHash(id, "*");
+      }
+      return count;
+    },
+    count: baseCollection.count.bind(baseCollection),
+    getByIndex: baseCollection.getByIndex.bind(baseCollection),
+    getIndices: baseCollection.getIndices.bind(baseCollection),
+    has: baseCollection.has.bind(baseCollection),
+    isStale: baseCollection.isStale.bind(baseCollection),
+    getStaleIds: baseCollection.getStaleIds.bind(baseCollection),
+    setStale: baseCollection.setStale.bind(baseCollection),
+    clear() {
+      baseCollection.clear();
+      embeddingManager.reset();
+    },
+    async load() {
+      await ensureDirectory(path);
+      const loaded = await loadFromDirectory(path, schema, contentColumn);
+      for (const { id, record } of loaded) {
+        const index = baseCollection.registry.allocate(id);
+        baseCollection.columns.setRecord(index, record);
+        if ("created" in record) {}
+        if (contentColumn) {
+          const content = record[contentColumn];
+          if (content && isContentStale(id, content)) {
+            baseCollection.setStale(id, true);
+          }
+        }
+      }
+      return loaded.length;
+    },
+    async save() {
+      await ensureDirectory(path);
+      const records = baseCollection.all();
+      for (const record of records) {
+        await saveRecord(record.id);
+      }
+      return records.length;
+    },
+    startWatching() {
+      if (fileWatcher)
+        return;
+      fileWatcher = createFileWatcher({
+        dirpath: path,
+        schema,
+        contentColumn,
+        isStaleCallback: contentColumn ? (id, content) => isContentStale(id, content) : undefined
+      });
+      fileWatcher.onChange(async (event) => {
+        if (savingIds.has(event.id))
+          return;
+        if (event.type === "delete") {
+          baseCollection.delete(event.id);
+        } else if (event.record) {
+          const exists = baseCollection.has(event.id);
+          if (exists) {
+            baseCollection.update(event.id, event.record);
+          } else {
+            baseCollection.insert({ ...event.record, id: event.id });
+          }
+          if (event.stale) {
+            baseCollection.setStale(event.id, true);
+          }
+        }
+        if (onExternalChange) {
+          await onExternalChange(event);
+        }
+      });
+      fileWatcher.start();
+    },
+    stopWatching() {
+      if (fileWatcher) {
+        fileWatcher.stop();
+        fileWatcher = null;
+      }
+    },
+    get isWatching() {
+      return fileWatcher?.isWatching ?? false;
+    },
+    onFileChange(callback) {
+      if (!fileWatcher) {
+        persistentCollection.startWatching();
+      }
+      return fileWatcher.onChange(callback);
+    },
+    setEmbedding(id, column, embedding, sourceContent) {
+      const vec = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
+      baseCollection.updateField(id, column, vec);
+      embeddingManager.setEmbedding(id, String(column), sourceContent);
+      baseCollection.setStale(id, false);
+      if (autoSave)
+        saveRecord(id);
+    },
+    search(column, queryVector, options2) {
+      return vectorSearch(baseCollection, column, queryVector, options2);
+    },
+    close() {
+      persistentCollection.stopWatching();
+      baseCollection.clear();
+      embeddingManager.reset();
+    }
+  };
+  if (watchFiles) {
+    persistentCollection.startWatching();
+  }
+  return persistentCollection;
+}
+function createDatabase(options = {}) {
+  const name = options.name ?? "default";
+  let basePath;
+  if (options.basePath) {
+    basePath = options.basePath;
+  } else if (options.local) {
+    basePath = `${process.cwd()}/.fsdb/${name}`;
+  } else {
+    basePath = `${Bun.env.HOME}/.fsdb/${name}`;
+  }
+  const collections = new ReactiveMap;
+  return {
+    name,
+    basePath,
+    collection(collectionName, collectionOptions) {
+      const existing = collections.get(collectionName);
+      if (existing) {
+        return existing;
+      }
+      const path = `${basePath}/${collectionName}`;
+      const collection = createPersistentCollection(collectionName, {
+        ...collectionOptions,
+        path
+      });
+      collections.set(collectionName, collection);
+      return collection;
+    },
+    getCollection(collectionName) {
+      return collections.get(collectionName);
+    },
+    listCollections() {
+      return Array.from(collections.keys());
+    },
+    close() {
+      for (const collection of collections.values()) {
+        collection.close();
+      }
+      collections.clear();
+    }
+  };
+}
+// src/query/reactive.ts
+function query(collection, filter) {
+  return derived(() => {
+    const indices = [];
+    const records = [];
+    for (const index of collection.getIndices()) {
+      const data = collection.columns.getRecord(index);
+      if (filter(data, index)) {
+        indices.push(index);
+        const record = collection.getByIndex(index);
+        if (record)
+          records.push(record);
+      }
+    }
+    return { indices, records, count: records.length };
+  });
+}
+function querySorted(collection, filter, sortBy, descending = false) {
+  return derived(() => {
+    const result = query(collection, filter).value;
+    const sortOptions = Array.isArray(sortBy) ? sortBy : [{ column: sortBy, direction: descending ? "desc" : "asc" }];
+    const sorted = [...result.records].sort((a, b) => {
+      for (const opt of sortOptions) {
+        const aVal = a[opt.column];
+        const bVal = b[opt.column];
+        if (aVal === bVal)
+          continue;
+        if (aVal == null)
+          return 1;
+        if (bVal == null)
+          return -1;
+        const cmp = aVal < bVal ? -1 : 1;
+        return opt.direction === "desc" ? -cmp : cmp;
+      }
+      return 0;
+    });
+    const sortedIndices = sorted.map((r) => collection.registry.getIndex(r.id));
+    return { indices: sortedIndices, records: sorted, count: sorted.length };
+  });
+}
+function queryFirst(collection, filter) {
+  return derived(() => {
+    for (const index of collection.getIndices()) {
+      const data = collection.columns.getRecord(index);
+      if (filter(data, index)) {
+        return collection.getByIndex(index);
+      }
+    }
+    return;
+  });
+}
+function queryCount(collection, filter) {
+  return derived(() => {
+    let count = 0;
+    for (const index of collection.getIndices()) {
+      const data = collection.columns.getRecord(index);
+      if (filter(data, index))
+        count++;
+    }
+    return count;
+  });
+}
+function queryAggregate(collection, aggregator, filter) {
+  return derived(() => {
+    const records = [];
+    for (const index of collection.getIndices()) {
+      const data = collection.columns.getRecord(index);
+      if (!filter || filter(data, index)) {
+        records.push(data);
+      }
+    }
+    return aggregator(records);
+  });
+}
+function queryGroupBy(collection, field, filter) {
+  return derived(() => {
+    const groups = new Map;
+    for (const index of collection.getIndices()) {
+      const data = collection.columns.getRecord(index);
+      if (filter && !filter(data, index))
+        continue;
+      const key = data[field];
+      const record = collection.getByIndex(index);
+      if (!record)
+        continue;
+      const group = groups.get(key);
+      if (group) {
+        group.push(record);
+      } else {
+        groups.set(key, [record]);
+      }
+    }
+    return groups;
+  });
+}
+// src/query/filters.ts
+function eq(column, value) {
+  return (record) => record[column] === value;
+}
+function neq(column, value) {
+  return (record) => record[column] !== value;
+}
+function gt(column, value) {
+  return (record) => record[column] > value;
+}
+function gte(column, value) {
+  return (record) => record[column] >= value;
+}
+function lt(column, value) {
+  return (record) => record[column] < value;
+}
+function lte(column, value) {
+  return (record) => record[column] <= value;
+}
+function between(column, min, max) {
+  return (record) => {
+    const val = record[column];
+    return val >= min && val <= max;
+  };
+}
+function oneOf(column, values) {
+  const set2 = new Set(values);
+  return (record) => set2.has(record[column]);
+}
+function fullText(query2, options) {
+  const searchTerm = options?.caseSensitive ? query2 : query2.toLowerCase();
+  return (record) => {
+    const columns = options?.columns ?? Object.keys(record);
+    for (const col of columns) {
+      const value = record[col];
+      if (typeof value === "string") {
+        const text = options?.caseSensitive ? value : value.toLowerCase();
+        if (text.includes(searchTerm))
+          return true;
+      }
+    }
+    return false;
+  };
+}
+function matches(column, pattern) {
+  const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+  return (record) => {
+    const value = record[column];
+    if (typeof value !== "string")
+      return false;
+    return regex.test(value);
+  };
+}
+function startsWith(column, prefix, caseSensitive = false) {
+  const search = caseSensitive ? prefix : prefix.toLowerCase();
+  return (record) => {
+    const value = record[column];
+    if (typeof value !== "string")
+      return false;
+    const text = caseSensitive ? value : value.toLowerCase();
+    return text.startsWith(search);
+  };
+}
+function endsWith(column, suffix, caseSensitive = false) {
+  const search = caseSensitive ? suffix : suffix.toLowerCase();
+  return (record) => {
+    const value = record[column];
+    if (typeof value !== "string")
+      return false;
+    const text = caseSensitive ? value : value.toLowerCase();
+    return text.endsWith(search);
+  };
+}
+function contains(column, value) {
+  return (record) => {
+    const arr = record[column];
+    if (!Array.isArray(arr))
+      return false;
+    return arr.includes(value);
+  };
+}
+function containsAny(column, values) {
+  const set2 = new Set(values);
+  return (record) => {
+    const arr = record[column];
+    if (!Array.isArray(arr))
+      return false;
+    return arr.some((v) => set2.has(v));
+  };
+}
+function containsAll(column, values) {
+  return (record) => {
+    const arr = record[column];
+    if (!Array.isArray(arr))
+      return false;
+    return values.every((v) => arr.includes(v));
+  };
+}
+function isEmpty(column) {
+  return (record) => {
+    const arr = record[column];
+    if (!Array.isArray(arr))
+      return true;
+    return arr.length === 0;
+  };
+}
+function isNotEmpty(column) {
+  return (record) => {
+    const arr = record[column];
+    if (!Array.isArray(arr))
+      return false;
+    return arr.length > 0;
+  };
+}
+function exists(column) {
+  return (record) => record[column] != null;
+}
+function isNull(column) {
+  return (record) => record[column] == null;
+}
+function after(column, date) {
+  const ts = typeof date === "number" ? date : date.getTime();
+  return (record) => record[column] > ts;
+}
+function before(column, date) {
+  const ts = typeof date === "number" ? date : date.getTime();
+  return (record) => record[column] < ts;
+}
+function withinLast(column, milliseconds) {
+  return (record) => {
+    const now = Date.now();
+    const ts = record[column];
+    return now - ts <= milliseconds;
+  };
+}
+function and(...filters) {
+  return (record, index) => filters.every((f) => f(record, index));
+}
+function or(...filters) {
+  return (record, index) => filters.some((f) => f(record, index));
+}
+function not(filter) {
+  return (record, index) => !filter(record, index);
+}
+function sortBy(records, ...sorts) {
+  const sortOptions = sorts.map((s) => typeof s === "object" ? s : { column: s, direction: "asc" });
+  return [...records].sort((a, b) => {
+    for (const opt of sortOptions) {
+      const aVal = a[opt.column];
+      const bVal = b[opt.column];
+      if (aVal === bVal)
+        continue;
+      if (aVal == null)
+        return 1;
+      if (bVal == null)
+        return -1;
+      const cmp = aVal < bVal ? -1 : 1;
+      return opt.direction === "desc" ? -cmp : cmp;
+    }
+    return 0;
+  });
+}
+function paginate(records, page = 1, pageSize = DEFAULT_PAGE_SIZE) {
+  const total = records.length;
+  const totalPages = Math.ceil(total / pageSize);
+  const start = (page - 1) * pageSize;
+  const end = start + pageSize;
+  return {
+    records: records.slice(start, end),
+    total,
+    page,
+    pageSize,
+    totalPages,
+    hasNext: page < totalPages,
+    hasPrev: page > 1
+  };
+}
+export {
+  withinLast,
+  vectorSearch,
+  toFloat32Array,
+  startsWith,
+  sortBy,
+  saveToMarkdown,
+  querySorted,
+  queryGroupBy,
+  queryFirst,
+  queryCount,
+  queryAggregate,
+  query,
+  parseSchema,
+  parseMarkdown,
+  parseColumnType,
+  paginate,
+  or,
+  oneOf,
+  not,
+  normalizeVector,
+  neq,
+  matches,
+  lte,
+  lt,
+  loadFromMarkdown,
+  loadFromDirectory,
+  isNull,
+  isNotEmpty,
+  isEmpty,
+  idToFilename,
+  gte,
+  gt,
+  getDefaultValue,
+  generateMarkdown,
+  generateId,
+  fullText,
+  createDatabase as fsDB,
+  filenameToId,
+  exists,
+  eq,
+  ensureDirectory,
+  endsWith,
+  deleteMarkdownFile,
+  createRegistry,
+  createPersistentCollection,
+  createFileWatcher,
+  createEmbeddingManager,
+  createDatabase,
+  createColumns,
+  createCollection,
+  cosineSimilarity,
+  containsAny,
+  containsAll,
+  contains,
+  between,
+  before,
+  batchCosineSimilarity,
+  and,
+  after,
+  WATCHER_DEBOUNCE_MS,
+  SAVE_GRACE_PERIOD_MS,
+  DEFAULT_VALUES,
+  DEFAULT_PAGE_SIZE
+};