@rlabs-inc/memory 0.3.2 → 0.3.5

package/dist/index.mjs

@@ -212,10 +212,10 @@ var require_lib = __commonJS((exports, module) => {
 
 // node_modules/whatwg-url/lib/utils.js
 var require_utils = __commonJS((exports, module) => {
-  exports.mixin = function mixin(target, source) {
-    const keys = Object.getOwnPropertyNames(source);
+  exports.mixin = function mixin(target, source2) {
+    const keys = Object.getOwnPropertyNames(source2);
     for (let i = 0;i < keys.length; ++i) {
-      Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i]));
+      Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source2, keys[i]));
     }
   };
   exports.wrapperSymbol = Symbol("wrapper");
@@ -2535,8 +2535,8 @@ var require_lib2 = __commonJS((exports, module) => {
   function isRequest(input) {
     return typeof input === "object" && typeof input[INTERNALS$2] === "object";
   }
-  function isAbortSignal(signal) {
-    const proto = signal && typeof signal === "object" && Object.getPrototypeOf(signal);
+  function isAbortSignal(signal2) {
+    const proto = signal2 && typeof signal2 === "object" && Object.getPrototypeOf(signal2);
     return !!(proto && proto.constructor.name === "AbortSignal");
   }
 
@@ -2571,10 +2571,10 @@ var require_lib2 = __commonJS((exports, module) => {
           headers.append("Content-Type", contentType);
         }
       }
-      let signal = isRequest(input) ? input.signal : null;
+      let signal2 = isRequest(input) ? input.signal : null;
       if ("signal" in init)
-        signal = init.signal;
-      if (signal != null && !isAbortSignal(signal)) {
+        signal2 = init.signal;
+      if (signal2 != null && !isAbortSignal(signal2)) {
         throw new TypeError("Expected signal to be an instanceof AbortSignal");
       }
       this[INTERNALS$2] = {
@@ -2582,7 +2582,7 @@ var require_lib2 = __commonJS((exports, module) => {
         redirect: init.redirect || input.redirect || "follow",
         headers,
         parsedURL,
-        signal
+        signal: signal2
       };
       this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
       this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
@@ -2697,7 +2697,7 @@ var require_lib2 = __commonJS((exports, module) => {
       const request = new Request2(url, opts);
       const options = getNodeRequestOptions(request);
       const send = (options.protocol === "https:" ? https : http).request;
-      const signal = request.signal;
+      const signal2 = request.signal;
       let response = null;
       const abort = function abort() {
         let error = new AbortError("The user aborted a request.");
@@ -2709,7 +2709,7 @@ var require_lib2 = __commonJS((exports, module) => {
           return;
         response.body.emit("error", error);
       };
-      if (signal && signal.aborted) {
+      if (signal2 && signal2.aborted) {
         abort();
         return;
       }
@@ -2719,13 +2719,13 @@ var require_lib2 = __commonJS((exports, module) => {
       };
       const req = send(options);
       let reqTimeout;
-      if (signal) {
-        signal.addEventListener("abort", abortAndFinalize);
+      if (signal2) {
+        signal2.addEventListener("abort", abortAndFinalize);
       }
       function finalize() {
         req.abort();
-        if (signal)
-          signal.removeEventListener("abort", abortAndFinalize);
+        if (signal2)
+          signal2.removeEventListener("abort", abortAndFinalize);
         clearTimeout(reqTimeout);
       }
       if (request.timeout) {
@@ -2744,7 +2744,7 @@ var require_lib2 = __commonJS((exports, module) => {
         finalize();
       });
       fixResponseChunkedTransferBadEnding(req, function(err) {
-        if (signal && signal.aborted) {
+        if (signal2 && signal2.aborted) {
           return;
         }
         if (response && response.body) {
@@ -2755,7 +2755,7 @@ var require_lib2 = __commonJS((exports, module) => {
         req.on("socket", function(s) {
           s.addListener("close", function(hadError) {
             const hasDataListener = s.listenerCount("data") > 0;
-            if (response && hasDataListener && !hadError && !(signal && signal.aborted)) {
+            if (response && hasDataListener && !hadError && !(signal2 && signal2.aborted)) {
               const err = new Error("Premature close");
               err.code = "ERR_STREAM_PREMATURE_CLOSE";
               response.body.emit("error", err);
@@ -2834,8 +2834,8 @@ var require_lib2 = __commonJS((exports, module) => {
           }
         }
         res.once("end", function() {
-          if (signal)
-            signal.removeEventListener("abort", abortAndFinalize);
+          if (signal2)
+            signal2.removeEventListener("abort", abortAndFinalize);
         });
         let body = res.pipe(new PassThrough$1);
         const response_options = {
@@ -5005,20 +5005,20 @@ var init_blobHelpers = __esm(() => {
 });
 
 // node_modules/formdata-node/lib/esm/Blob.js
-var __classPrivateFieldGet = function(receiver, state2, kind2, f2) {
+var __classPrivateFieldGet = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
-}, __classPrivateFieldSet = function(receiver, state2, value, kind2, f2) {
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
+}, __classPrivateFieldSet = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state2.set(receiver, value), value;
+  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
 }, _Blob_parts, _Blob_type, _Blob_size, Blob2;
 var init_Blob = __esm(() => {
   init_ponyfill();
@@ -5119,20 +5119,20 @@ var init_Blob = __esm(() => {
 });
 
 // node_modules/formdata-node/lib/esm/File.js
-var __classPrivateFieldSet2 = function(receiver, state2, value, kind2, f2) {
+var __classPrivateFieldSet2 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state2.set(receiver, value), value;
-}, __classPrivateFieldGet2 = function(receiver, state2, kind2, f2) {
+  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+}, __classPrivateFieldGet2 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
 }, _File_name, _File_lastModified, File2;
 var init_File = __esm(() => {
   init_Blob();
@@ -5189,12 +5189,12 @@ var init_deprecateConstructorEntries = __esm(() => {
 
 // node_modules/formdata-node/lib/esm/FormData.js
 import { inspect } from "util";
-var __classPrivateFieldGet3 = function(receiver, state2, kind2, f2) {
+var __classPrivateFieldGet3 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
 }, _FormData_instances, _FormData_entries, _FormData_setEntry, FormData2;
 var init_FormData = __esm(() => {
   init_File();
@@ -6258,17 +6258,17 @@ var require_abort_controller = __commonJS((exports, module) => {
   }
   eventTargetShim.defineEventAttribute(AbortSignal.prototype, "abort");
   function createAbortSignal() {
-    const signal = Object.create(AbortSignal.prototype);
-    eventTargetShim.EventTarget.call(signal);
-    abortedFlags.set(signal, false);
-    return signal;
+    const signal2 = Object.create(AbortSignal.prototype);
+    eventTargetShim.EventTarget.call(signal2);
+    abortedFlags.set(signal2, false);
+    return signal2;
   }
-  function abortSignal(signal) {
-    if (abortedFlags.get(signal) !== false) {
+  function abortSignal(signal2) {
+    if (abortedFlags.get(signal2) !== false) {
       return;
     }
-    abortedFlags.set(signal, true);
-    signal.dispatchEvent({ type: "abort" });
+    abortedFlags.set(signal2, true);
+    signal2.dispatchEvent({ type: "abort" });
   }
   var abortedFlags = new WeakMap;
   Object.defineProperties(AbortSignal.prototype, {
@@ -6294,11 +6294,11 @@ var require_abort_controller = __commonJS((exports, module) => {
   }
   var signals = new WeakMap;
   function getSignal(controller) {
-    const signal = signals.get(controller);
-    if (signal == null) {
+    const signal2 = signals.get(controller);
+    if (signal2 == null) {
       throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
     }
-    return signal;
+    return signal2;
   }
   Object.defineProperties(AbortController2.prototype, {
     signal: { enumerable: true },
@@ -6388,20 +6388,20 @@ var init_isFormData = __esm(() => {
 });
 
 // node_modules/form-data-encoder/lib/esm/FormDataEncoder.js
-var __classPrivateFieldSet3 = function(receiver, state2, value, kind2, f2) {
+var __classPrivateFieldSet3 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state2.set(receiver, value), value;
-}, __classPrivateFieldGet4 = function(receiver, state2, kind2, f2) {
+  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+}, __classPrivateFieldGet4 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
 }, _FormDataEncoder_instances, _FormDataEncoder_CRLF, _FormDataEncoder_CRLF_BYTES, _FormDataEncoder_CRLF_BYTES_LENGTH, _FormDataEncoder_DASHES, _FormDataEncoder_encoder, _FormDataEncoder_footer, _FormDataEncoder_form, _FormDataEncoder_options, _FormDataEncoder_getFieldHeader, defaultOptions, FormDataEncoder;
 var init_FormDataEncoder = __esm(() => {
   init_createBoundary();
@@ -6603,20 +6603,20 @@ async function fileFromPath2(path, filenameOrOptions, options) {
   const stats = await fs.stat(path);
   return createFileFromPath(path, stats, filenameOrOptions, options);
 }
-var import_node_domexception, __classPrivateFieldSet4 = function(receiver, state2, value, kind2, f2) {
+var import_node_domexception, __classPrivateFieldSet4 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state2.set(receiver, value), value;
-}, __classPrivateFieldGet5 = function(receiver, state2, kind2, f2) {
+  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+}, __classPrivateFieldGet5 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
 }, _FileFromPath_path, _FileFromPath_start, MESSAGE, FileFromPath;
 var init_fileFromPath = __esm(() => {
   import_node_domexception = __toESM(require_node_domexception(), 1);
@@ -6918,20 +6918,20 @@ function findDoubleNewlineIndex(buffer) {
   }
   return -1;
 }
-var __classPrivateFieldSet5 = function(receiver, state2, value, kind2, f2) {
+var __classPrivateFieldSet5 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state2.set(receiver, value), value;
-}, __classPrivateFieldGet6 = function(receiver, state2, kind2, f2) {
+  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+}, __classPrivateFieldGet6 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
 }, _LineDecoder_carriageReturnIndex;
 var init_line = __esm(() => {
   init_error();
@@ -7512,9 +7512,9 @@ class APIClient {
     }).join("&");
   }
   async fetchWithTimeout(url, init, ms, controller) {
-    const { signal, ...options } = init || {};
-    if (signal)
-      signal.addEventListener("abort", () => controller.abort());
+    const { signal: signal2, ...options } = init || {};
+    if (signal2)
+      signal2.addEventListener("abort", () => controller.abort());
     const timeout = setTimeout(() => controller.abort(), ms);
     const fetchOptions = {
       signal: controller.signal,
@@ -7644,20 +7644,20 @@ function debug(action, ...args) {
     console.log(`Anthropic:DEBUG:${action}`, ...args);
   }
 }
-var __classPrivateFieldSet6 = function(receiver, state2, value, kind2, f2) {
+var __classPrivateFieldSet6 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state2.set(receiver, value), value;
-}, __classPrivateFieldGet7 = function(receiver, state2, kind2, f2) {
+  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+}, __classPrivateFieldGet7 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
 }, _AbstractPage_client, APIPromise, AbstractPage, PagePromise, createResponseHeaders = (headers) => {
   return new Proxy(Object.fromEntries(headers.entries()), {
     get(target, name) {
@@ -8372,20 +8372,20 @@ var init_parser = () => {};
 
 // node_modules/@anthropic-ai/sdk/lib/BetaMessageStream.mjs
 function checkNever(x2) {}
-var __classPrivateFieldSet7 = function(receiver, state2, value, kind2, f2) {
+var __classPrivateFieldSet7 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state2.set(receiver, value), value;
-}, __classPrivateFieldGet8 = function(receiver, state2, kind2, f2) {
+  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+}, __classPrivateFieldGet8 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
 }, _BetaMessageStream_instances, _BetaMessageStream_currentMessageSnapshot, _BetaMessageStream_connectedPromise, _BetaMessageStream_resolveConnectedPromise, _BetaMessageStream_rejectConnectedPromise, _BetaMessageStream_endPromise, _BetaMessageStream_resolveEndPromise, _BetaMessageStream_rejectEndPromise, _BetaMessageStream_listeners, _BetaMessageStream_ended, _BetaMessageStream_errored, _BetaMessageStream_aborted, _BetaMessageStream_catchingPromiseCreated, _BetaMessageStream_response, _BetaMessageStream_request_id, _BetaMessageStream_getFinalMessage, _BetaMessageStream_getFinalText, _BetaMessageStream_handleError, _BetaMessageStream_beginRequest, _BetaMessageStream_addStreamEvent, _BetaMessageStream_endRequest, _BetaMessageStream_accumulateMessage, JSON_BUF_PROPERTY = "__json_buf", BetaMessageStream;
 var init_BetaMessageStream = __esm(() => {
   init_error();
@@ -8487,11 +8487,11 @@ var init_BetaMessageStream = __esm(() => {
       }
     }
     async _createMessage(messages, params, options) {
-      const signal = options?.signal;
-      if (signal) {
-        if (signal.aborted)
+      const signal2 = options?.signal;
+      if (signal2) {
+        if (signal2.aborted)
           this.controller.abort();
-        signal.addEventListener("abort", () => this.controller.abort());
+        signal2.addEventListener("abort", () => this.controller.abort());
       }
       __classPrivateFieldGet8(this, _BetaMessageStream_instances, "m", _BetaMessageStream_beginRequest).call(this);
       const { response, data: stream } = await messages.create({ ...params, stream: true }, { ...options, signal: this.controller.signal }).withResponse();
@@ -8605,11 +8605,11 @@ var init_BetaMessageStream = __esm(() => {
       }
     }
     async _fromReadableStream(readableStream, options) {
-      const signal = options?.signal;
-      if (signal) {
-        if (signal.aborted)
+      const signal2 = options?.signal;
+      if (signal2) {
+        if (signal2.aborted)
           this.controller.abort();
-        signal.addEventListener("abort", () => this.controller.abort());
+        signal2.addEventListener("abort", () => this.controller.abort());
       }
       __classPrivateFieldGet8(this, _BetaMessageStream_instances, "m", _BetaMessageStream_beginRequest).call(this);
       this._connected(null);
@@ -8980,20 +8980,20 @@ var init_batches2 = __esm(() => {
 
 // node_modules/@anthropic-ai/sdk/lib/MessageStream.mjs
 function checkNever2(x2) {}
-var __classPrivateFieldSet8 = function(receiver, state2, value, kind2, f2) {
+var __classPrivateFieldSet8 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state2.set(receiver, value), value;
-}, __classPrivateFieldGet9 = function(receiver, state2, kind2, f2) {
+  return kind2 === "a" ? f2.call(receiver, value) : f2 ? f2.value = value : state.set(receiver, value), value;
+}, __classPrivateFieldGet9 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver))
+  if (typeof state === "function" ? receiver !== state || !f2 : !state.has(receiver))
     throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state2.get(receiver);
+  return kind2 === "m" ? f2 : kind2 === "a" ? f2.call(receiver) : f2 ? f2.value : state.get(receiver);
 }, _MessageStream_instances, _MessageStream_currentMessageSnapshot, _MessageStream_connectedPromise, _MessageStream_resolveConnectedPromise, _MessageStream_rejectConnectedPromise, _MessageStream_endPromise, _MessageStream_resolveEndPromise, _MessageStream_rejectEndPromise, _MessageStream_listeners, _MessageStream_ended, _MessageStream_errored, _MessageStream_aborted, _MessageStream_catchingPromiseCreated, _MessageStream_response, _MessageStream_request_id, _MessageStream_getFinalMessage, _MessageStream_getFinalText, _MessageStream_handleError, _MessageStream_beginRequest, _MessageStream_addStreamEvent, _MessageStream_endRequest, _MessageStream_accumulateMessage, JSON_BUF_PROPERTY2 = "__json_buf", MessageStream;
 var init_MessageStream = __esm(() => {
   init_error();
@@ -9095,11 +9095,11 @@ var init_MessageStream = __esm(() => {
       }
     }
     async _createMessage(messages, params, options) {
-      const signal = options?.signal;
-      if (signal) {
-        if (signal.aborted)
+      const signal2 = options?.signal;
+      if (signal2) {
+        if (signal2.aborted)
           this.controller.abort();
-        signal.addEventListener("abort", () => this.controller.abort());
+        signal2.addEventListener("abort", () => this.controller.abort());
       }
       __classPrivateFieldGet9(this, _MessageStream_instances, "m", _MessageStream_beginRequest).call(this);
       const { response, data: stream } = await messages.create({ ...params, stream: true }, { ...options, signal: this.controller.signal }).withResponse();
@@ -9213,11 +9213,11 @@ var init_MessageStream = __esm(() => {
       }
     }
     async _fromReadableStream(readableStream, options) {
-      const signal = options?.signal;
-      if (signal) {
-        if (signal.aborted)
+      const signal2 = options?.signal;
+      if (signal2) {
+        if (signal2.aborted)
           this.controller.abort();
-        signal.addEventListener("abort", () => this.controller.abort());
+        signal2.addEventListener("abort", () => this.controller.abort());
       }
       __classPrivateFieldGet9(this, _MessageStream_instances, "m", _MessageStream_beginRequest).call(this);
       this._connected(null);
@@ -9676,220 +9676,754 @@ Assistant:`;
 
 // src/core/engine.ts
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 
-// node_modules/fatherstatedb/dist/index.mjs
+// node_modules/@rlabs-inc/fsdb/dist/index.mjs
 import { watch } from "fs";
-import { join } from "path";
+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 untracking = false;
-var proxyToSignal = new WeakMap;
-var rawToProxy = new WeakMap;
-var defaultEquals = (a, b) => Object.is(a, b);
-function derived(fn, options) {
-  const internal = {
-    v: undefined,
-    reactions: new Set,
-    equals: options?.equals ?? defaultEquals,
-    fn,
-    dirty: true
-  };
-  const deps = new Set;
-  const markDirty = () => {
-    if (!internal.dirty) {
-      internal.dirty = true;
-      trigger(internal);
+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;
     }
-  };
-  const recompute = () => {
-    for (const dep of deps) {
-      dep.reactions.delete(derivedReaction);
+  }
+  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);
     }
-    deps.clear();
-    const prevReaction = activeReaction;
-    activeReaction = derivedReaction;
-    try {
-      const newValue = fn();
-      internal.v = newValue;
-    } finally {
-      activeReaction = prevReaction;
+    processEffectTree(root);
+  }
+}
+function processEffectTree(effect) {
+  let child = effect.first;
+  while (child !== null) {
+    const next = child.next;
+    if (isDirty(child)) {
+      updateEffectImpl(child);
     }
-    internal.dirty = false;
-  };
-  const derivedReaction = {
-    execute: markDirty,
-    deps,
-    active: true
-  };
-  return {
-    get value() {
-      track(internal);
-      if (internal.dirty) {
-        recompute();
+    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);
       }
-      return internal.v;
     }
-  };
+  }
+  if ((signal.f & DERIVED) !== 0) {
+    const derived = signal;
+    if (isDirty(derived)) {
+      updateDerived(derived);
+    }
+  }
+  return signal.v;
 }
-derived.by = derived;
-function track(signal2) {
-  if (activeReaction && !untracking) {
-    activeReaction.deps.add(signal2);
-    signal2.reactions.add(activeReaction);
+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 trigger(signal2) {
-  const reactions = [...signal2.reactions];
-  for (const reaction of reactions) {
-    if (!reaction.active)
-      continue;
-    if ("dirty" in reaction) {
-      reaction.dirty = true;
+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;
+        }
+      }
     }
-    if (batchDepth > 0) {
-      pendingReactions.add(reaction);
+    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 {
-      reaction.execute();
+      setUntrackedWrites(prevUntrackedWrites);
     }
   }
 }
-var REACTIVE_MARKER = Symbol("reactive");
-function state(initial) {
-  return createDeepReactive(initial);
+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;
-  if (value[REACTIVE_MARKER])
+  if (value === null || typeof value !== "object") {
     return false;
+  }
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === Array.prototype || proto === null;
 }
-function createDeepReactive(target) {
-  const existing = rawToProxy.get(target);
-  if (existing)
-    return existing;
-  const internal = {
-    v: target,
-    reactions: new Set,
-    equals: defaultEquals
+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 propSignals = new Map;
-  const getPropSignal = (prop) => {
-    let sig = propSignals.get(prop);
-    if (!sig) {
-      sig = {
-        v: target[prop],
-        reactions: new Set,
-        equals: defaultEquals
-      };
-      propSignals.set(prop, sig);
+  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 sig;
+    return s;
   };
-  const proxy = new Proxy(target, {
-    get(target2, prop, receiver) {
-      if (prop === REACTIVE_MARKER)
-        return true;
-      const value = Reflect.get(target2, prop, receiver);
-      if (Array.isArray(target2) && typeof value === "function") {
-        track(internal);
-        return value.bind(proxy);
-      }
-      const sig = getPropSignal(prop);
-      track(sig);
-      if (shouldProxy(value)) {
-        const existingProxy = rawToProxy.get(value);
-        if (existingProxy)
-          return existingProxy;
-        return createDeepReactive(value);
+  const proxyObj = new Proxy(value, {
+    get(target, prop, receiver) {
+      if (prop === STATE_SYMBOL) {
+        return value;
       }
-      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(target2, prop, value, receiver) {
-      const oldValue = target2[prop];
-      const rawValue = value?.[REACTIVE_MARKER] ? proxyToRaw.get(value) ?? value : value;
-      if (Object.is(oldValue, rawValue))
-        return true;
-      const result = Reflect.set(target2, prop, rawValue, receiver);
-      if (result) {
-        const sig = getPropSignal(prop);
-        sig.v = rawValue;
-        trigger(sig);
-        if (Array.isArray(target2)) {
-          internal.v = target2;
-          trigger(internal);
+    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);
+          }
         }
       }
-      return result;
+      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(target2, prop) {
-      const hadKey = prop in target2;
-      const result = Reflect.deleteProperty(target2, prop);
-      if (result && hadKey) {
-        const sig = propSignals.get(prop);
-        if (sig) {
-          sig.v = undefined;
-          trigger(sig);
+    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);
         }
-        trigger(internal);
+        set(version, get(version) + 1);
       }
-      return result;
+      return Reflect.deleteProperty(target, prop);
     },
-    has(target2, prop) {
-      if (prop === REACTIVE_MARKER)
+    has(target, prop) {
+      if (prop === STATE_SYMBOL) {
         return true;
-      track(internal);
-      return Reflect.has(target2, prop);
+      }
+      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(target2) {
-      track(internal);
-      return Reflect.ownKeys(target2);
+    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);
     }
   });
-  rawToProxy.set(target, proxy);
-  proxyToRaw.set(proxy, target);
-  proxyToSignal.set(proxy, internal);
-  return proxy;
+  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;
+  }
 }
-var proxyToRaw = new WeakMap;
-var signalProxyCache = new WeakMap;
+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 = { v: 0, reactions: new Set, equals: defaultEquals };
-  #size = { v: 0, reactions: new Set, equals: defaultEquals };
+  #version = source(0);
+  #size;
   constructor(entries) {
-    super();
-    if (entries) {
-      for (const [key, value] of entries) {
-        super.set(key, value);
-      }
-      this.#size.v = super.size;
-    }
+    super(entries);
+    this.#size = source(super.size);
   }
   #getKeySignal(key) {
     let sig = this.#keySignals.get(key);
-    if (!sig) {
-      sig = { v: 0, reactions: new Set, equals: defaultEquals };
+    if (sig === undefined) {
+      sig = source(0);
       this.#keySignals.set(key, sig);
     }
     return sig;
   }
+  #increment(sig) {
+    set(sig, sig.v + 1);
+  }
   get size() {
-    track(this.#size);
+    get(this.#size);
     return super.size;
   }
   has(key) {
-    const sig = this.#getKeySignal(key);
-    track(sig);
+    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.#getKeySignal(key);
-    track(sig);
+    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) {
@@ -9898,65 +10432,60 @@ class ReactiveMap extends Map {
     super.set(key, value);
     const sig = this.#getKeySignal(key);
     if (isNew) {
-      this.#size.v = super.size;
-      trigger(this.#size);
-      this.#version.v++;
-      trigger(this.#version);
-      sig.v++;
-      trigger(sig);
+      set(this.#size, super.size);
+      this.#increment(this.#version);
+      this.#increment(sig);
     } else if (!Object.is(oldValue, value)) {
-      sig.v++;
-      trigger(sig);
+      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 had = super.has(key);
-    const result = super.delete(key);
-    if (had) {
+    const existed = super.has(key);
+    if (existed) {
+      super.delete(key);
       const sig = this.#keySignals.get(key);
-      if (sig) {
-        sig.v = -1;
-        trigger(sig);
+      if (sig !== undefined) {
+        set(sig, -1);
         this.#keySignals.delete(key);
       }
-      this.#size.v = super.size;
-      trigger(this.#size);
-      this.#version.v++;
-      trigger(this.#version);
+      set(this.#size, super.size);
+      this.#increment(this.#version);
     }
-    return result;
+    return existed;
   }
   clear() {
-    if (super.size === 0)
-      return;
-    for (const sig of this.#keySignals.values()) {
-      sig.v = -1;
-      trigger(sig);
+    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);
     }
-    super.clear();
-    this.#keySignals.clear();
-    this.#size.v = 0;
-    trigger(this.#size);
-    this.#version.v++;
-    trigger(this.#version);
-  }
-  forEach(callbackfn, thisArg) {
-    track(this.#version);
-    super.forEach(callbackfn, thisArg);
   }
   keys() {
-    track(this.#version);
+    get(this.#version);
     return super.keys();
   }
   values() {
-    track(this.#version);
+    get(this.#version);
     return super.values();
   }
   entries() {
-    track(this.#version);
+    get(this.#version);
     return super.entries();
   }
+  forEach(callbackfn, thisArg) {
+    get(this.#version);
+    super.forEach(callbackfn, thisArg);
+  }
   [Symbol.iterator]() {
     return this.entries();
   }
@@ -9964,375 +10493,857 @@ class ReactiveMap extends Map {
 
 class ReactiveSet extends Set {
   #itemSignals = new Map;
-  #version = { v: 0, reactions: new Set, equals: defaultEquals };
-  #size = { v: 0, reactions: new Set, equals: defaultEquals };
+  #version = source(0);
+  #size;
   constructor(values) {
-    super();
-    if (values) {
-      for (const value of values) {
-        super.add(value);
-      }
-      this.#size.v = super.size;
-    }
+    super(values);
+    this.#size = source(super.size);
   }
   #getItemSignal(item) {
     let sig = this.#itemSignals.get(item);
-    if (!sig) {
-      sig = { v: super.has(item), reactions: new Set, equals: defaultEquals };
+    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() {
-    track(this.#size);
+    get(this.#size);
     return super.size;
   }
-  has(value) {
-    const sig = this.#getItemSignal(value);
-    track(sig);
-    return super.has(value);
-  }
-  add(value) {
-    if (!super.has(value)) {
-      super.add(value);
-      const sig = this.#getItemSignal(value);
-      sig.v = true;
-      trigger(sig);
-      this.#size.v = super.size;
-      trigger(this.#size);
-      this.#version.v++;
-      trigger(this.#version);
+  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(value) {
-    const had = super.has(value);
-    const result = super.delete(value);
-    if (had) {
-      const sig = this.#itemSignals.get(value);
-      if (sig) {
-        sig.v = false;
-        trigger(sig);
-        this.#itemSignals.delete(value);
-      }
-      this.#size.v = super.size;
-      trigger(this.#size);
-      this.#version.v++;
-      trigger(this.#version);
+  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 result;
+    return existed;
   }
   clear() {
-    if (super.size === 0)
-      return;
-    for (const sig of this.#itemSignals.values()) {
-      sig.v = false;
-      trigger(sig);
+    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();
     }
-    super.clear();
-    this.#itemSignals.clear();
-    this.#size.v = 0;
-    trigger(this.#size);
-    this.#version.v++;
-    trigger(this.#version);
-  }
-  forEach(callbackfn, thisArg) {
-    track(this.#version);
-    super.forEach(callbackfn, thisArg);
   }
   keys() {
-    track(this.#version);
+    get(this.#version);
     return super.keys();
   }
   values() {
-    track(this.#version);
+    get(this.#version);
     return super.values();
   }
   entries() {
-    track(this.#version);
+    get(this.#version);
     return super.entries();
   }
+  forEach(callbackfn, thisArg) {
+    get(this.#version);
+    super.forEach(callbackfn, thisArg);
+  }
   [Symbol.iterator]() {
     return this.values();
   }
 }
-var registry = state({
-  idToIndex: new ReactiveMap,
-  indexToId: new ReactiveMap,
-  allocatedIndices: new Set,
-  freeIndices: [],
-  nextIndex: 0,
-  get count() {
-    return this.allocatedIndices.size;
+
+class ReactiveDate extends Date {
+  #time;
+  constructor(...args) {
+    super(...args);
+    this.#time = source(super.getTime());
   }
-});
-function allocateIndex(id) {
-  const existing = registry.idToIndex.get(id);
-  if (existing !== undefined)
-    return existing;
-  let index;
-  if (registry.freeIndices.length > 0) {
-    index = registry.freeIndices.pop();
-  } else {
-    index = registry.nextIndex++;
+  #update() {
+    const time = super.getTime();
+    set(this.#time, time);
+    return time;
   }
-  registry.idToIndex.set(id, index);
-  registry.indexToId.set(index, id);
-  registry.allocatedIndices.add(index);
-  return index;
-}
-function releaseIndex(id) {
-  const index = registry.idToIndex.get(id);
-  if (index === undefined)
-    return;
-  registry.idToIndex.delete(id);
-  registry.indexToId.delete(index);
-  registry.allocatedIndices.delete(index);
-  registry.freeIndices.push(index);
-  return index;
-}
-function getIndex(id) {
-  return registry.idToIndex.get(id);
-}
-function getId(index) {
-  return registry.indexToId.get(index);
-}
-function getAllIndices() {
-  return Array.from(registry.allocatedIndices);
-}
-function resetRegistry() {
-  registry.idToIndex.clear();
-  registry.indexToId.clear();
-  registry.allocatedIndices.clear();
-  registry.freeIndices.length = 0;
-  registry.nextIndex = 0;
-}
-function parseColumnType(type) {
-  if (type === "string" || type === "timestamp") {
-    return { baseType: "string" };
+  getTime() {
+    get(this.#time);
+    return super.getTime();
   }
-  if (type === "number") {
-    return { baseType: "number" };
+  getFullYear() {
+    get(this.#time);
+    return super.getFullYear();
   }
-  if (type === "boolean") {
-    return { baseType: "boolean" };
+  getMonth() {
+    get(this.#time);
+    return super.getMonth();
   }
-  if (type === "string[]") {
-    return { baseType: "array", arrayType: "string" };
+  getDate() {
+    get(this.#time);
+    return super.getDate();
   }
-  if (type === "number[]") {
-    return { baseType: "array", arrayType: "number" };
+  getDay() {
+    get(this.#time);
+    return super.getDay();
   }
-  if (type.startsWith("vector:")) {
-    const dims = parseInt(type.split(":")[1], 10);
-    return { baseType: "vector", vectorDimensions: dims };
+  getHours() {
+    get(this.#time);
+    return super.getHours();
   }
-  throw new Error(`Unknown column type: ${type}`);
-}
-function createSchema(definition) {
-  const columns = Object.keys(definition);
-  const vectorColumns = columns.filter((col) => {
-    const type = definition[col];
-    return typeof type === "string" && type.startsWith("vector:");
-  });
-  return {
-    definition,
-    columns,
-    vectorColumns
-  };
-}
-function getDefaultForType(type) {
-  const parsed = parseColumnType(type);
-  switch (parsed.baseType) {
-    case "string":
-      return "";
-    case "number":
-      return 0;
-    case "boolean":
-      return false;
-    case "array":
-      return [];
-    case "vector":
-      return null;
-    default:
-      return null;
+  getMinutes() {
+    get(this.#time);
+    return super.getMinutes();
   }
-}
-
-class Columns {
-  _arrays = new ReactiveMap;
-  _indexes = new ReactiveMap;
-  _schema;
-  constructor(schema) {
-    this._schema = schema;
-    for (const name of Object.keys(schema)) {
-      this._arrays.set(name, []);
-    }
+  getSeconds() {
+    get(this.#time);
+    return super.getSeconds();
   }
-  getColumn(name) {
-    return this._arrays.get(name);
+  getMilliseconds() {
+    get(this.#time);
+    return super.getMilliseconds();
   }
-  set(column, index, value) {
-    const arr = this._arrays.get(column);
-    arr[index] = value;
-    this._updateIndex(column, index, value);
+  getUTCFullYear() {
+    get(this.#time);
+    return super.getUTCFullYear();
   }
-  get(column, index) {
-    return this._arrays.get(column)[index];
+  getUTCMonth() {
+    get(this.#time);
+    return super.getUTCMonth();
   }
-  setRecord(index, record) {
-    for (const [column, value] of Object.entries(record)) {
-      if (value !== undefined) {
-        this.set(column, index, value);
-      }
+  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();
   }
-  getRecord(index) {
-    const result = {};
-    for (const column of this._arrays.keys()) {
-      result[column] = this.get(column, index);
+  setMonth(month, date) {
+    if (date !== undefined) {
+      super.setMonth(month, date);
+    } else {
+      super.setMonth(month);
     }
-    return result;
+    return this.#update();
   }
-  clearAt(index) {
-    for (const [name, type] of Object.entries(this._schema)) {
-      const arr = this._arrays.get(name);
-      const parsed = parseColumnType(type);
-      switch (parsed.baseType) {
-        case "string":
-          arr[index] = "";
-          break;
-        case "number":
-          arr[index] = 0;
-          break;
-        case "boolean":
-          arr[index] = false;
-          break;
-        case "array":
-          arr[index] = [];
-          break;
-        case "vector":
-          arr[index] = null;
-          break;
-      }
+  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();
   }
-  createIndex(column) {
-    if (this._indexes.has(column)) {
-      return this._indexes.get(column);
+  setMinutes(min, sec, ms) {
+    if (ms !== undefined) {
+      super.setMinutes(min, sec, ms);
+    } else if (sec !== undefined) {
+      super.setMinutes(min, sec);
+    } else {
+      super.setMinutes(min);
     }
-    const index = new ReactiveMap;
-    this._indexes.set(column, index);
-    const arr = this._arrays.get(column);
-    for (const i of getAllIndices()) {
-      const value = arr[i];
-      if (value !== undefined) {
-        if (!index.has(value)) {
-          index.set(value, []);
-        }
-        index.get(value).push(i);
+    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);
+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 index;
+  };
+  return registry;
+}
+function generateId() {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${timestamp}-${random}`;
+}
+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;
+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)
+    };
   }
-  getByValue(column, value) {
-    const index = this._indexes.get(column);
-    if (!index) {
-      return this._linearScan(column, value);
+  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 index.get(value) || [];
   }
-  _linearScan(column, value) {
-    const arr = this._arrays.get(column);
-    const result = [];
-    for (const i of getAllIndices()) {
-      if (arr[i] === value) {
-        result.push(i);
+  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 result;
+  };
+  return manager;
+}
+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
+    };
   }
-  _updateIndex(column, index, newValue) {
-    const indexMap = this._indexes.get(column);
-    if (!indexMap)
+  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;
-    for (const [value, indices] of indexMap) {
-      const pos = indices.indexOf(index);
-      if (pos !== -1) {
-        indices.splice(pos, 1);
-        if (indices.length === 0) {
-          indexMap.delete(value);
+    },
+    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++;
         }
-        break;
       }
-    }
-    if (newValue !== undefined && newValue !== null && newValue !== "") {
-      if (!indexMap.has(newValue)) {
-        indexMap.set(newValue, []);
+      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;
       }
-      indexMap.get(newValue).push(index);
+      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;
+    },
+    setMetadata(id, created, updated, stale = false) {
+      const index = registry.getIndex(id);
+      if (index === -1)
+        return;
+      setMetadataAt(index, created, updated, stale);
+    },
+    clear() {
+      registry.reset();
+      columns.reset();
+      metadata.created.value = [];
+      metadata.updated.value = [];
+      metadata.stale.value = [];
     }
+  };
+  return collection;
+}
+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() };
   }
-  getColumnNames() {
-    return Array.from(this._arrays.keys());
-  }
-  hasIndex(column) {
-    return this._indexes.has(column);
+  const endIndex = text.indexOf(`
+---`, 3);
+  if (endIndex === -1) {
+    return { frontmatter, content: text.trim() };
   }
-}
-function parseFrontmatter(text) {
-  const result = {};
-  const lines = text.split(`
+  const yamlText = text.slice(4, endIndex);
+  const lines = yamlText.split(`
 `);
   for (const line of lines) {
     const trimmed = line.trim();
-    if (!trimmed || trimmed === "---")
+    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();
-    result[key] = parseValue(value);
+    frontmatter[key] = parseYamlValue(value);
   }
-  return result;
+  content = text.slice(endIndex + 4).trim();
+  return { frontmatter, content };
 }
-function parseValue(value) {
-  if (!value)
-    return "";
+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("]")) {
-    const inner = value.slice(1, -1).trim();
-    if (!inner)
-      return [];
-    const items = inner.split(",").map((s) => s.trim());
-    const firstItem = items[0];
-    if (firstItem && !isNaN(Number(firstItem))) {
-      return items.map((s) => Number(s));
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
     }
-    return items.map((s) => s.replace(/^["']|["']$/g, ""));
   }
-  if (!isNaN(Number(value)) && value !== "") {
-    return Number(value);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
   }
-  return value.replace(/^["']|["']$/g, "");
+  return value;
 }
-function serializeValue(value, type) {
-  if (value === undefined || value === null)
-    return "";
-  if (value instanceof Float32Array) {
-    return `[${Array.from(value).join(", ")}]`;
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0)
-      return "[]";
-    if (typeof value[0] === "number") {
-      return `[${value.join(", ")}]`;
-    }
-    return `[${value.map((v) => `"${v}"`).join(", ")}]`;
+function toYamlValue(value) {
+  if (value === null || value === undefined) {
+    return "null";
   }
   if (typeof value === "boolean") {
     return value ? "true" : "false";
@@ -10340,746 +11351,618 @@ function serializeValue(value, type) {
   if (typeof value === "number") {
     return String(value);
   }
-  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 generateFrontmatter(record, schema) {
+function generateMarkdown(record, schema, contentColumn) {
   const lines = ["---"];
-  for (const [key, value] of Object.entries(record)) {
-    if (value === undefined || value === null)
+  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 type = schema?.[key];
-    lines.push(`${key}: ${serializeValue(value, type)}`);
+    const value = record[key];
+    lines.push(`${String(key)}: ${toYamlValue(value)}`);
   }
   lines.push("---");
-  return lines.join(`
-`);
-}
-function parseMarkdown(content) {
-  const lines = content.split(`
-`);
-  let inFrontmatter = false;
-  let frontmatterStart = -1;
-  let frontmatterEnd = -1;
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line === "---") {
-      if (!inFrontmatter) {
-        inFrontmatter = true;
-        frontmatterStart = i;
-      } else {
-        frontmatterEnd = i;
-        break;
-      }
+  lines.push("");
+  if (contentColumn) {
+    const content = record[contentColumn];
+    if (typeof content === "string") {
+      lines.push(content);
     }
   }
-  if (frontmatterStart === -1 || frontmatterEnd === -1) {
-    return {
-      id: "",
-      frontmatter: {},
-      content: content.trim()
-    };
-  }
-  const frontmatterText = lines.slice(frontmatterStart + 1, frontmatterEnd).join(`
+  return lines.join(`
 `);
-  const frontmatter = parseFrontmatter(frontmatterText);
-  const contentLines = lines.slice(frontmatterEnd + 1);
-  const contentText = contentLines.join(`
-`).trim();
-  return {
-    id: frontmatter.id || "",
-    frontmatter,
-    content: contentText
-  };
-}
-function generateMarkdown(record, content, schema) {
-  const frontmatter = generateFrontmatter(record, schema);
-  return `${frontmatter}
-
-${content}`;
-}
-async function loadFromMarkdown(filePath) {
-  const content = await Bun.file(filePath).text();
-  return parseMarkdown(content);
-}
-async function saveToMarkdown(filePath, record, content, schema) {
-  const markdown = generateMarkdown(record, content, schema);
-  await Bun.write(filePath, markdown);
-}
-async function loadFromDirectory(dirPath) {
-  const glob = new Bun.Glob("**/*.md");
-  const documents = [];
-  for await (const file of glob.scan({ cwd: dirPath, absolute: true })) {
-    try {
-      const doc = await loadFromMarkdown(file);
-      documents.push(doc);
-    } catch (error) {
-      console.error(`Failed to load ${file}:`, error);
-    }
-  }
-  return documents;
-}
-function idToFilename(id) {
-  return id.replace(/[^a-zA-Z0-9-_]/g, "_") + ".md";
-}
-function filenameToId(filename) {
-  return filename.replace(/\.md$/, "");
 }
-
-class FileWatcher {
-  _path;
-  _watcher = null;
-  _handler;
-  _options;
-  _debounceTimers = new Map;
-  _knownFiles = new Set;
-  _isStarting = false;
-  constructor(path, handler, options = {}) {
-    this._path = path;
-    this._handler = handler;
-    this._options = {
-      debounceMs: options.debounceMs ?? 100,
-      extension: options.extension ?? ".md"
-    };
-  }
-  async start() {
-    if (this._watcher || this._isStarting)
-      return;
-    this._isStarting = true;
-    await this._scanExistingFiles();
-    this._watcher = watch(this._path, { recursive: false }, (eventType, filename) => {
-      if (!filename)
-        return;
-      if (!filename.endsWith(this._options.extension))
-        return;
-      this._handleChange(eventType, filename);
-    });
-    this._isStarting = false;
-  }
-  stop() {
-    if (this._watcher) {
-      this._watcher.close();
-      this._watcher = null;
-    }
-    for (const timer of this._debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    this._debounceTimers.clear();
-  }
-  get isWatching() {
-    return this._watcher !== null;
-  }
-  async _scanExistingFiles() {
-    try {
-      const glob = new Bun.Glob(`*${this._options.extension}`);
-      for await (const file of glob.scan({ cwd: this._path, absolute: false })) {
-        this._knownFiles.add(file);
-      }
-    } catch (error) {
-      console.warn(`FileWatcher: Could not scan ${this._path}:`, error);
-    }
-  }
-  _handleChange(eventType, filename) {
-    const existingTimer = this._debounceTimers.get(filename);
-    if (existingTimer) {
-      clearTimeout(existingTimer);
-    }
-    const timer = setTimeout(async () => {
-      this._debounceTimers.delete(filename);
-      await this._processChange(filename);
-    }, this._options.debounceMs);
-    this._debounceTimers.set(filename, timer);
-  }
-  async _processChange(filename) {
-    const filepath = join(this._path, filename);
-    const id = filenameToId(filename);
+async function loadFromMarkdown(filepath, schema, contentColumn) {
+  try {
     const file = Bun.file(filepath);
-    const exists = await file.exists();
-    let changeType;
-    if (!exists) {
-      if (this._knownFiles.has(filename)) {
-        changeType = "delete";
-        this._knownFiles.delete(filename);
-      } else {
-        return;
-      }
-    } else if (this._knownFiles.has(filename)) {
-      changeType = "update";
-    } else {
-      changeType = "create";
-      this._knownFiles.add(filename);
+    if (!await file.exists()) {
+      return null;
     }
-    try {
-      await this._handler({
-        type: changeType,
-        id,
-        filename,
-        filepath
-      });
-    } catch (error) {
-      console.error(`FileWatcher: Error handling ${changeType} for ${filename}:`, error);
-    }
-  }
-  async rescan() {
-    const previousFiles = new Set(this._knownFiles);
-    this._knownFiles.clear();
-    await this._scanExistingFiles();
-    for (const filename of this._knownFiles) {
-      if (!previousFiles.has(filename)) {
-        const filepath = join(this._path, filename);
-        const id = filenameToId(filename);
-        await this._handler({
-          type: "create",
-          id,
-          filename,
-          filepath
-        });
-      }
+    const text = await file.text();
+    const { frontmatter, content } = parseMarkdown(text);
+    const id = frontmatter.id;
+    if (!id) {
+      const filename = filepath.split("/").pop() || "";
+      return null;
     }
-    for (const filename of previousFiles) {
-      if (!this._knownFiles.has(filename)) {
-        const filepath = join(this._path, filename);
-        const id = filenameToId(filename);
-        await this._handler({
-          type: "delete",
-          id,
-          filename,
-          filepath
-        });
+    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;
   }
 }
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+async function saveToMarkdown(filepath, record, schema, contentColumn) {
+  try {
+    const markdown = generateMarkdown(record, schema, contentColumn);
+    await Bun.write(filepath, markdown);
+    return true;
+  } catch {
+    return false;
   }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0;i < a.length; i++) {
-    const ai = a[i];
-    const bi = b[i];
-    dotProduct += ai * bi;
-    normA += ai * ai;
-    normB += bi * bi;
-  }
-  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-  if (magnitude === 0)
-    return 0;
-  return dotProduct / magnitude;
 }
-function batchCosineSimilarity(query, vectors, indices, topK) {
+async function loadFromDirectory(dirpath, schema, contentColumn) {
   const results = [];
-  let queryNorm = 0;
-  for (let i = 0;i < query.length; i++) {
-    queryNorm += query[i] * query[i];
-  }
-  queryNorm = Math.sqrt(queryNorm);
-  if (queryNorm === 0)
-    return results;
-  for (const idx of indices) {
-    const vector = vectors[idx];
-    if (!vector)
-      continue;
-    let dotProduct = 0;
-    let vectorNorm = 0;
-    for (let i = 0;i < query.length; i++) {
-      const vi = vector[i];
-      dotProduct += query[i] * vi;
-      vectorNorm += vi * vi;
-    }
-    vectorNorm = Math.sqrt(vectorNorm);
-    if (vectorNorm === 0)
-      continue;
-    const similarity = dotProduct / (queryNorm * vectorNorm);
-    results.push({ index: idx, similarity });
-  }
-  results.sort((a, b) => b.similarity - a.similarity);
-  if (topK !== undefined && topK > 0) {
-    return results.slice(0, topK);
-  }
-  return results;
-}
-function vectorSearch(vectors, indices, query, options = {}) {
-  const { topK, minSimilarity = 0 } = options;
-  let results = batchCosineSimilarity(query, vectors, indices, topK);
-  if (minSimilarity > 0) {
-    results = results.filter((r) => r.similarity >= minSimilarity);
-  }
-  return results;
-}
-function toFloat32Array(arr) {
-  return new Float32Array(arr);
-}
-
-class Database {
-  _options;
-  _columns;
-  _schema;
-  _contentColumn;
-  _watcher = null;
-  _isSaving = new Set;
-  _created = [];
-  _updated = [];
-  _contentHashes = new ReactiveMap;
-  _staleFlags = [];
-  _onFileChange;
-  constructor(options) {
-    this._options = options;
-    this._schema = createSchema(options.schema);
-    this._columns = new Columns(options.schema);
-    this._contentColumn = options.contentColumn;
-  }
-  onFileChange(callback) {
-    this._onFileChange = callback;
-  }
-  setEmbedding(id, vectorColumn, embedding, sourceContent) {
-    const index = getIndex(id);
-    if (index === undefined)
-      return false;
-    const vector = Array.isArray(embedding) ? toFloat32Array(embedding) : embedding;
-    this._columns.set(vectorColumn, index, vector);
-    if (!this._contentHashes.has(vectorColumn)) {
-      this._contentHashes.set(vectorColumn, []);
-    }
-    this._contentHashes.get(vectorColumn)[index] = Bun.hash(sourceContent);
-    this._staleFlags[index] = false;
-    return true;
-  }
-  isStale(id) {
-    const index = getIndex(id);
-    if (index === undefined)
-      return false;
-    return this._staleFlags[index] ?? false;
-  }
-  setStale(id, stale) {
-    const index = getIndex(id);
-    if (index === undefined)
-      return;
-    this._staleFlags[index] = stale;
-  }
-  getStaleIds() {
-    const staleIds = [];
-    for (const index of getAllIndices()) {
-      if (this._staleFlags[index]) {
-        const id = getId(index);
-        if (id)
-          staleIds.push(id);
-      }
-    }
-    return staleIds;
-  }
-  async insert(data) {
-    const id = data.id || this._generateId();
-    const index = allocateIndex(id);
-    const now = Date.now();
-    this._created[index] = now;
-    this._updated[index] = now;
-    for (const [key, value] of Object.entries(data)) {
-      if (key === "id")
-        continue;
-      const colType = this._options.schema[key];
-      if (colType && typeof colType === "string" && colType.startsWith("vector:")) {
-        if (Array.isArray(value)) {
-          this._columns.set(key, index, toFloat32Array(value));
-        } else {
-          this._columns.set(key, index, value);
-        }
-      } else {
-        this._columns.set(key, index, value);
-      }
-    }
-    if (this._options.autoSave && this._options.path) {
-      await this._saveRecord(id, index);
-    }
-    return id;
-  }
-  get(id) {
-    const index = getIndex(id);
-    if (index === undefined)
-      return null;
-    const record = this._columns.getRecord(index);
-    return {
-      id,
-      ...record,
-      created: this._created[index] || 0,
-      updated: this._updated[index] || 0,
-      stale: this._staleFlags[index] ?? false
-    };
-  }
-  async update(id, data) {
-    const index = getIndex(id);
-    if (index === undefined)
-      return false;
-    this._updated[index] = Date.now();
-    for (const [key, value] of Object.entries(data)) {
-      const colType = this._options.schema[key];
-      if (colType && typeof colType === "string" && colType.startsWith("vector:")) {
-        if (Array.isArray(value)) {
-          this._columns.set(key, index, toFloat32Array(value));
-        } else {
-          this._columns.set(key, index, value);
-        }
-      } else {
-        this._columns.set(key, index, value);
+  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);
       }
     }
-    if (this._options.autoSave && this._options.path) {
-      await this._saveRecord(id, index);
-    }
+  } catch {}
+  return results;
+}
+async function deleteMarkdownFile(filepath) {
+  try {
+    const fs = await import("fs/promises");
+    await fs.unlink(filepath);
     return true;
+  } catch {
+    return false;
   }
-  async delete(id) {
-    const index = releaseIndex(id);
-    if (index === undefined)
-      return false;
-    this._columns.clearAt(index);
-    this._created[index] = 0;
-    this._updated[index] = 0;
-    if (this._options.autoSave && this._options.path) {
-      const filePath = `${this._options.path}/${idToFilename(id)}`;
-      try {
-        await Bun.write(filePath, "");
-        const { unlink } = await import("fs/promises");
-        await unlink(filePath);
-      } catch {}
+}
+async function ensureDirectory(dirpath) {
+  const fs = await import("fs/promises");
+  await fs.mkdir(dirpath, { recursive: true });
+}
+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;
     }
-    return true;
-  }
-  find(filter) {
-    const results = [];
-    for (const index of getAllIndices()) {
-      const id = getId(index);
-      if (!id)
-        continue;
-      const record = this._columns.getRecord(index);
-      const withMeta = {
+    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,
-        ...record,
-        created: this._created[index] || 0,
-        updated: this._updated[index] || 0,
-        stale: this._staleFlags[index] || false
+        filename,
+        filepath,
+        stale: false
       };
-      if (filter(withMeta)) {
-        results.push(withMeta);
+    } 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);
+        }
       }
-    }
-    return results;
-  }
-  findOne(filter) {
-    for (const index of getAllIndices()) {
-      const id = getId(index);
-      if (!id)
-        continue;
-      const record = this._columns.getRecord(index);
-      const withMeta = {
+      event = {
+        type: isNew ? "create" : "update",
         id,
-        ...record,
-        created: this._created[index] || 0,
-        updated: this._updated[index] || 0,
-        stale: this._staleFlags[index] || false
+        filename,
+        filepath,
+        record: result.record,
+        stale
       };
-      if (filter(withMeta)) {
-        return withMeta;
-      }
-    }
-    return null;
-  }
-  all() {
-    return this.find(() => true);
-  }
-  count(filter) {
-    if (!filter) {
-      return registry.count;
-    }
-    return this.find(filter).length;
-  }
-  async insertMany(records) {
-    const ids = [];
-    for (const record of records) {
-      const id = await this.insert(record);
-      ids.push(id);
-    }
-    return ids;
-  }
-  async updateMany(filter, data) {
-    const matches = this.find(filter);
-    let count = 0;
-    for (const record of matches) {
-      const success = await this.update(record.id, data);
-      if (success)
-        count++;
     }
-    return count;
-  }
-  async deleteMany(filter) {
-    const matches = this.find(filter);
-    let count = 0;
-    for (const record of matches) {
-      const success = await this.delete(record.id);
-      if (success)
-        count++;
+    for (const callback of _callbacks) {
+      try {
+        await callback(event);
+      } catch (err) {
+        console.error("File watcher callback error:", err);
+      }
     }
-    return count;
   }
-  search(column, queryVector, options = {}) {
-    const { filter, ...searchOptions } = options;
-    const query = Array.isArray(queryVector) ? toFloat32Array(queryVector) : queryVector;
-    const vectors = this._columns.getColumn(column);
-    let indices = getAllIndices();
-    if (filter) {
-      indices = indices.filter((idx) => {
-        const id = getId(idx);
-        if (!id)
-          return false;
-        const record = this._columns.getRecord(idx);
-        return filter({ id, ...record });
-      });
+  function handleChange(filename) {
+    const existing = _pendingChanges.get(filename);
+    if (existing) {
+      clearTimeout(existing);
     }
-    const results = vectorSearch(vectors, indices, query, searchOptions);
-    return results.map(({ index, similarity }) => {
-      const id = getId(index);
-      const record = this._columns.getRecord(index);
-      const stale = this._staleFlags[index] ?? false;
-      return { id, ...record, similarity, stale };
-    });
+    const timeout = setTimeout(() => {
+      _pendingChanges.delete(filename);
+      processChange(filename);
+    }, debounceMs);
+    _pendingChanges.set(filename, timeout);
   }
-  async load() {
-    if (!this._options.path) {
-      throw new Error("No storage path configured");
-    }
-    const documents = await loadFromDirectory(this._options.path);
-    let count = 0;
-    for (const doc of documents) {
-      if (!doc.id)
-        continue;
-      const index = allocateIndex(doc.id);
-      for (const [key, value] of Object.entries(doc.frontmatter)) {
-        if (key === "id")
-          continue;
-        if (key === "created") {
-          this._created[index] = value;
-          continue;
-        }
-        if (key === "updated") {
-          this._updated[index] = value;
-          continue;
+  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);
         }
-        const colType = this._options.schema[key];
-        if (colType && typeof colType === "string" && colType.startsWith("vector:")) {
-          if (Array.isArray(value)) {
-            this._columns.set(key, index, toFloat32Array(value));
+        _watcher = watch(dirpath, { recursive: false }, (eventType, filename) => {
+          if (filename && filename.endsWith(".md")) {
+            handleChange(filename);
           }
-        } else if (key in this._options.schema) {
-          this._columns.set(key, index, value);
-        }
+        });
+        _isWatching.value = true;
+      } catch (err) {
+        console.error("Failed to start file watcher:", err);
       }
-      if (this._contentColumn && doc.content) {
-        this._columns.set(this._contentColumn, index, doc.content);
+    },
+    stop() {
+      if (!_isWatching.value)
+        return;
+      for (const timeout of _pendingChanges.values()) {
+        clearTimeout(timeout);
       }
-      count++;
-    }
-    if (count > 0) {
-      this._reconcileSchema();
-    }
-    return count;
-  }
-  _reconcileSchema() {
-    const indices = getAllIndices();
-    if (indices.length === 0)
-      return;
-    for (const [field, type] of Object.entries(this._options.schema)) {
-      const column = this._columns.getColumn(field);
-      const defaultValue = getDefaultForType(type);
-      for (const index of indices) {
-        if (column[index] === undefined) {
-          this._columns.set(field, index, defaultValue);
-        }
+      _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;
+}
+function toFloat32Array(arr) {
+  if (arr instanceof Float32Array)
+    return arr;
+  return new Float32Array(arr);
+}
+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}`);
   }
-  async save() {
-    if (!this._options.path) {
-      throw new Error("No storage path configured");
-    }
-    let count = 0;
-    for (const index of getAllIndices()) {
-      const id = getId(index);
-      if (!id)
-        continue;
-      await this._saveRecord(id, index);
-      count++;
-    }
-    return count;
-  }
-  get columns() {
-    return this._columns;
-  }
-  get registry() {
-    return registry;
-  }
-  getColumn(name) {
-    return this._columns.getColumn(name);
-  }
-  createIndex(column) {
-    return this._columns.createIndex(column);
-  }
-  getByIndex(index) {
-    if (!registry.allocatedIndices.has(index))
-      return null;
-    return this._columns.getRecord(index);
+  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];
   }
-  getIndices() {
-    return getAllIndices();
+  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];
   }
-  _generateId() {
-    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  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 });
   }
-  async _saveRecord(id, index) {
-    if (!this._options.path)
-      return;
-    this._isSaving.add(id);
-    try {
-      const record = this._columns.getRecord(index);
-      const frontmatter = {
-        id,
-        created: this._created[index],
-        updated: this._updated[index]
-      };
-      for (const [key, value] of Object.entries(record)) {
-        if (key === this._contentColumn)
-          continue;
-        if (value !== undefined && value !== null) {
-          if (value instanceof Float32Array) {
-            frontmatter[key] = Array.from(value);
-          } else {
-            frontmatter[key] = value;
-          }
+  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);
         }
       }
-      const content = this._contentColumn ? record[this._contentColumn] || "" : "";
-      const filePath = `${this._options.path}/${idToFilename(id)}`;
-      await saveToMarkdown(filePath, frontmatter, content, this._options.schema);
-    } finally {
-      setTimeout(() => {
-        this._isSaving.delete(id);
-      }, 200);
-    }
-  }
-  async startWatching() {
-    if (!this._options.path) {
-      throw new Error("No storage path configured");
+    },
+    reset() {
+      hashes.clear();
     }
-    if (this._watcher) {
-      return;
+  };
+}
+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;
     }
-    this._watcher = new FileWatcher(this._options.path, async (event) => this._handleFileChange(event), { debounceMs: 100 });
-    await this._watcher.start();
-  }
-  stopWatching() {
-    if (this._watcher) {
-      this._watcher.stop();
-      this._watcher = null;
+    const vec = collection.columns.get(vectorColumn, index);
+    if (vec) {
+      vectors.push(vec);
+      vectorIndices.push(index);
     }
   }
-  get isWatching() {
-    return this._watcher?.isWatching ?? false;
+  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)
+    });
   }
-  async _handleFileChange(event) {
-    const { type, id, filepath } = event;
-    if (this._isSaving.has(id)) {
-      return;
+  return results;
+}
+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;
+      }
     }
-    try {
-      if (type === "delete") {
-        const existingIndex = getIndex(id);
-        if (existingIndex !== undefined) {
-          releaseIndex(id);
-          this._columns.clearAt(existingIndex);
-          this._created[existingIndex] = 0;
-          this._updated[existingIndex] = 0;
-          this._staleFlags[existingIndex] = false;
-          for (const hashArray of this._contentHashes.values()) {
-            if (hashArray[existingIndex] !== undefined) {
-              hashArray[existingIndex] = null;
-            }
-          }
-          if (this._onFileChange) {
-            this._onFileChange({ ...event });
+    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),
+    setMetadata: baseCollection.setMetadata.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);
+        const created = record.created ?? Date.now();
+        const updated = record.updated ?? created;
+        const stale = record.stale ?? false;
+        baseCollection.setMetadata(id, created, updated, stale);
+        if (contentColumn) {
+          const content = record[contentColumn];
+          if (content && isContentStale(id, content)) {
+            baseCollection.setStale(id, true);
           }
         }
-      } else {
-        const doc = await loadFromMarkdown(filepath);
-        if (!doc.id)
+      }
+      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;
-        const index = allocateIndex(doc.id);
-        let isStale = false;
-        if (type === "update" && this._contentColumn && doc.content) {
-          const newContentHash = Bun.hash(doc.content);
-          for (const [vectorColumn, hashArray] of this._contentHashes.entries()) {
-            const storedHash = hashArray[index];
-            if (storedHash !== undefined && storedHash !== null && storedHash !== newContentHash) {
-              isStale = true;
-              break;
-            }
-          }
-        }
-        this._staleFlags[index] = isStale;
-        for (const [key, value] of Object.entries(doc.frontmatter)) {
-          if (key === "id")
-            continue;
-          if (key === "created") {
-            this._created[index] = value;
-            continue;
-          }
-          if (key === "updated") {
-            this._updated[index] = value;
-            continue;
+        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 });
           }
-          const colType = this._options.schema[key];
-          if (colType && typeof colType === "string" && colType.startsWith("vector:")) {
-            if (Array.isArray(value)) {
-              this._columns.set(key, index, toFloat32Array(value));
-            }
-          } else if (key in this._options.schema) {
-            this._columns.set(key, index, value);
+          if (event.stale) {
+            baseCollection.setStale(event.id, true);
           }
         }
-        if (this._contentColumn && doc.content) {
-          this._columns.set(this._contentColumn, index, doc.content);
-        }
-        if (this._onFileChange) {
-          const record = this._columns.getRecord(index);
-          this._onFileChange({ ...event, record, stale: isStale });
+        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();
       }
-    } catch (error) {
-      console.error(`FatherStateDB: Error handling file change for ${id}:`, error);
+      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}`;
   }
-  close() {
-    this.stopWatching();
-    resetRegistry();
-  }
-}
-async function createDatabase(options) {
-  const db = new Database(options);
-  if (options.path) {
-    try {
-      const { mkdir } = await import("fs/promises");
-      await mkdir(options.path, { recursive: true });
-      await db.load();
-    } catch (error) {}
-    if (options.watchFiles) {
-      await db.startWatching();
+  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();
     }
-  }
-  return db;
+  };
 }
 
 // src/core/store.ts
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join } from "path";
 
 // src/types/schema.ts
 var memorySchema = {
@@ -11128,7 +12011,7 @@ class MemoryStore {
   _projects = new Map;
   constructor(config = {}) {
     this._config = {
-      basePath: config.basePath ?? join2(homedir(), ".local", "share", "memory"),
+      basePath: config.basePath ?? join(homedir(), ".local", "share", "memory"),
       watchFiles: config.watchFiles ?? false
     };
   }
@@ -11138,43 +12021,47 @@ class MemoryStore {
       return this._projects.get(projectId);
     }
     console.log(`\uD83C\uDD95 [DEBUG] Creating NEW databases for ${projectId}`);
-    const projectPath = join2(this._config.basePath, projectId);
+    const projectPath = join(this._config.basePath, projectId);
     console.log(`   Path: ${projectPath}`);
-    const [memories, summaries, snapshots, sessions] = await Promise.all([
-      createDatabase({
-        path: join2(projectPath, "memories"),
-        schema: memorySchema,
-        contentColumn: "content",
-        autoSave: true,
-        watchFiles: this._config.watchFiles
-      }),
-      createDatabase({
-        path: join2(projectPath, "summaries"),
-        schema: sessionSummarySchema,
-        contentColumn: "summary",
-        autoSave: true,
-        watchFiles: this._config.watchFiles
-      }),
-      createDatabase({
-        path: join2(projectPath, "snapshots"),
-        schema: projectSnapshotSchema,
-        autoSave: true,
-        watchFiles: this._config.watchFiles
-      }),
-      createDatabase({
-        path: join2(projectPath, "sessions"),
-        schema: sessionSchema,
-        autoSave: true,
-        watchFiles: this._config.watchFiles
-      })
+    const db = createDatabase({
+      name: projectId,
+      basePath: projectPath
+    });
+    const memories = db.collection("memories", {
+      schema: memorySchema,
+      contentColumn: "content",
+      autoSave: true,
+      watchFiles: this._config.watchFiles
+    });
+    const summaries = db.collection("summaries", {
+      schema: sessionSummarySchema,
+      contentColumn: "summary",
+      autoSave: true,
+      watchFiles: this._config.watchFiles
+    });
+    const snapshots = db.collection("snapshots", {
+      schema: projectSnapshotSchema,
+      autoSave: true,
+      watchFiles: this._config.watchFiles
+    });
+    const sessions = db.collection("sessions", {
+      schema: sessionSchema,
+      autoSave: true,
+      watchFiles: this._config.watchFiles
+    });
+    await Promise.all([
+      memories.load(),
+      summaries.load(),
+      snapshots.load(),
+      sessions.load()
     ]);
-    const dbs = { memories, summaries, snapshots, sessions };
-    this._projects.set(projectId, dbs);
-    return dbs;
+    const projectDB = { db, memories, summaries, snapshots, sessions };
+    this._projects.set(projectId, projectDB);
+    return projectDB;
   }
   async storeMemory(projectId, sessionId, memory, embedding) {
     const { memories } = await this.getProject(projectId);
-    const id = await memories.insert({
+    const id = memories.insert({
       content: memory.content,
       reasoning: memory.reasoning,
       importance_weight: memory.importance_weight,
@@ -11190,7 +12077,7 @@ class MemoryStore {
       question_types: memory.question_types,
       session_id: sessionId,
       project_id: projectId,
-      embedding: embedding ? embedding instanceof Float32Array ? embedding : new Float32Array(embedding) : undefined
+      embedding: embedding ? embedding instanceof Float32Array ? embedding : new Float32Array(embedding) : null
     });
     return id;
   }
@@ -11213,7 +12100,7 @@ class MemoryStore {
       question_types: record.question_types,
       session_id: record.session_id,
       project_id: record.project_id,
-      embedding: record.embedding,
+      embedding: record.embedding ?? undefined,
       created_at: record.created,
       updated_at: record.updated,
       stale: record.stale
@@ -11224,9 +12111,9 @@ class MemoryStore {
     const { topK = 10, filter } = options;
     const results = memories.search("embedding", queryEmbedding, {
       topK,
-      filter: filter ? (record) => {
+      filter: filter ? (record, _idx) => {
         const mem = {
-          id: record.id,
+          id: "",
           content: record.content,
           reasoning: record.reasoning,
           importance_weight: record.importance_weight,
@@ -11248,36 +12135,37 @@ class MemoryStore {
         return filter(mem);
       } : undefined
     });
-    return results.map((record) => ({
-      id: record.id,
-      content: record.content,
-      reasoning: record.reasoning,
-      importance_weight: record.importance_weight,
-      confidence_score: record.confidence_score,
-      context_type: record.context_type,
-      temporal_relevance: record.temporal_relevance,
-      knowledge_domain: record.knowledge_domain,
-      emotional_resonance: record.emotional_resonance,
-      action_required: record.action_required,
-      problem_solution_pair: record.problem_solution_pair,
-      semantic_tags: record.semantic_tags,
-      trigger_phrases: record.trigger_phrases,
-      question_types: record.question_types,
-      session_id: record.session_id,
-      project_id: record.project_id,
-      embedding: record.embedding,
-      created_at: record.created,
-      updated_at: record.updated,
-      stale: record.stale
+    return results.map((result) => ({
+      id: result.record.id,
+      content: result.record.content,
+      reasoning: result.record.reasoning,
+      importance_weight: result.record.importance_weight,
+      confidence_score: result.record.confidence_score,
+      context_type: result.record.context_type,
+      temporal_relevance: result.record.temporal_relevance,
+      knowledge_domain: result.record.knowledge_domain,
+      emotional_resonance: result.record.emotional_resonance,
+      action_required: result.record.action_required,
+      problem_solution_pair: result.record.problem_solution_pair,
+      semantic_tags: result.record.semantic_tags,
+      trigger_phrases: result.record.trigger_phrases,
+      question_types: result.record.question_types,
+      session_id: result.record.session_id,
+      project_id: result.record.project_id,
+      embedding: result.record.embedding ?? undefined,
+      created_at: result.record.created,
+      updated_at: result.record.updated,
+      stale: result.stale
     }));
   }
   async setMemoryEmbedding(projectId, memoryId, embedding, content) {
     const { memories } = await this.getProject(projectId);
-    return memories.setEmbedding(memoryId, "embedding", embedding, content);
+    const vec = embedding instanceof Float32Array ? embedding : new Float32Array(embedding);
+    memories.setEmbedding(memoryId, "embedding", vec, content);
   }
   async getStaleMemoryIds(projectId) {
     const { memories } = await this.getProject(projectId);
-    return memories.getStaleIds();
+    return memories.all().filter((r) => r.stale).map((r) => r.id);
   }
   async getOrCreateSession(projectId, sessionId) {
     const { sessions } = await this.getProject(projectId);
@@ -11291,7 +12179,7 @@ class MemoryStore {
     }
     const allSessions = sessions.all();
     const firstSessionCompleted = allSessions.some((s) => s.first_session_completed);
-    await sessions.insert({
+    sessions.insert({
       id: sessionId,
       project_id: projectId,
       message_count: 0,
@@ -11312,7 +12200,7 @@ class MemoryStore {
       throw new Error(`Session ${sessionId} not found`);
     }
     const newCount = session.message_count + 1;
-    await sessions.update(sessionId, {
+    sessions.update(sessionId, {
       message_count: newCount,
       last_active: Date.now()
     });
@@ -11320,14 +12208,14 @@ class MemoryStore {
   }
   async markFirstSessionCompleted(projectId, sessionId) {
     const { sessions } = await this.getProject(projectId);
-    await sessions.update(sessionId, { first_session_completed: true });
+    sessions.update(sessionId, { first_session_completed: true });
   }
   async storeSessionSummary(projectId, sessionId, summary, interactionTone = "") {
     const { summaries } = await this.getProject(projectId);
     console.log(`\uD83D\uDCDD [DEBUG] Storing summary for ${projectId}:`);
     console.log(`   Summary length: ${summary.length} chars`);
     console.log(`   Summaries count before: ${summaries.all().length}`);
-    const id = await summaries.insert({
+    const id = summaries.insert({
       session_id: sessionId,
       project_id: projectId,
       summary,
@@ -11346,8 +12234,8 @@ class MemoryStore {
       console.log(`   No summaries found!`);
       return null;
     }
-    all.sort((a, b) => b.created - a.created);
-    const latest = all[0];
+    const sorted = [...all].sort((a, b) => b.created - a.created);
+    const latest = sorted[0];
     console.log(`   Latest summary: ${latest.summary.slice(0, 50)}...`);
     return {
       id: latest.id,
@@ -11374,8 +12262,8 @@ class MemoryStore {
     const all = snapshots.all();
     if (!all.length)
       return null;
-    all.sort((a, b) => b.created - a.created);
-    const latest = all[0];
+    const sorted = [...all].sort((a, b) => b.created - a.created);
+    const latest = sorted[0];
     return {
       id: latest.id,
       session_id: latest.session_id,
@@ -11391,25 +12279,22 @@ class MemoryStore {
     const { memories, sessions } = await this.getProject(projectId);
     const allMemories = memories.all();
     const allSessions = sessions.all();
-    const staleIds = memories.getStaleIds();
+    const staleCount = allMemories.filter((r) => r.stale).length;
     let latestSession = null;
     if (allSessions.length) {
-      allSessions.sort((a, b) => b.last_active - a.last_active);
-      latestSession = allSessions[0].id;
+      const sorted = [...allSessions].sort((a, b) => b.last_active - a.last_active);
+      latestSession = sorted[0].id;
     }
     return {
       totalMemories: allMemories.length,
       totalSessions: allSessions.length,
-      staleMemories: staleIds.length,
+      staleMemories: staleCount,
       latestSession
     };
   }
   close() {
-    for (const dbs of this._projects.values()) {
-      dbs.memories.close();
-      dbs.summaries.close();
-      dbs.snapshots.close();
-      dbs.sessions.close();
+    for (const projectDB of this._projects.values()) {
+      projectDB.db.close();
     }
     this._projects.clear();
   }
@@ -11418,9 +12303,205 @@ function createStore(config) {
   return new MemoryStore(config);
 }
 
+// src/utils/logger.ts
+import { styleText } from "util";
+var style = (format, text) => styleText(format, text);
+function timestamp() {
+  return style("dim", new Date().toISOString().slice(11, 19));
+}
+function shortId(id) {
+  return style("dim", id.slice(0, 8) + "...");
+}
+var sym = {
+  brain: "\uD83E\uDDE0",
+  sparkles: "✨",
+  book: "\uD83D\uDCD6",
+  calendar: "\uD83D\uDCC5",
+  arrow: "→",
+  check: "✓",
+  cross: "✗",
+  warning: "⚠",
+  info: "ℹ",
+  bullet: "•",
+  fire: "\uD83D\uDD25",
+  target: "\uD83C\uDFAF"
+};
+var logger = {
+  info(message) {
+    console.log(`${timestamp()} ${style("cyan", sym.info)} ${message}`);
+  },
+  success(message) {
+    console.log(`${timestamp()} ${style("green", sym.check)} ${message}`);
+  },
+  warn(message) {
+    console.log(`${timestamp()} ${style("yellow", sym.warning)} ${message}`);
+  },
+  error(message) {
+    console.error(`${timestamp()} ${style("red", sym.cross)} ${message}`);
+  },
+  memory(message) {
+    console.log(`${timestamp()} ${style("magenta", sym.brain)} ${message}`);
+  },
+  inject(message) {
+    console.log(`${timestamp()} ${style("cyan", sym.sparkles)} ${message}`);
+  },
+  session(message) {
+    console.log(`${timestamp()} ${style("blue", sym.calendar)} ${message}`);
+  },
+  primer(message) {
+    console.log(`${timestamp()} ${style("yellow", sym.book)} ${message}`);
+  },
+  divider() {
+    console.log(style("dim", "─".repeat(60)));
+  },
+  request(method, path, projectId) {
+    const proj = projectId ? style("dim", ` [${projectId}]`) : "";
+    console.log(`${timestamp()} ${style("dim", sym.arrow)} ${style("cyan", method)} ${path}${proj}`);
+  },
+  logCuratedMemories(memories) {
+    console.log();
+    console.log(`${timestamp()} ${style("magenta", sym.brain)} ${style(["bold", "magenta"], `CURATED ${memories.length} MEMORIES`)}`);
+    console.log();
+    memories.forEach((m, i) => {
+      const importance = style("yellow", `${(m.importance_weight * 100).toFixed(0)}%`);
+      const type = style("cyan", m.context_type.toUpperCase());
+      const num = style("dim", `${i + 1}.`);
+      console.log(`   ${num} [${type}] ${importance}`);
+      const preview = m.content.length > 70 ? m.content.slice(0, 70) + style("dim", "...") : m.content;
+      console.log(`      ${style("white", preview)}`);
+      if (m.semantic_tags?.length) {
+        const tags = m.semantic_tags.slice(0, 4).join(style("dim", ", "));
+        console.log(`      ${style("dim", "tags:")} ${tags}`);
+      }
+      if (m.action_required) {
+        console.log(`      ${style("red", "⚡ ACTION REQUIRED")}`);
+      }
+      console.log();
+    });
+  },
+  logRetrievedMemories(memories, query) {
+    const queryPreview = query.length > 40 ? query.slice(0, 40) + "..." : query;
+    const emojiMap = {
+      breakthrough: "\uD83D\uDCA1",
+      decision: "⚖️",
+      personal: "\uD83D\uDC9C",
+      technical: "\uD83D\uDD27",
+      technical_state: "\uD83D\uDCCD",
+      unresolved: "❓",
+      preference: "⚙️",
+      workflow: "\uD83D\uDD04",
+      architectural: "\uD83C\uDFD7️",
+      debugging: "\uD83D\uDC1B",
+      philosophy: "\uD83C\uDF00",
+      todo: "\uD83C\uDFAF",
+      implementation: "⚡",
+      problem_solution: "✅",
+      project_context: "\uD83D\uDCE6",
+      milestone: "\uD83C\uDFC6",
+      general: "\uD83D\uDCDD"
+    };
+    console.log();
+    console.log(`${timestamp()} ${style("cyan", sym.sparkles)} ${style("bold", `SURFACING ${memories.length} MEMORIES`)}`);
+    console.log(`      ${style("dim", "query:")} "${queryPreview}"`);
+    console.log();
+    if (memories.length === 0) {
+      console.log(`      ${style("dim", "(no relevant memories for this context)")}`);
+      console.log();
+      return;
+    }
+    memories.forEach((m, i) => {
+      const score = style("green", `${(m.score * 100).toFixed(0)}%`);
+      const emoji = emojiMap[m.context_type?.toLowerCase()] ?? "\uD83D\uDCDD";
+      const num = style("dim", `${i + 1}.`);
+      const preview = m.content.length > 55 ? m.content.slice(0, 55) + style("dim", "...") : m.content;
+      console.log(`   ${num} [${score}] ${emoji}`);
+      console.log(`      ${preview}`);
+    });
+    console.log();
+  },
+  startup(port, host, mode) {
+    console.log();
+    console.log(style(["bold", "magenta"], "┌──────────────────────────────────────────────────────────┐"));
+    console.log(style(["bold", "magenta"], "│") + style("bold", `  ${sym.brain} MEMORY SERVER                                        `) + style(["bold", "magenta"], "│"));
+    console.log(style(["bold", "magenta"], "└──────────────────────────────────────────────────────────┘"));
+    console.log();
+    console.log(`   ${style("dim", "url:")}     ${style("cyan", `http://${host}:${port}`)}`);
+    console.log(`   ${style("dim", "storage:")} ${mode}`);
+    console.log(`   ${style("dim", "engine:")}  TypeScript + fsdb`);
+    console.log();
+    this.divider();
+    console.log();
+  },
+  logSessionStart(sessionId, projectId, isNew) {
+    const status = isNew ? style("green", "new session") : style("blue", "continuing");
+    console.log();
+    console.log(`${timestamp()} ${style("blue", sym.calendar)} ${style("bold", "SESSION")} ${shortId(sessionId)}`);
+    console.log(`      ${style("dim", "project:")} ${projectId}`);
+    console.log(`      ${style("dim", "status:")} ${status}`);
+    console.log();
+  },
+  logCurationStart(sessionId, trigger) {
+    console.log();
+    console.log(`${timestamp()} ${style("magenta", sym.brain)} ${style("bold", "CURATING")} ${shortId(sessionId)}`);
+    console.log(`      ${style("dim", "trigger:")} ${trigger}`);
+  },
+  logCurationComplete(memoriesCount, summary) {
+    if (memoriesCount > 0) {
+      console.log(`      ${style("dim", "memories:")} ${style("green", String(memoriesCount))} extracted`);
+      if (summary) {
+        const shortSummary = summary.length > 50 ? summary.slice(0, 50) + "..." : summary;
+        console.log(`      ${style("dim", "summary:")} ${shortSummary}`);
+      }
+    } else {
+      console.log(`      ${style("dim", "result:")} no memories to extract`);
+    }
+    console.log();
+  },
+  logRetrievalScoring(params) {
+    const { totalMemories, currentMessage, alreadyInjected, mustIncludeCount, remainingSlots, finalCount, selectedMemories } = params;
+    console.log();
+    console.log(`${timestamp()} ${style("magenta", sym.brain)} ${style("bold", "TWO-STAGE MEMORY FILTERING")}`);
+    console.log(`      ${style("dim", "candidates:")} ${totalMemories} memories`);
+    console.log(`      ${style("dim", "already injected:")} ${alreadyInjected}`);
+    const msgPreview = currentMessage.length > 60 ? currentMessage.slice(0, 60) + "..." : currentMessage;
+    console.log(`      ${style("dim", "trigger:")} "${msgPreview}"`);
+    console.log();
+    console.log(`      ${style("cyan", "Stage 1:")} ${mustIncludeCount} must-include (critical/action-required)`);
+    console.log(`      ${style("cyan", "Stage 2:")} ${remainingSlots} slots for scored selection`);
+    console.log(`      ${style("green", "Final:")} ${finalCount} memories selected`);
+    console.log();
+    if (selectedMemories.length === 0) {
+      console.log(`      ${style("dim", "\uD83D\uDCED No relevant memories for this context")}`);
+      console.log();
+      return;
+    }
+    console.log(style("dim", "      ─".repeat(30)));
+    console.log(`      ${style("bold", "SELECTION DETAILS")}`);
+    console.log();
+    selectedMemories.forEach((m, i) => {
+      const num = style("dim", `${i + 1}.`);
+      const score = style("green", `${(m.score * 100).toFixed(0)}%`);
+      const relevance = style("cyan", `rel:${(m.relevance_score * 100).toFixed(0)}%`);
+      const type = style("yellow", m.context_type.toUpperCase());
+      console.log(`   ${num} [${score} ${relevance}] ${type}`);
+      const preview = m.content.length > 60 ? m.content.slice(0, 60) + style("dim", "...") : m.content;
+      console.log(`      ${style("white", preview)}`);
+      const components = Object.entries(m.components).sort((a, b) => b[1] - a[1]).slice(0, 3).filter(([, v]) => v > 0.1).map(([k, v]) => `${k}:${(v * 100).toFixed(0)}%`).join(", ");
+      if (components) {
+        console.log(`      ${style("dim", "scores:")} ${components}`);
+      }
+      if (m.semantic_tags?.length) {
+        const tags = m.semantic_tags.slice(0, 3).join(", ");
+        console.log(`      ${style("dim", "tags:")} ${tags}`);
+      }
+      console.log();
+    });
+  }
+};
+
 // src/core/retrieval.ts
 class SmartVectorRetrieval {
-  retrieveRelevantMemories(allMemories, currentMessage, queryEmbedding, sessionContext, maxMemories = 5) {
+  retrieveRelevantMemories(allMemories, currentMessage, queryEmbedding, sessionContext, maxMemories = 5, alreadyInjectedCount = 0) {
     if (!allMemories.length) {
       return [];
     }
@@ -11519,6 +12600,24 @@ class SmartVectorRetrieval {
       }
     }
     const finalSelected = selected.slice(0, maxMemories);
+    logger.logRetrievalScoring({
+      totalMemories: allMemories.length,
+      currentMessage,
+      alreadyInjected: alreadyInjectedCount,
+      mustIncludeCount: mustInclude.length,
+      remainingSlots,
+      finalCount: finalSelected.length,
+      selectedMemories: finalSelected.map((item) => ({
+        content: item.memory.content,
+        reasoning: item.reasoning,
+        score: item.score,
+        relevance_score: item.relevance_score,
+        importance_weight: item.memory.importance_weight ?? 0.5,
+        context_type: item.memory.context_type ?? "general",
+        semantic_tags: item.memory.semantic_tags ?? [],
+        components: item.components
+      }))
+    });
     return finalSelected.map((item) => ({
       ...item.memory,
       score: item.score,
@@ -11716,35 +12815,65 @@ function createRetrieval() {
   return new SmartVectorRetrieval;
 }
 
+// src/types/memory.ts
+var MEMORY_TYPE_EMOJI = {
+  breakthrough: "\uD83D\uDCA1",
+  decision: "⚖️",
+  personal: "\uD83D\uDC9C",
+  technical: "\uD83D\uDD27",
+  technical_state: "\uD83D\uDCCD",
+  unresolved: "❓",
+  preference: "⚙️",
+  workflow: "\uD83D\uDD04",
+  architectural: "\uD83C\uDFD7️",
+  debugging: "\uD83D\uDC1B",
+  philosophy: "\uD83C\uDF00",
+  todo: "\uD83C\uDFAF",
+  implementation: "⚡",
+  problem_solution: "✅",
+  project_context: "\uD83D\uDCE6",
+  milestone: "\uD83C\uDFC6",
+  general: "\uD83D\uDCDD"
+};
+function getMemoryEmoji(contextType) {
+  return MEMORY_TYPE_EMOJI[contextType.toLowerCase()] ?? "\uD83D\uDCDD";
+}
+
 // src/core/engine.ts
 class MemoryEngine {
   _config;
   _stores = new Map;
   _retrieval;
+  _sessionMetadata = new Map;
   constructor(config = {}) {
     this._config = {
       storageMode: config.storageMode ?? "central",
-      centralPath: config.centralPath ?? join3(homedir2(), ".local", "share", "memory"),
+      centralPath: config.centralPath ?? join2(homedir2(), ".local", "share", "memory"),
       localFolder: config.localFolder ?? ".memory",
       maxMemories: config.maxMemories ?? 5,
       embedder: config.embedder
     };
     this._retrieval = createRetrieval();
   }
+  _getSessionMetadata(sessionId, projectId) {
+    if (!this._sessionMetadata.has(sessionId)) {
+      this._sessionMetadata.set(sessionId, {
+        message_count: 0,
+        started_at: Date.now(),
+        project_id: projectId,
+        injected_memories: new Set
+      });
+    }
+    return this._sessionMetadata.get(sessionId);
+  }
   async _getStore(projectId, projectPath) {
     const key = this._config.storageMode === "local" && projectPath ? projectPath : projectId;
-    console.log(`\uD83C\uDFEA [DEBUG] _getStore called:`);
-    console.log(`   projectId: ${projectId}`);
-    console.log(`   projectPath: ${projectPath}`);
-    console.log(`   storageMode: ${this._config.storageMode}`);
-    console.log(`   cache key: ${key}`);
-    console.log(`   cached: ${this._stores.has(key)}`);
     if (this._stores.has(key)) {
       return this._stores.get(key);
     }
     let basePath;
     if (this._config.storageMode === "local" && projectPath) {
-      basePath = join3(projectPath, this._config.localFolder);
+      basePath = join2(projectPath, this._config.localFolder);
     } else {
       basePath = this._config.centralPath;
     }
@@ -11773,10 +12902,16 @@ class MemoryEngine {
     if (!currentMessage.trim()) {
       return { memories: [], formatted: "" };
     }
+    const sessionMeta = this._getSessionMetadata(sessionId, projectId);
+    const injectedIds = sessionMeta.injected_memories;
     const allMemories = await store.getAllMemories(projectId);
     if (!allMemories.length) {
       return { memories: [], formatted: "" };
     }
+    const candidateMemories = allMemories.filter((m) => !injectedIds.has(m.id));
+    if (!candidateMemories.length) {
+      return { memories: [], formatted: "" };
+    }
     let queryEmbedding;
     if (this._config.embedder) {
       queryEmbedding = await this._config.embedder(currentMessage);
@@ -11786,7 +12921,10 @@ class MemoryEngine {
       project_id: projectId,
       message_count: messageCount
     };
-    const relevantMemories = this._retrieval.retrieveRelevantMemories(allMemories, currentMessage, queryEmbedding ?? new Float32Array(384), sessionContext, maxMemories);
+    const relevantMemories = this._retrieval.retrieveRelevantMemories(candidateMemories, currentMessage, queryEmbedding ?? new Float32Array(384), sessionContext, maxMemories, injectedIds.size);
+    for (const memory of relevantMemories) {
+      injectedIds.add(memory.id);
+    }
     return {
       memories: relevantMemories,
       formatted: this._formatMemories(relevantMemories)
@@ -11831,12 +12969,32 @@ class MemoryEngine {
       const timeSince = Date.now() - summary.created_at;
       temporalContext = this._formatTimeSince(timeSince);
     }
+    const currentDatetime = this._formatCurrentDatetime();
+    const sessionNumber = stats.totalSessions + 1;
     return {
       temporal_context: temporalContext,
+      current_datetime: currentDatetime,
+      session_number: sessionNumber,
       session_summary: summary?.summary,
       project_status: snapshot ? this._formatSnapshot(snapshot) : undefined
     };
   }
+  _formatCurrentDatetime() {
+    const now = new Date;
+    const dayOfWeek = now.toLocaleDateString("en-US", { weekday: "long" });
+    const fullDate = now.toLocaleDateString("en-US", {
+      month: "long",
+      day: "numeric",
+      year: "numeric"
+    });
+    const time = now.toLocaleTimeString("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true
+    });
+    const timezone = now.toLocaleTimeString("en-US", { timeZoneName: "short" }).split(" ").pop();
+    return `${dayOfWeek}, ${fullDate} • ${time} • ${timezone}`;
+  }
   _formatTimeSince(ms) {
     const minutes = Math.floor(ms / 60000);
     const hours = Math.floor(minutes / 60);
@@ -11869,9 +13027,8 @@ class MemoryEngine {
   }
   _formatPrimer(primer) {
     const parts = ["# Continuing Session"];
-    if (primer.temporal_context) {
-      parts.push(`*${primer.temporal_context}*`);
-    }
+    parts.push(`*Session #${primer.session_number}${primer.temporal_context ? ` • ${primer.temporal_context}` : ""}*`);
+    parts.push(`\uD83D\uDCC5 ${primer.current_datetime}`);
     if (primer.session_summary) {
       parts.push(`
 **Previous session**: ${primer.session_summary}`);
@@ -11881,6 +13038,8 @@ class MemoryEngine {
 **Project status**: ${primer.project_status}`);
     }
     parts.push(`
+**Memory types**: \uD83D\uDCA1breakthrough ⚖️decision \uD83D\uDC9Cpersonal \uD83D\uDD27technical \uD83D\uDCCDstate ❓unresolved ⚙️preference \uD83D\uDD04workflow \uD83C\uDFD7️architecture \uD83D\uDC1Bdebug \uD83C\uDF00philosophy \uD83C\uDFAFtodo ⚡impl ✅solved \uD83D\uDCE6project \uD83C\uDFC6milestone`);
+    parts.push(`
 *Memories will surface naturally as we converse.*`);
     return parts.join(`
 `);
@@ -11894,8 +13053,8 @@ class MemoryEngine {
     for (const memory of memories) {
       const tags = memory.semantic_tags?.join(", ") || "";
       const importance = memory.importance_weight?.toFixed(1) || "0.5";
-      const contextType = memory.context_type?.toUpperCase() || "GENERAL";
-      parts.push(`[${contextType} • ${importance}] [${tags}] ${memory.content}`);
+      const emoji = getMemoryEmoji(memory.context_type || "general");
+      parts.push(`[${emoji} • ${importance}] [${tags}] ${memory.content}`);
     }
     return parts.join(`
 `);
@@ -11912,14 +13071,14 @@ function createEngine(config) {
 }
 // src/core/curator.ts
 import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 import { existsSync } from "fs";
 function getClaudeCommand() {
   const envCommand = process.env.CURATOR_COMMAND;
   if (envCommand) {
     return envCommand;
   }
-  const claudeLocal = join4(homedir3(), ".claude", "local", "claude");
+  const claudeLocal = join3(homedir3(), ".claude", "local", "claude");
   if (existsSync(claudeLocal)) {
     return claudeLocal;
   }
@@ -11935,7 +13094,6 @@ class Curator {
       cliCommand,
       cliType: config.cliType ?? "claude-code"
     };
-    console.log(`\uD83E\uDDE0 Curator initialized with CLI: ${cliCommand}`);
   }
   buildCurationPrompt(triggerType = "session_end") {
     return `You have just had a conversation. As this session is ending (${triggerType}), please curate memories for the Claude Tools Memory System.
@@ -12013,8 +13171,9 @@ Return ONLY this JSON structure:
     "interaction_tone": "The tone/style of interaction (e.g., professional and focused, warm collaborative friendship, mentor-student dynamic, casual technical discussion, or null if neutral)",
     "project_snapshot": {
         "current_phase": "Current state (if applicable)",
-        "recent_achievements": "What was accomplished (if applicable)",
-        "active_challenges": "What remains (if applicable)"
+        "recent_achievements": ["What was accomplished (if applicable)"],
+        "active_challenges": ["What remains (if applicable)"],
+        "next_steps": ["Planned next actions (if applicable)"]
     },
     "memories": [
         {
@@ -12057,8 +13216,7 @@ Return ONLY this JSON structure:
         } : undefined,
         memories: this._parseMemories(data.memories ?? [])
       };
-    } catch (error) {
-      console.error("Failed to parse curation response:", error);
+    } catch {
       return {
         session_summary: "",
         memories: []
@@ -12128,25 +13286,21 @@ ${prompt}`
     }
     return this.parseCurationResponse(content.text);
   }
-  async curateWithCLI(sessionId, triggerType = "session_end", cwd) {
+  async curateWithCLI(sessionId, triggerType = "session_end", cwd, cliTypeOverride) {
+    const type = cliTypeOverride ?? this._config.cliType;
     const systemPrompt = this.buildCurationPrompt(triggerType);
     const userMessage = "This session has ended. Please curate the memories from our conversation according to the instructions in your system prompt. Return ONLY the JSON structure.";
     const args = [];
-    if (this._config.cliType === "claude-code") {
+    let command = this._config.cliCommand;
+    if (type === "claude-code") {
       args.push("--resume", sessionId, "-p", userMessage, "--append-system-prompt", systemPrompt, "--output-format", "json", "--max-turns", "1");
     } else {
+      command = "gemini";
       args.push("--resume", sessionId, "-p", `${systemPrompt}
 
 ${userMessage}`, "--output-format", "json");
     }
-    console.log(`
-\uD83D\uDCCB Executing CLI command:`);
-    console.log(`   Command: ${this._config.cliCommand}`);
-    console.log(`   Args: --resume ${sessionId} -p [user_message] --append-system-prompt [curation_instructions] --output-format json --max-turns 1`);
-    console.log(`   CWD: ${cwd || "not set"}`);
-    console.log(`   User message: "${userMessage.slice(0, 50)}..."`);
-    console.log(`   System prompt length: ${systemPrompt.length} chars`);
-    const proc = Bun.spawn([this._config.cliCommand, ...args], {
+    const proc = Bun.spawn([command, ...args], {
       cwd,
       env: {
         ...process.env,
@@ -12159,67 +13313,29 @@ ${userMessage}`, "--output-format", "json");
       new Response(proc.stderr).text()
     ]);
     const exitCode = await proc.exited;
-    console.log(`
-\uD83D\uDCE4 CLI Response:`);
-    console.log(`   Exit code: ${exitCode}`);
-    console.log(`   Stdout length: ${stdout.length} chars`);
-    console.log(`   Stderr length: ${stderr.length} chars`);
-    if (stderr) {
-      console.log(`
-⚠️ Stderr output:`);
-      console.log(stderr.slice(0, 1000));
-    }
-    if (stdout) {
-      console.log(`
-\uD83D\uDCE5 Stdout output (first 500 chars):`);
-      console.log(stdout.slice(0, 500));
-    }
     if (exitCode !== 0) {
-      console.error(`
-❌ CLI exited with code ${exitCode}`);
       return { session_summary: "", memories: [] };
     }
     try {
       const cliOutput = JSON.parse(stdout);
       if (cliOutput.type === "error" || cliOutput.is_error === true) {
-        console.log(`
-❌ CLI returned error:`);
-        console.log(`   Type: ${cliOutput.type}`);
-        console.log(`   Message: ${cliOutput.message || cliOutput.error || "Unknown error"}`);
         return { session_summary: "", memories: [] };
       }
       let aiResponse = "";
       if (typeof cliOutput.result === "string") {
         aiResponse = cliOutput.result;
-        console.log(`
-\uD83D\uDCE6 Extracted result from CLI wrapper (${aiResponse.length} chars)`);
       } else {
-        console.log(`
-⚠️ No result field in CLI output`);
-        console.log(`   Keys: ${Object.keys(cliOutput).join(", ")}`);
         return { session_summary: "", memories: [] };
       }
       const codeBlockMatch = aiResponse.match(/```(?:json)?\s*([\s\S]*?)```/);
       if (codeBlockMatch) {
         aiResponse = codeBlockMatch[1].trim();
-        console.log(`\uD83D\uDCDD Extracted JSON from markdown code block`);
       }
       const jsonMatch = aiResponse.match(/\{[\s\S]*\}/)?.[0];
       if (jsonMatch) {
-        console.log(`✅ Found JSON object (${jsonMatch.length} chars)`);
-        const result = this.parseCurationResponse(jsonMatch);
-        console.log(`   Parsed ${result.memories.length} memories`);
-        return result;
-      } else {
-        console.log(`
-⚠️ No JSON object found in AI response`);
-        console.log(`   Response preview: ${aiResponse.slice(0, 200)}...`);
+        return this.parseCurationResponse(jsonMatch);
       }
-    } catch (error) {
-      console.error(`
-❌ Failed to parse CLI output:`, error);
-      console.log(`   Raw stdout (first 500 chars): ${stdout.slice(0, 500)}`);
-    }
+    } catch {}
     return { session_summary: "", memories: [] };
   }
 }