@polka-codes/cli-shared 0.9.88 → 0.9.90

package/dist/index.js

@@ -9179,8 +9179,8 @@ var require_retry = __commonJS((exports) => {
     }
     const delay2 = getNextRetryDelay(config3);
     err.config.retryConfig.currentRetryAttempt += 1;
-    const backoff2 = config3.retryBackoff ? config3.retryBackoff(err, delay2) : new Promise((resolve2) => {
-      setTimeout(resolve2, delay2);
+    const backoff2 = config3.retryBackoff ? config3.retryBackoff(err, delay2) : new Promise((resolve3) => {
+      setTimeout(resolve3, delay2);
     });
     if (config3.onRetryAttempt) {
       await config3.onRetryAttempt(err);
@@ -10054,8 +10054,8 @@ var require_helpers = __commonJS((exports) => {
   function req(url2, opts = {}) {
     const href = typeof url2 === "string" ? url2 : url2.href;
     const req2 = (href.startsWith("https:") ? https : http).request(url2, opts);
-    const promise2 = new Promise((resolve2, reject) => {
-      req2.once("response", resolve2).once("error", reject).end();
+    const promise2 = new Promise((resolve3, reject) => {
+      req2.once("response", resolve3).once("error", reject).end();
     });
     req2.then = promise2.then.bind(promise2);
     return req2;
@@ -10224,7 +10224,7 @@ var require_parse_proxy_response = __commonJS((exports) => {
   var debug_1 = __importDefault(require_src2());
   var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
   function parseProxyResponse(socket) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       let buffersLength = 0;
       const buffers = [];
       function read() {
@@ -10293,7 +10293,7 @@ var require_parse_proxy_response = __commonJS((exports) => {
         }
         debug("got proxy server response: %o %o", firstLine, headers);
         cleanup();
-        resolve2({
+        resolve3({
           connect: {
             statusCode,
             statusText,
@@ -10527,7 +10527,7 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       return new originalPromise(executor);
     }
     function promiseResolvedWith(value) {
-      return newPromise((resolve2) => resolve2(value));
+      return newPromise((resolve3) => resolve3(value));
     }
     function promiseRejectedWith(reason) {
       return originalPromiseReject(reason);
@@ -10682,8 +10682,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       return new TypeError("Cannot " + name17 + " a stream using a released reader");
     }
     function defaultReaderClosedPromiseInitialize(reader) {
-      reader._closedPromise = newPromise((resolve2, reject) => {
-        reader._closedPromise_resolve = resolve2;
+      reader._closedPromise = newPromise((resolve3, reject) => {
+        reader._closedPromise_resolve = resolve3;
         reader._closedPromise_reject = reject;
       });
     }
@@ -10846,8 +10846,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
         }
         let resolvePromise;
         let rejectPromise;
-        const promise2 = newPromise((resolve2, reject) => {
-          resolvePromise = resolve2;
+        const promise2 = newPromise((resolve3, reject) => {
+          resolvePromise = resolve3;
           rejectPromise = reject;
         });
         const readRequest = {
@@ -10943,8 +10943,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
         const reader = this._reader;
         let resolvePromise;
         let rejectPromise;
-        const promise2 = newPromise((resolve2, reject) => {
-          resolvePromise = resolve2;
+        const promise2 = newPromise((resolve3, reject) => {
+          resolvePromise = resolve3;
           rejectPromise = reject;
         });
         const readRequest = {
@@ -11941,8 +11941,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
         }
         let resolvePromise;
         let rejectPromise;
-        const promise2 = newPromise((resolve2, reject) => {
-          resolvePromise = resolve2;
+        const promise2 = newPromise((resolve3, reject) => {
+          resolvePromise = resolve3;
           rejectPromise = reject;
         });
         const readIntoRequest = {
@@ -12218,10 +12218,10 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
         wasAlreadyErroring = true;
         reason = undefined;
       }
-      const promise2 = newPromise((resolve2, reject) => {
+      const promise2 = newPromise((resolve3, reject) => {
         stream._pendingAbortRequest = {
           _promise: undefined,
-          _resolve: resolve2,
+          _resolve: resolve3,
           _reject: reject,
           _reason: reason,
           _wasAlreadyErroring: wasAlreadyErroring
@@ -12238,9 +12238,9 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       if (state === "closed" || state === "errored") {
         return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
       }
-      const promise2 = newPromise((resolve2, reject) => {
+      const promise2 = newPromise((resolve3, reject) => {
         const closeRequest = {
-          _resolve: resolve2,
+          _resolve: resolve3,
           _reject: reject
         };
         stream._closeRequest = closeRequest;
@@ -12253,9 +12253,9 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       return promise2;
     }
     function WritableStreamAddWriteRequest(stream) {
-      const promise2 = newPromise((resolve2, reject) => {
+      const promise2 = newPromise((resolve3, reject) => {
         const writeRequest = {
-          _resolve: resolve2,
+          _resolve: resolve3,
           _reject: reject
         };
         stream._writeRequests.push(writeRequest);
@@ -12820,8 +12820,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       return new TypeError("Cannot " + name17 + " a stream using a released writer");
     }
     function defaultWriterClosedPromiseInitialize(writer) {
-      writer._closedPromise = newPromise((resolve2, reject) => {
-        writer._closedPromise_resolve = resolve2;
+      writer._closedPromise = newPromise((resolve3, reject) => {
+        writer._closedPromise_resolve = resolve3;
         writer._closedPromise_reject = reject;
         writer._closedPromiseState = "pending";
       });
@@ -12857,8 +12857,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       writer._closedPromiseState = "resolved";
     }
     function defaultWriterReadyPromiseInitialize(writer) {
-      writer._readyPromise = newPromise((resolve2, reject) => {
-        writer._readyPromise_resolve = resolve2;
+      writer._readyPromise = newPromise((resolve3, reject) => {
+        writer._readyPromise_resolve = resolve3;
         writer._readyPromise_reject = reject;
       });
       writer._readyPromiseState = "pending";
@@ -12945,7 +12945,7 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       source._disturbed = true;
       let shuttingDown = false;
       let currentWrite = promiseResolvedWith(undefined);
-      return newPromise((resolve2, reject) => {
+      return newPromise((resolve3, reject) => {
         let abortAlgorithm;
         if (signal !== undefined) {
           abortAlgorithm = () => {
@@ -13090,7 +13090,7 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
           if (isError) {
             reject(error48);
           } else {
-            resolve2(undefined);
+            resolve3(undefined);
           }
           return null;
         }
@@ -13359,8 +13359,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       let branch1;
       let branch2;
       let resolveCancelPromise;
-      const cancelPromise = newPromise((resolve2) => {
-        resolveCancelPromise = resolve2;
+      const cancelPromise = newPromise((resolve3) => {
+        resolveCancelPromise = resolve3;
       });
       function pullAlgorithm() {
         if (reading) {
@@ -13450,8 +13450,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       let branch1;
       let branch2;
       let resolveCancelPromise;
-      const cancelPromise = newPromise((resolve2) => {
-        resolveCancelPromise = resolve2;
+      const cancelPromise = newPromise((resolve3) => {
+        resolveCancelPromise = resolve3;
       });
       function forwardReaderError(thisReader) {
         uponRejection(thisReader._closedPromise, (r) => {
@@ -14196,8 +14196,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
         const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
         const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
         let startPromise_resolve;
-        const startPromise = newPromise((resolve2) => {
-          startPromise_resolve = resolve2;
+        const startPromise = newPromise((resolve3) => {
+          startPromise_resolve = resolve3;
         });
         InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
         SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
@@ -14284,8 +14284,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
       if (stream._backpressureChangePromise !== undefined) {
         stream._backpressureChangePromise_resolve();
       }
-      stream._backpressureChangePromise = newPromise((resolve2) => {
-        stream._backpressureChangePromise_resolve = resolve2;
+      stream._backpressureChangePromise = newPromise((resolve3) => {
+        stream._backpressureChangePromise_resolve = resolve3;
       });
       stream._backpressure = backpressure;
     }
@@ -14443,8 +14443,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
         return controller._finishPromise;
       }
       const readable = stream._readable;
-      controller._finishPromise = newPromise((resolve2, reject) => {
-        controller._finishPromise_resolve = resolve2;
+      controller._finishPromise = newPromise((resolve3, reject) => {
+        controller._finishPromise_resolve = resolve3;
         controller._finishPromise_reject = reject;
       });
       const cancelPromise = controller._cancelAlgorithm(reason);
@@ -14470,8 +14470,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
         return controller._finishPromise;
       }
       const readable = stream._readable;
-      controller._finishPromise = newPromise((resolve2, reject) => {
-        controller._finishPromise_resolve = resolve2;
+      controller._finishPromise = newPromise((resolve3, reject) => {
+        controller._finishPromise_resolve = resolve3;
         controller._finishPromise_reject = reject;
       });
       const flushPromise = controller._flushAlgorithm();
@@ -14501,8 +14501,8 @@ var require_ponyfill_es2018 = __commonJS((exports, module) => {
         return controller._finishPromise;
       }
       const writable = stream._writable;
-      controller._finishPromise = newPromise((resolve2, reject) => {
-        controller._finishPromise_resolve = resolve2;
+      controller._finishPromise = newPromise((resolve3, reject) => {
+        controller._finishPromise_resolve = resolve3;
         controller._finishPromise_reject = reject;
       });
       const cancelPromise = controller._cancelAlgorithm(reason);
@@ -15363,7 +15363,7 @@ var init_multipart_parser = __esm(() => {
 
 // ../../node_modules/node-fetch/src/body.js
 import Stream, { PassThrough } from "node:stream";
-import { types as types3, deprecate, promisify } from "node:util";
+import { types as types4, deprecate, promisify } from "node:util";
 import { Buffer as Buffer4 } from "node:buffer";
 
 class Body {
@@ -15375,7 +15375,7 @@ class Body {
       body = null;
     } else if (isURLSearchParameters(body)) {
       body = Buffer4.from(body.toString());
-    } else if (isBlob(body)) {} else if (Buffer4.isBuffer(body)) {} else if (types3.isAnyArrayBuffer(body)) {
+    } else if (isBlob(body)) {} else if (Buffer4.isBuffer(body)) {} else if (types4.isAnyArrayBuffer(body)) {
       body = Buffer4.from(body);
     } else if (ArrayBuffer.isView(body)) {
       body = Buffer4.from(body.buffer, body.byteOffset, body.byteLength);
@@ -15521,7 +15521,7 @@ var pipeline, INTERNALS, clone2 = (instance, highWaterMark) => {
   if (isBlob(body)) {
     return body.type || null;
   }
-  if (Buffer4.isBuffer(body) || types3.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+  if (Buffer4.isBuffer(body) || types4.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
     return null;
   }
   if (body instanceof FormData2) {
@@ -15578,7 +15578,7 @@ var init_body = __esm(() => {
 });
 
 // ../../node_modules/node-fetch/src/headers.js
-import { types as types4 } from "node:util";
+import { types as types5 } from "node:util";
 import http from "node:http";
 function fromRawHeaders(headers = []) {
   return new Headers2(headers.reduce((result, value, index, array2) => {
@@ -15620,7 +15620,7 @@ var init_headers = __esm(() => {
         for (const [name17, values] of Object.entries(raw)) {
           result.push(...values.map((value) => [name17, value]));
         }
-      } else if (init == null) {} else if (typeof init === "object" && !types4.isBoxedPrimitive(init)) {
+      } else if (init == null) {} else if (typeof init === "object" && !types5.isBoxedPrimitive(init)) {
         const method = init[Symbol.iterator];
         if (method == null) {
           result.push(...Object.entries(init));
@@ -15629,7 +15629,7 @@ var init_headers = __esm(() => {
             throw new TypeError("Header pairs must be iterable");
           }
           result = [...init].map((pair) => {
-            if (typeof pair !== "object" || types4.isBoxedPrimitive(pair)) {
+            if (typeof pair !== "object" || types5.isBoxedPrimitive(pair)) {
               throw new TypeError("Each header pair must be an iterable object");
             }
             return [...pair];
@@ -16224,7 +16224,7 @@ import zlib from "node:zlib";
 import Stream2, { PassThrough as PassThrough2, pipeline as pump } from "node:stream";
 import { Buffer as Buffer5 } from "node:buffer";
 async function fetch2(url2, options_) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const request = new Request(url2, options_);
     const { parsedURL, options } = getNodeRequestOptions(request);
     if (!supportedSchemas.has(parsedURL.protocol)) {
@@ -16233,7 +16233,7 @@ async function fetch2(url2, options_) {
     if (parsedURL.protocol === "data:") {
       const data = dist_default(request.url);
       const response2 = new Response2(data, { headers: { "Content-Type": data.typeFull } });
-      resolve2(response2);
+      resolve3(response2);
       return;
     }
     const send = (parsedURL.protocol === "https:" ? https : http2).request;
@@ -16355,7 +16355,7 @@ async function fetch2(url2, options_) {
             if (responseReferrerPolicy) {
               requestOptions.referrerPolicy = responseReferrerPolicy;
             }
-            resolve2(fetch2(new Request(locationURL, requestOptions)));
+            resolve3(fetch2(new Request(locationURL, requestOptions)));
             finalize2();
             return;
           }
@@ -16388,7 +16388,7 @@ async function fetch2(url2, options_) {
       const codings = headers.get("Content-Encoding");
       if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
         response = new Response2(body, responseOptions);
-        resolve2(response);
+        resolve3(response);
         return;
       }
       const zlibOptions = {
@@ -16402,7 +16402,7 @@ async function fetch2(url2, options_) {
           }
         });
         response = new Response2(body, responseOptions);
-        resolve2(response);
+        resolve3(response);
         return;
       }
       if (codings === "deflate" || codings === "x-deflate") {
@@ -16426,12 +16426,12 @@ async function fetch2(url2, options_) {
             });
           }
           response = new Response2(body, responseOptions);
-          resolve2(response);
+          resolve3(response);
         });
         raw.once("end", () => {
           if (!response) {
             response = new Response2(body, responseOptions);
-            resolve2(response);
+            resolve3(response);
           }
         });
         return;
@@ -16443,11 +16443,11 @@ async function fetch2(url2, options_) {
           }
         });
         response = new Response2(body, responseOptions);
-        resolve2(response);
+        resolve3(response);
         return;
       }
       response = new Response2(body, responseOptions);
-      resolve2(response);
+      resolve3(response);
     });
     writeToStream(request_, request).catch(reject);
   });
@@ -22359,7 +22359,7 @@ var require_jwtaccess = __commonJS((exports) => {
       }
     }
     fromStreamAsync(inputStream) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (!inputStream) {
           reject(new Error("Must pass in a stream containing the service account auth settings."));
         }
@@ -22368,7 +22368,7 @@ var require_jwtaccess = __commonJS((exports) => {
           try {
             const data = JSON.parse(s2);
             this.fromJSON(data);
-            resolve2();
+            resolve3();
           } catch (err) {
             reject(err);
           }
@@ -22554,7 +22554,7 @@ var require_jwtclient = __commonJS((exports) => {
       }
     }
     fromStreamAsync(inputStream) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (!inputStream) {
           throw new Error("Must pass in a stream containing the service account auth settings.");
         }
@@ -22563,7 +22563,7 @@ var require_jwtclient = __commonJS((exports) => {
           try {
             const data = JSON.parse(s2);
             this.fromJSON(data);
-            resolve2();
+            resolve3();
           } catch (e2) {
             reject(e2);
           }
@@ -22663,7 +22663,7 @@ var require_refreshclient = __commonJS((exports) => {
       }
     }
     async fromStreamAsync(inputStream) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (!inputStream) {
           return reject(new Error("Must pass in a stream containing the user refresh token."));
         }
@@ -22672,7 +22672,7 @@ var require_refreshclient = __commonJS((exports) => {
           try {
             const data = JSON.parse(s2);
             this.fromJSON(data);
-            return resolve2();
+            return resolve3();
           } catch (err) {
             return reject(err);
           }
@@ -24028,7 +24028,7 @@ var require_pluggable_auth_handler = __commonJS((exports) => {
       this.outputFile = options.outputFile;
     }
     retrieveResponseFromExecutable(envMap) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         const child = childProcess.spawn(this.commandComponents[0], this.commandComponents.slice(1), {
           env: { ...process.env, ...Object.fromEntries(envMap) }
         });
@@ -24050,7 +24050,7 @@ var require_pluggable_auth_handler = __commonJS((exports) => {
             try {
               const responseJson = JSON.parse(output);
               const response = new executable_response_1.ExecutableResponse(responseJson);
-              return resolve2(response);
+              return resolve3(response);
             } catch (error48) {
               if (error48 instanceof executable_response_1.ExecutableResponseError) {
                 return reject(error48);
@@ -24701,7 +24701,7 @@ var require_googleauth = __commonJS((exports) => {
       }
     }
     fromStreamAsync(inputStream, options) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         if (!inputStream) {
           throw new Error("Must pass in a stream containing the Google auth settings.");
         }
@@ -24711,7 +24711,7 @@ var require_googleauth = __commonJS((exports) => {
             try {
               const data = JSON.parse(chunks.join(""));
               const r2 = this._cacheClientFromJSON(data, options);
-              return resolve2(r2);
+              return resolve3(r2);
             } catch (err) {
               if (!this.keyFilename)
                 throw err;
@@ -24721,7 +24721,7 @@ var require_googleauth = __commonJS((exports) => {
               });
               this.cachedCredential = client;
               this.setGapicJWTValues(client);
-              return resolve2(client);
+              return resolve3(client);
             }
           } catch (err) {
             return reject(err);
@@ -24742,16 +24742,16 @@ var require_googleauth = __commonJS((exports) => {
       return false;
     }
     async getDefaultServiceProjectId() {
-      return new Promise((resolve2) => {
+      return new Promise((resolve3) => {
         (0, child_process_1.exec)("gcloud config config-helper --format json", (err, stdout) => {
           if (!err && stdout) {
             try {
               const projectId = JSON.parse(stdout).configuration.properties.core.project;
-              resolve2(projectId);
+              resolve3(projectId);
               return;
             } catch (e2) {}
           }
-          resolve2(null);
+          resolve3(null);
         });
       });
     }
@@ -35104,6 +35104,2290 @@ var require_mimeScore = __commonJS((exports, module) => {
   };
 });
 
+// ../../node_modules/sql.js/dist/sql-wasm.js
+var require_sql_wasm = __commonJS((exports, module) => {
+  var __dirname = "/Users/xiliangchen/projects/polka-codes/node_modules/sql.js/dist";
+  var initSqlJsPromise = undefined;
+  var initSqlJs = function(moduleConfig) {
+    if (initSqlJsPromise) {
+      return initSqlJsPromise;
+    }
+    initSqlJsPromise = new Promise(function(resolveModule, reject) {
+      var Module = typeof moduleConfig !== "undefined" ? moduleConfig : {};
+      var originalOnAbortFunction = Module["onAbort"];
+      Module["onAbort"] = function(errorThatCausedAbort) {
+        reject(new Error(errorThatCausedAbort));
+        if (originalOnAbortFunction) {
+          originalOnAbortFunction(errorThatCausedAbort);
+        }
+      };
+      Module["postRun"] = Module["postRun"] || [];
+      Module["postRun"].push(function() {
+        resolveModule(Module);
+      });
+      module = undefined;
+      var f3;
+      f3 ||= typeof Module != "undefined" ? Module : {};
+      var aa = typeof window == "object", ba = typeof WorkerGlobalScope != "undefined", ca = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
+      f3.onRuntimeInitialized = function() {
+        function a(g, l) {
+          switch (typeof l) {
+            case "boolean":
+              dc(g, l ? 1 : 0);
+              break;
+            case "number":
+              ec(g, l);
+              break;
+            case "string":
+              fc(g, l, -1, -1);
+              break;
+            case "object":
+              if (l === null)
+                lb(g);
+              else if (l.length != null) {
+                var n = da(l, ea);
+                gc(g, n, l.length, -1);
+                fa(n);
+              } else
+                va(g, "Wrong API use : tried to return a value of an unknown type (" + l + ").", -1);
+              break;
+            default:
+              lb(g);
+          }
+        }
+        function b(g, l) {
+          for (var n = [], r2 = 0;r2 < g; r2 += 1) {
+            var t2 = m2(l + 4 * r2, "i32"), y = hc(t2);
+            if (y === 1 || y === 2)
+              t2 = ic(t2);
+            else if (y === 3)
+              t2 = jc(t2);
+            else if (y === 4) {
+              y = t2;
+              t2 = kc(y);
+              y = lc(y);
+              for (var L = new Uint8Array(t2), J = 0;J < t2; J += 1)
+                L[J] = p[y + J];
+              t2 = L;
+            } else
+              t2 = null;
+            n.push(t2);
+          }
+          return n;
+        }
+        function c(g, l) {
+          this.Qa = g;
+          this.db = l;
+          this.Oa = 1;
+          this.lb = [];
+        }
+        function d(g, l) {
+          this.db = l;
+          l = ha(g) + 1;
+          this.eb = ia(l);
+          if (this.eb === null)
+            throw Error("Unable to allocate memory for the SQL string");
+          u(g, x2, this.eb, l);
+          this.kb = this.eb;
+          this.Za = this.pb = null;
+        }
+        function e2(g) {
+          this.filename = "dbfile_" + (4294967295 * Math.random() >>> 0);
+          if (g != null) {
+            var l = this.filename, n = "/", r2 = l;
+            n && (n = typeof n == "string" ? n : ja(n), r2 = l ? ka(n + "/" + l) : n);
+            l = la(true, true);
+            r2 = ma(r2, l);
+            if (g) {
+              if (typeof g == "string") {
+                n = Array(g.length);
+                for (var t2 = 0, y = g.length;t2 < y; ++t2)
+                  n[t2] = g.charCodeAt(t2);
+                g = n;
+              }
+              na(r2, l | 146);
+              n = oa(r2, 577);
+              pa(n, g, 0, g.length, 0);
+              qa(n);
+              na(r2, l);
+            }
+          }
+          this.handleError(q(this.filename, h2));
+          this.db = m2(h2, "i32");
+          ob(this.db);
+          this.fb = {};
+          this.Sa = {};
+        }
+        var h2 = z2(4), k = f3.cwrap, q = k("sqlite3_open", "number", ["string", "number"]), w = k("sqlite3_close_v2", "number", ["number"]), v = k("sqlite3_exec", "number", ["number", "string", "number", "number", "number"]), C = k("sqlite3_changes", "number", ["number"]), G = k("sqlite3_prepare_v2", "number", ["number", "string", "number", "number", "number"]), pb = k("sqlite3_sql", "string", ["number"]), nc = k("sqlite3_normalized_sql", "string", ["number"]), qb = k("sqlite3_prepare_v2", "number", ["number", "number", "number", "number", "number"]), oc = k("sqlite3_bind_text", "number", ["number", "number", "number", "number", "number"]), rb = k("sqlite3_bind_blob", "number", ["number", "number", "number", "number", "number"]), pc = k("sqlite3_bind_double", "number", ["number", "number", "number"]), qc = k("sqlite3_bind_int", "number", ["number", "number", "number"]), rc = k("sqlite3_bind_parameter_index", "number", ["number", "string"]), sc = k("sqlite3_step", "number", ["number"]), tc = k("sqlite3_errmsg", "string", ["number"]), uc = k("sqlite3_column_count", "number", ["number"]), vc = k("sqlite3_data_count", "number", ["number"]), wc = k("sqlite3_column_double", "number", ["number", "number"]), sb = k("sqlite3_column_text", "string", ["number", "number"]), xc = k("sqlite3_column_blob", "number", ["number", "number"]), yc = k("sqlite3_column_bytes", "number", [
+          "number",
+          "number"
+        ]), zc = k("sqlite3_column_type", "number", ["number", "number"]), Ac = k("sqlite3_column_name", "string", ["number", "number"]), Bc = k("sqlite3_reset", "number", ["number"]), Cc = k("sqlite3_clear_bindings", "number", ["number"]), Dc = k("sqlite3_finalize", "number", ["number"]), tb = k("sqlite3_create_function_v2", "number", "number string number number number number number number number".split(" ")), hc = k("sqlite3_value_type", "number", ["number"]), kc = k("sqlite3_value_bytes", "number", ["number"]), jc = k("sqlite3_value_text", "string", ["number"]), lc = k("sqlite3_value_blob", "number", ["number"]), ic = k("sqlite3_value_double", "number", ["number"]), ec = k("sqlite3_result_double", "", ["number", "number"]), lb = k("sqlite3_result_null", "", ["number"]), fc = k("sqlite3_result_text", "", ["number", "string", "number", "number"]), gc = k("sqlite3_result_blob", "", ["number", "number", "number", "number"]), dc = k("sqlite3_result_int", "", ["number", "number"]), va = k("sqlite3_result_error", "", ["number", "string", "number"]), ub = k("sqlite3_aggregate_context", "number", ["number", "number"]), ob = k("RegisterExtensionFunctions", "number", ["number"]), vb = k("sqlite3_update_hook", "number", ["number", "number", "number"]);
+        c.prototype.bind = function(g) {
+          if (!this.Qa)
+            throw "Statement closed";
+          this.reset();
+          return Array.isArray(g) ? this.Cb(g) : g != null && typeof g === "object" ? this.Db(g) : true;
+        };
+        c.prototype.step = function() {
+          if (!this.Qa)
+            throw "Statement closed";
+          this.Oa = 1;
+          var g = sc(this.Qa);
+          switch (g) {
+            case 100:
+              return true;
+            case 101:
+              return false;
+            default:
+              throw this.db.handleError(g);
+          }
+        };
+        c.prototype.wb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          return wc(this.Qa, g);
+        };
+        c.prototype.Gb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          g = sb(this.Qa, g);
+          if (typeof BigInt !== "function")
+            throw Error("BigInt is not supported");
+          return BigInt(g);
+        };
+        c.prototype.Hb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          return sb(this.Qa, g);
+        };
+        c.prototype.getBlob = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          var l = yc(this.Qa, g);
+          g = xc(this.Qa, g);
+          for (var n = new Uint8Array(l), r2 = 0;r2 < l; r2 += 1)
+            n[r2] = p[g + r2];
+          return n;
+        };
+        c.prototype.get = function(g, l) {
+          l = l || {};
+          g != null && this.bind(g) && this.step();
+          g = [];
+          for (var n = vc(this.Qa), r2 = 0;r2 < n; r2 += 1)
+            switch (zc(this.Qa, r2)) {
+              case 1:
+                var t2 = l.useBigInt ? this.Gb(r2) : this.wb(r2);
+                g.push(t2);
+                break;
+              case 2:
+                g.push(this.wb(r2));
+                break;
+              case 3:
+                g.push(this.Hb(r2));
+                break;
+              case 4:
+                g.push(this.getBlob(r2));
+                break;
+              default:
+                g.push(null);
+            }
+          return g;
+        };
+        c.prototype.getColumnNames = function() {
+          for (var g = [], l = uc(this.Qa), n = 0;n < l; n += 1)
+            g.push(Ac(this.Qa, n));
+          return g;
+        };
+        c.prototype.getAsObject = function(g, l) {
+          g = this.get(g, l);
+          l = this.getColumnNames();
+          for (var n = {}, r2 = 0;r2 < l.length; r2 += 1)
+            n[l[r2]] = g[r2];
+          return n;
+        };
+        c.prototype.getSQL = function() {
+          return pb(this.Qa);
+        };
+        c.prototype.getNormalizedSQL = function() {
+          return nc(this.Qa);
+        };
+        c.prototype.run = function(g) {
+          g != null && this.bind(g);
+          this.step();
+          return this.reset();
+        };
+        c.prototype.sb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          g = ra(g);
+          var n = da(g, ea);
+          this.lb.push(n);
+          this.db.handleError(oc(this.Qa, l, n, g.length - 1, 0));
+        };
+        c.prototype.Bb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          var n = da(g, ea);
+          this.lb.push(n);
+          this.db.handleError(rb(this.Qa, l, n, g.length, 0));
+        };
+        c.prototype.rb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          this.db.handleError((g === (g | 0) ? qc : pc)(this.Qa, l, g));
+        };
+        c.prototype.Eb = function(g) {
+          g == null && (g = this.Oa, this.Oa += 1);
+          rb(this.Qa, g, 0, 0, 0);
+        };
+        c.prototype.tb = function(g, l) {
+          l == null && (l = this.Oa, this.Oa += 1);
+          switch (typeof g) {
+            case "string":
+              this.sb(g, l);
+              return;
+            case "number":
+              this.rb(g, l);
+              return;
+            case "bigint":
+              this.sb(g.toString(), l);
+              return;
+            case "boolean":
+              this.rb(g + 0, l);
+              return;
+            case "object":
+              if (g === null) {
+                this.Eb(l);
+                return;
+              }
+              if (g.length != null) {
+                this.Bb(g, l);
+                return;
+              }
+          }
+          throw "Wrong API use : tried to bind a value of an unknown type (" + g + ").";
+        };
+        c.prototype.Db = function(g) {
+          var l = this;
+          Object.keys(g).forEach(function(n) {
+            var r2 = rc(l.Qa, n);
+            r2 !== 0 && l.tb(g[n], r2);
+          });
+          return true;
+        };
+        c.prototype.Cb = function(g) {
+          for (var l = 0;l < g.length; l += 1)
+            this.tb(g[l], l + 1);
+          return true;
+        };
+        c.prototype.reset = function() {
+          this.freemem();
+          return Cc(this.Qa) === 0 && Bc(this.Qa) === 0;
+        };
+        c.prototype.freemem = function() {
+          for (var g;(g = this.lb.pop()) !== undefined; )
+            fa(g);
+        };
+        c.prototype.free = function() {
+          this.freemem();
+          var g = Dc(this.Qa) === 0;
+          delete this.db.fb[this.Qa];
+          this.Qa = 0;
+          return g;
+        };
+        d.prototype.next = function() {
+          if (this.eb === null)
+            return { done: true };
+          this.Za !== null && (this.Za.free(), this.Za = null);
+          if (!this.db.db)
+            throw this.mb(), Error("Database closed");
+          var g = sa(), l = z2(4);
+          ta(h2);
+          ta(l);
+          try {
+            this.db.handleError(qb(this.db.db, this.kb, -1, h2, l));
+            this.kb = m2(l, "i32");
+            var n = m2(h2, "i32");
+            if (n === 0)
+              return this.mb(), { done: true };
+            this.Za = new c(n, this.db);
+            this.db.fb[n] = this.Za;
+            return { value: this.Za, done: false };
+          } catch (r2) {
+            throw this.pb = ua(this.kb), this.mb(), r2;
+          } finally {
+            wa(g);
+          }
+        };
+        d.prototype.mb = function() {
+          fa(this.eb);
+          this.eb = null;
+        };
+        d.prototype.getRemainingSQL = function() {
+          return this.pb !== null ? this.pb : ua(this.kb);
+        };
+        typeof Symbol === "function" && typeof Symbol.iterator === "symbol" && (d.prototype[Symbol.iterator] = function() {
+          return this;
+        });
+        e2.prototype.run = function(g, l) {
+          if (!this.db)
+            throw "Database closed";
+          if (l) {
+            g = this.prepare(g, l);
+            try {
+              g.step();
+            } finally {
+              g.free();
+            }
+          } else
+            this.handleError(v(this.db, g, 0, 0, h2));
+          return this;
+        };
+        e2.prototype.exec = function(g, l, n) {
+          if (!this.db)
+            throw "Database closed";
+          var r2 = sa(), t2 = null;
+          try {
+            var y = xa(g), L = z2(4);
+            for (g = [];m2(y, "i8") !== 0; ) {
+              ta(h2);
+              ta(L);
+              this.handleError(qb(this.db, y, -1, h2, L));
+              var J = m2(h2, "i32");
+              y = m2(L, "i32");
+              if (J !== 0) {
+                var I = null;
+                t2 = new c(J, this);
+                for (l != null && t2.bind(l);t2.step(); )
+                  I === null && (I = { columns: t2.getColumnNames(), values: [] }, g.push(I)), I.values.push(t2.get(null, n));
+                t2.free();
+              }
+            }
+            return g;
+          } catch (M) {
+            throw t2 && t2.free(), M;
+          } finally {
+            wa(r2);
+          }
+        };
+        e2.prototype.each = function(g, l, n, r2, t2) {
+          typeof l === "function" && (r2 = n, n = l, l = undefined);
+          g = this.prepare(g, l);
+          try {
+            for (;g.step(); )
+              n(g.getAsObject(null, t2));
+          } finally {
+            g.free();
+          }
+          if (typeof r2 === "function")
+            return r2();
+        };
+        e2.prototype.prepare = function(g, l) {
+          ta(h2);
+          this.handleError(G(this.db, g, -1, h2, 0));
+          g = m2(h2, "i32");
+          if (g === 0)
+            throw "Nothing to prepare";
+          var n = new c(g, this);
+          l != null && n.bind(l);
+          return this.fb[g] = n;
+        };
+        e2.prototype.iterateStatements = function(g) {
+          return new d(g, this);
+        };
+        e2.prototype["export"] = function() {
+          Object.values(this.fb).forEach(function(l) {
+            l.free();
+          });
+          Object.values(this.Sa).forEach(A2);
+          this.Sa = {};
+          this.handleError(w(this.db));
+          var g = ya(this.filename);
+          this.handleError(q(this.filename, h2));
+          this.db = m2(h2, "i32");
+          ob(this.db);
+          return g;
+        };
+        e2.prototype.close = function() {
+          this.db !== null && (Object.values(this.fb).forEach(function(g) {
+            g.free();
+          }), Object.values(this.Sa).forEach(A2), this.Sa = {}, this.Ya && (A2(this.Ya), this.Ya = undefined), this.handleError(w(this.db)), za("/" + this.filename), this.db = null);
+        };
+        e2.prototype.handleError = function(g) {
+          if (g === 0)
+            return null;
+          g = tc(this.db);
+          throw Error(g);
+        };
+        e2.prototype.getRowsModified = function() {
+          return C(this.db);
+        };
+        e2.prototype.create_function = function(g, l) {
+          Object.prototype.hasOwnProperty.call(this.Sa, g) && (A2(this.Sa[g]), delete this.Sa[g]);
+          var n = Aa(function(r2, t2, y) {
+            t2 = b(t2, y);
+            try {
+              var L = l.apply(null, t2);
+            } catch (J) {
+              va(r2, J, -1);
+              return;
+            }
+            a(r2, L);
+          }, "viii");
+          this.Sa[g] = n;
+          this.handleError(tb(this.db, g, l.length, 1, 0, n, 0, 0, 0));
+          return this;
+        };
+        e2.prototype.create_aggregate = function(g, l) {
+          var n = l.init || function() {
+            return null;
+          }, r2 = l.finalize || function(I) {
+            return I;
+          }, t2 = l.step;
+          if (!t2)
+            throw "An aggregate function must have a step function in " + g;
+          var y = {};
+          Object.hasOwnProperty.call(this.Sa, g) && (A2(this.Sa[g]), delete this.Sa[g]);
+          l = g + "__finalize";
+          Object.hasOwnProperty.call(this.Sa, l) && (A2(this.Sa[l]), delete this.Sa[l]);
+          var L = Aa(function(I, M, Ra) {
+            var X = ub(I, 1);
+            Object.hasOwnProperty.call(y, X) || (y[X] = n());
+            M = b(M, Ra);
+            M = [y[X]].concat(M);
+            try {
+              y[X] = t2.apply(null, M);
+            } catch (Fc) {
+              delete y[X], va(I, Fc, -1);
+            }
+          }, "viii"), J = Aa(function(I) {
+            var M = ub(I, 1);
+            try {
+              var Ra = r2(y[M]);
+            } catch (X) {
+              delete y[M];
+              va(I, X, -1);
+              return;
+            }
+            a(I, Ra);
+            delete y[M];
+          }, "vi");
+          this.Sa[g] = L;
+          this.Sa[l] = J;
+          this.handleError(tb(this.db, g, t2.length - 1, 1, 0, 0, L, J, 0));
+          return this;
+        };
+        e2.prototype.updateHook = function(g) {
+          this.Ya && (vb(this.db, 0, 0), A2(this.Ya), this.Ya = undefined);
+          g && (this.Ya = Aa(function(l, n, r2, t2, y) {
+            switch (n) {
+              case 18:
+                l = "insert";
+                break;
+              case 23:
+                l = "update";
+                break;
+              case 9:
+                l = "delete";
+                break;
+              default:
+                throw "unknown operationCode in updateHook callback: " + n;
+            }
+            r2 = r2 ? B(x2, r2) : "";
+            t2 = t2 ? B(x2, t2) : "";
+            if (y > Number.MAX_SAFE_INTEGER)
+              throw "rowId too big to fit inside a Number";
+            g(l, r2, t2, Number(y));
+          }, "viiiij"), vb(this.db, this.Ya, 0));
+        };
+        f3.Database = e2;
+      };
+      var Ba = { ...f3 }, Ca = "./this.program", Da = (a, b) => {
+        throw b;
+      }, D = "", Ea, Fa;
+      if (ca) {
+        var fs4 = __require("fs");
+        __require("path");
+        D = __dirname + "/";
+        Fa = (a) => {
+          a = Ga(a) ? new URL(a) : a;
+          return fs4.readFileSync(a);
+        };
+        Ea = async (a) => {
+          a = Ga(a) ? new URL(a) : a;
+          return fs4.readFileSync(a, undefined);
+        };
+        !f3.thisProgram && 1 < process.argv.length && (Ca = process.argv[1].replace(/\\/g, "/"));
+        process.argv.slice(2);
+        typeof module != "undefined" && (module.exports = f3);
+        Da = (a, b) => {
+          process.exitCode = a;
+          throw b;
+        };
+      } else if (aa || ba)
+        ba ? D = self.location.href : typeof document != "undefined" && document.currentScript && (D = document.currentScript.src), D = D.startsWith("blob:") ? "" : D.slice(0, D.replace(/[?#].*/, "").lastIndexOf("/") + 1), ba && (Fa = (a) => {
+          var b = new XMLHttpRequest;
+          b.open("GET", a, false);
+          b.responseType = "arraybuffer";
+          b.send(null);
+          return new Uint8Array(b.response);
+        }), Ea = async (a) => {
+          if (Ga(a))
+            return new Promise((c, d) => {
+              var e2 = new XMLHttpRequest;
+              e2.open("GET", a, true);
+              e2.responseType = "arraybuffer";
+              e2.onload = () => {
+                e2.status == 200 || e2.status == 0 && e2.response ? c(e2.response) : d(e2.status);
+              };
+              e2.onerror = d;
+              e2.send(null);
+            });
+          var b = await fetch(a, { credentials: "same-origin" });
+          if (b.ok)
+            return b.arrayBuffer();
+          throw Error(b.status + " : " + b.url);
+        };
+      var Ha = f3.print || console.log.bind(console), Ia = f3.printErr || console.error.bind(console);
+      Object.assign(f3, Ba);
+      Ba = null;
+      f3.thisProgram && (Ca = f3.thisProgram);
+      var Ja = f3.wasmBinary, Ka, La = false, Ma, p, x2, Na, E, F2, Oa, H, Pa, Ga = (a) => a.startsWith("file://");
+      function Qa() {
+        var a = Ka.buffer;
+        f3.HEAP8 = p = new Int8Array(a);
+        f3.HEAP16 = Na = new Int16Array(a);
+        f3.HEAPU8 = x2 = new Uint8Array(a);
+        f3.HEAPU16 = new Uint16Array(a);
+        f3.HEAP32 = E = new Int32Array(a);
+        f3.HEAPU32 = F2 = new Uint32Array(a);
+        f3.HEAPF32 = Oa = new Float32Array(a);
+        f3.HEAPF64 = Pa = new Float64Array(a);
+        f3.HEAP64 = H = new BigInt64Array(a);
+        f3.HEAPU64 = new BigUint64Array(a);
+      }
+      var K = 0, Sa = null;
+      function Ta(a) {
+        f3.onAbort?.(a);
+        a = "Aborted(" + a + ")";
+        Ia(a);
+        La = true;
+        throw new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");
+      }
+      var Ua;
+      async function Va(a) {
+        if (!Ja)
+          try {
+            var b = await Ea(a);
+            return new Uint8Array(b);
+          } catch {}
+        if (a == Ua && Ja)
+          a = new Uint8Array(Ja);
+        else if (Fa)
+          a = Fa(a);
+        else
+          throw "both async and sync fetching of the wasm failed";
+        return a;
+      }
+      async function Wa(a, b) {
+        try {
+          var c = await Va(a);
+          return await WebAssembly.instantiate(c, b);
+        } catch (d) {
+          Ia(`failed to asynchronously prepare wasm: ${d}`), Ta(d);
+        }
+      }
+      async function Xa(a) {
+        var b = Ua;
+        if (!Ja && typeof WebAssembly.instantiateStreaming == "function" && !Ga(b) && !ca)
+          try {
+            var c = fetch(b, { credentials: "same-origin" });
+            return await WebAssembly.instantiateStreaming(c, a);
+          } catch (d) {
+            Ia(`wasm streaming compile failed: ${d}`), Ia("falling back to ArrayBuffer instantiation");
+          }
+        return Wa(b, a);
+      }
+
+      class Ya {
+        name = "ExitStatus";
+        constructor(a) {
+          this.message = `Program terminated with exit(${a})`;
+          this.status = a;
+        }
+      }
+      var Za = (a) => {
+        for (;0 < a.length; )
+          a.shift()(f3);
+      }, $a = [], ab = [], bb = () => {
+        var a = f3.preRun.shift();
+        ab.unshift(a);
+      };
+      function m2(a, b = "i8") {
+        b.endsWith("*") && (b = "*");
+        switch (b) {
+          case "i1":
+            return p[a];
+          case "i8":
+            return p[a];
+          case "i16":
+            return Na[a >> 1];
+          case "i32":
+            return E[a >> 2];
+          case "i64":
+            return H[a >> 3];
+          case "float":
+            return Oa[a >> 2];
+          case "double":
+            return Pa[a >> 3];
+          case "*":
+            return F2[a >> 2];
+          default:
+            Ta(`invalid type for getValue: ${b}`);
+        }
+      }
+      var cb = f3.noExitRuntime || true;
+      function ta(a) {
+        var b = "i32";
+        b.endsWith("*") && (b = "*");
+        switch (b) {
+          case "i1":
+            p[a] = 0;
+            break;
+          case "i8":
+            p[a] = 0;
+            break;
+          case "i16":
+            Na[a >> 1] = 0;
+            break;
+          case "i32":
+            E[a >> 2] = 0;
+            break;
+          case "i64":
+            H[a >> 3] = BigInt(0);
+            break;
+          case "float":
+            Oa[a >> 2] = 0;
+            break;
+          case "double":
+            Pa[a >> 3] = 0;
+            break;
+          case "*":
+            F2[a >> 2] = 0;
+            break;
+          default:
+            Ta(`invalid type for setValue: ${b}`);
+        }
+      }
+      var db2 = typeof TextDecoder != "undefined" ? new TextDecoder : undefined, B = (a, b = 0, c = NaN) => {
+        var d = b + c;
+        for (c = b;a[c] && !(c >= d); )
+          ++c;
+        if (16 < c - b && a.buffer && db2)
+          return db2.decode(a.subarray(b, c));
+        for (d = "";b < c; ) {
+          var e2 = a[b++];
+          if (e2 & 128) {
+            var h2 = a[b++] & 63;
+            if ((e2 & 224) == 192)
+              d += String.fromCharCode((e2 & 31) << 6 | h2);
+            else {
+              var k = a[b++] & 63;
+              e2 = (e2 & 240) == 224 ? (e2 & 15) << 12 | h2 << 6 | k : (e2 & 7) << 18 | h2 << 12 | k << 6 | a[b++] & 63;
+              65536 > e2 ? d += String.fromCharCode(e2) : (e2 -= 65536, d += String.fromCharCode(55296 | e2 >> 10, 56320 | e2 & 1023));
+            }
+          } else
+            d += String.fromCharCode(e2);
+        }
+        return d;
+      }, ua = (a, b) => a ? B(x2, a, b) : "", eb = (a, b) => {
+        for (var c = 0, d = a.length - 1;0 <= d; d--) {
+          var e2 = a[d];
+          e2 === "." ? a.splice(d, 1) : e2 === ".." ? (a.splice(d, 1), c++) : c && (a.splice(d, 1), c--);
+        }
+        if (b)
+          for (;c; c--)
+            a.unshift("..");
+        return a;
+      }, ka = (a) => {
+        var b = a.charAt(0) === "/", c = a.slice(-1) === "/";
+        (a = eb(a.split("/").filter((d) => !!d), !b).join("/")) || b || (a = ".");
+        a && c && (a += "/");
+        return (b ? "/" : "") + a;
+      }, fb = (a) => {
+        var b = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(a).slice(1);
+        a = b[0];
+        b = b[1];
+        if (!a && !b)
+          return ".";
+        b &&= b.slice(0, -1);
+        return a + b;
+      }, gb = (a) => a && a.match(/([^\/]+|\/)\/*$/)[1], hb = () => {
+        if (ca) {
+          var a = __require("crypto");
+          return (b) => a.randomFillSync(b);
+        }
+        return (b) => crypto.getRandomValues(b);
+      }, ib = (a) => {
+        (ib = hb())(a);
+      }, jb = (...a) => {
+        for (var b = "", c = false, d = a.length - 1;-1 <= d && !c; d--) {
+          c = 0 <= d ? a[d] : "/";
+          if (typeof c != "string")
+            throw new TypeError("Arguments to path.resolve must be strings");
+          if (!c)
+            return "";
+          b = c + "/" + b;
+          c = c.charAt(0) === "/";
+        }
+        b = eb(b.split("/").filter((e2) => !!e2), !c).join("/");
+        return (c ? "/" : "") + b || ".";
+      }, kb = [], ha = (a) => {
+        for (var b = 0, c = 0;c < a.length; ++c) {
+          var d = a.charCodeAt(c);
+          127 >= d ? b++ : 2047 >= d ? b += 2 : 55296 <= d && 57343 >= d ? (b += 4, ++c) : b += 3;
+        }
+        return b;
+      }, u = (a, b, c, d) => {
+        if (!(0 < d))
+          return 0;
+        var e2 = c;
+        d = c + d - 1;
+        for (var h2 = 0;h2 < a.length; ++h2) {
+          var k = a.charCodeAt(h2);
+          if (55296 <= k && 57343 >= k) {
+            var q = a.charCodeAt(++h2);
+            k = 65536 + ((k & 1023) << 10) | q & 1023;
+          }
+          if (127 >= k) {
+            if (c >= d)
+              break;
+            b[c++] = k;
+          } else {
+            if (2047 >= k) {
+              if (c + 1 >= d)
+                break;
+              b[c++] = 192 | k >> 6;
+            } else {
+              if (65535 >= k) {
+                if (c + 2 >= d)
+                  break;
+                b[c++] = 224 | k >> 12;
+              } else {
+                if (c + 3 >= d)
+                  break;
+                b[c++] = 240 | k >> 18;
+                b[c++] = 128 | k >> 12 & 63;
+              }
+              b[c++] = 128 | k >> 6 & 63;
+            }
+            b[c++] = 128 | k & 63;
+          }
+        }
+        b[c] = 0;
+        return c - e2;
+      }, ra = (a, b) => {
+        var c = Array(ha(a) + 1);
+        a = u(a, c, 0, c.length);
+        b && (c.length = a);
+        return c;
+      }, mb = [];
+      function nb(a, b) {
+        mb[a] = { input: [], output: [], cb: b };
+        wb(a, xb);
+      }
+      var xb = { open(a) {
+        var b = mb[a.node.rdev];
+        if (!b)
+          throw new N(43);
+        a.tty = b;
+        a.seekable = false;
+      }, close(a) {
+        a.tty.cb.fsync(a.tty);
+      }, fsync(a) {
+        a.tty.cb.fsync(a.tty);
+      }, read(a, b, c, d) {
+        if (!a.tty || !a.tty.cb.xb)
+          throw new N(60);
+        for (var e2 = 0, h2 = 0;h2 < d; h2++) {
+          try {
+            var k = a.tty.cb.xb(a.tty);
+          } catch (q) {
+            throw new N(29);
+          }
+          if (k === undefined && e2 === 0)
+            throw new N(6);
+          if (k === null || k === undefined)
+            break;
+          e2++;
+          b[c + h2] = k;
+        }
+        e2 && (a.node.atime = Date.now());
+        return e2;
+      }, write(a, b, c, d) {
+        if (!a.tty || !a.tty.cb.qb)
+          throw new N(60);
+        try {
+          for (var e2 = 0;e2 < d; e2++)
+            a.tty.cb.qb(a.tty, b[c + e2]);
+        } catch (h2) {
+          throw new N(29);
+        }
+        d && (a.node.mtime = a.node.ctime = Date.now());
+        return e2;
+      } }, yb = { xb() {
+        a: {
+          if (!kb.length) {
+            var a = null;
+            if (ca) {
+              var b = Buffer.alloc(256), c = 0, d = process.stdin.fd;
+              try {
+                c = fs4.readSync(d, b, 0, 256);
+              } catch (e2) {
+                if (e2.toString().includes("EOF"))
+                  c = 0;
+                else
+                  throw e2;
+              }
+              0 < c && (a = b.slice(0, c).toString("utf-8"));
+            } else
+              typeof window != "undefined" && typeof window.prompt == "function" && (a = window.prompt("Input: "), a !== null && (a += `
+`));
+            if (!a) {
+              a = null;
+              break a;
+            }
+            kb = ra(a, true);
+          }
+          a = kb.shift();
+        }
+        return a;
+      }, qb(a, b) {
+        b === null || b === 10 ? (Ha(B(a.output)), a.output = []) : b != 0 && a.output.push(b);
+      }, fsync(a) {
+        0 < a.output?.length && (Ha(B(a.output)), a.output = []);
+      }, Tb() {
+        return { Ob: 25856, Qb: 5, Nb: 191, Pb: 35387, Mb: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
+      }, Ub() {
+        return 0;
+      }, Vb() {
+        return [24, 80];
+      } }, zb = { qb(a, b) {
+        b === null || b === 10 ? (Ia(B(a.output)), a.output = []) : b != 0 && a.output.push(b);
+      }, fsync(a) {
+        0 < a.output?.length && (Ia(B(a.output)), a.output = []);
+      } }, O = { Wa: null, Xa() {
+        return O.createNode(null, "/", 16895, 0);
+      }, createNode(a, b, c, d) {
+        if ((c & 61440) === 24576 || (c & 61440) === 4096)
+          throw new N(63);
+        O.Wa || (O.Wa = { dir: { node: { Ta: O.La.Ta, Ua: O.La.Ua, lookup: O.La.lookup, hb: O.La.hb, rename: O.La.rename, unlink: O.La.unlink, rmdir: O.La.rmdir, readdir: O.La.readdir, symlink: O.La.symlink }, stream: { Va: O.Ma.Va } }, file: { node: { Ta: O.La.Ta, Ua: O.La.Ua }, stream: { Va: O.Ma.Va, read: O.Ma.read, write: O.Ma.write, ib: O.Ma.ib, jb: O.Ma.jb } }, link: { node: { Ta: O.La.Ta, Ua: O.La.Ua, readlink: O.La.readlink }, stream: {} }, ub: { node: { Ta: O.La.Ta, Ua: O.La.Ua }, stream: Ab } });
+        c = Bb(a, b, c, d);
+        P(c.mode) ? (c.La = O.Wa.dir.node, c.Ma = O.Wa.dir.stream, c.Na = {}) : (c.mode & 61440) === 32768 ? (c.La = O.Wa.file.node, c.Ma = O.Wa.file.stream, c.Ra = 0, c.Na = null) : (c.mode & 61440) === 40960 ? (c.La = O.Wa.link.node, c.Ma = O.Wa.link.stream) : (c.mode & 61440) === 8192 && (c.La = O.Wa.ub.node, c.Ma = O.Wa.ub.stream);
+        c.atime = c.mtime = c.ctime = Date.now();
+        a && (a.Na[b] = c, a.atime = a.mtime = a.ctime = c.atime);
+        return c;
+      }, Sb(a) {
+        return a.Na ? a.Na.subarray ? a.Na.subarray(0, a.Ra) : new Uint8Array(a.Na) : new Uint8Array(0);
+      }, La: { Ta(a) {
+        var b = {};
+        b.dev = (a.mode & 61440) === 8192 ? a.id : 1;
+        b.ino = a.id;
+        b.mode = a.mode;
+        b.nlink = 1;
+        b.uid = 0;
+        b.gid = 0;
+        b.rdev = a.rdev;
+        P(a.mode) ? b.size = 4096 : (a.mode & 61440) === 32768 ? b.size = a.Ra : (a.mode & 61440) === 40960 ? b.size = a.link.length : b.size = 0;
+        b.atime = new Date(a.atime);
+        b.mtime = new Date(a.mtime);
+        b.ctime = new Date(a.ctime);
+        b.blksize = 4096;
+        b.blocks = Math.ceil(b.size / b.blksize);
+        return b;
+      }, Ua(a, b) {
+        for (var c of ["mode", "atime", "mtime", "ctime"])
+          b[c] != null && (a[c] = b[c]);
+        b.size !== undefined && (b = b.size, a.Ra != b && (b == 0 ? (a.Na = null, a.Ra = 0) : (c = a.Na, a.Na = new Uint8Array(b), c && a.Na.set(c.subarray(0, Math.min(b, a.Ra))), a.Ra = b)));
+      }, lookup() {
+        throw O.vb;
+      }, hb(a, b, c, d) {
+        return O.createNode(a, b, c, d);
+      }, rename(a, b, c) {
+        try {
+          var d = Q(b, c);
+        } catch (h2) {}
+        if (d) {
+          if (P(a.mode))
+            for (var e2 in d.Na)
+              throw new N(55);
+          Cb(d);
+        }
+        delete a.parent.Na[a.name];
+        b.Na[c] = a;
+        a.name = c;
+        b.ctime = b.mtime = a.parent.ctime = a.parent.mtime = Date.now();
+      }, unlink(a, b) {
+        delete a.Na[b];
+        a.ctime = a.mtime = Date.now();
+      }, rmdir(a, b) {
+        var c = Q(a, b), d;
+        for (d in c.Na)
+          throw new N(55);
+        delete a.Na[b];
+        a.ctime = a.mtime = Date.now();
+      }, readdir(a) {
+        return [".", "..", ...Object.keys(a.Na)];
+      }, symlink(a, b, c) {
+        a = O.createNode(a, b, 41471, 0);
+        a.link = c;
+        return a;
+      }, readlink(a) {
+        if ((a.mode & 61440) !== 40960)
+          throw new N(28);
+        return a.link;
+      } }, Ma: { read(a, b, c, d, e2) {
+        var h2 = a.node.Na;
+        if (e2 >= a.node.Ra)
+          return 0;
+        a = Math.min(a.node.Ra - e2, d);
+        if (8 < a && h2.subarray)
+          b.set(h2.subarray(e2, e2 + a), c);
+        else
+          for (d = 0;d < a; d++)
+            b[c + d] = h2[e2 + d];
+        return a;
+      }, write(a, b, c, d, e2, h2) {
+        b.buffer === p.buffer && (h2 = false);
+        if (!d)
+          return 0;
+        a = a.node;
+        a.mtime = a.ctime = Date.now();
+        if (b.subarray && (!a.Na || a.Na.subarray)) {
+          if (h2)
+            return a.Na = b.subarray(c, c + d), a.Ra = d;
+          if (a.Ra === 0 && e2 === 0)
+            return a.Na = b.slice(c, c + d), a.Ra = d;
+          if (e2 + d <= a.Ra)
+            return a.Na.set(b.subarray(c, c + d), e2), d;
+        }
+        h2 = e2 + d;
+        var k = a.Na ? a.Na.length : 0;
+        k >= h2 || (h2 = Math.max(h2, k * (1048576 > k ? 2 : 1.125) >>> 0), k != 0 && (h2 = Math.max(h2, 256)), k = a.Na, a.Na = new Uint8Array(h2), 0 < a.Ra && a.Na.set(k.subarray(0, a.Ra), 0));
+        if (a.Na.subarray && b.subarray)
+          a.Na.set(b.subarray(c, c + d), e2);
+        else
+          for (h2 = 0;h2 < d; h2++)
+            a.Na[e2 + h2] = b[c + h2];
+        a.Ra = Math.max(a.Ra, e2 + d);
+        return d;
+      }, Va(a, b, c) {
+        c === 1 ? b += a.position : c === 2 && (a.node.mode & 61440) === 32768 && (b += a.node.Ra);
+        if (0 > b)
+          throw new N(28);
+        return b;
+      }, ib(a, b, c, d, e2) {
+        if ((a.node.mode & 61440) !== 32768)
+          throw new N(43);
+        a = a.node.Na;
+        if (e2 & 2 || !a || a.buffer !== p.buffer) {
+          e2 = true;
+          d = 65536 * Math.ceil(b / 65536);
+          var h2 = Db(65536, d);
+          h2 && x2.fill(0, h2, h2 + d);
+          d = h2;
+          if (!d)
+            throw new N(48);
+          if (a) {
+            if (0 < c || c + b < a.length)
+              a.subarray ? a = a.subarray(c, c + b) : a = Array.prototype.slice.call(a, c, c + b);
+            p.set(a, d);
+          }
+        } else
+          e2 = false, d = a.byteOffset;
+        return { Kb: d, Ab: e2 };
+      }, jb(a, b, c, d) {
+        O.Ma.write(a, b, 0, d, c, false);
+        return 0;
+      } } }, la = (a, b) => {
+        var c = 0;
+        a && (c |= 365);
+        b && (c |= 146);
+        return c;
+      }, Eb = null, Fb = {}, Gb = [], Hb = 1, R = null, Ib = false, Jb = true, Kb = {}, N = class {
+        name = "ErrnoError";
+        constructor(a) {
+          this.Pa = a;
+        }
+      }, Lb = class {
+        gb = {};
+        node = null;
+        get flags() {
+          return this.gb.flags;
+        }
+        set flags(a) {
+          this.gb.flags = a;
+        }
+        get position() {
+          return this.gb.position;
+        }
+        set position(a) {
+          this.gb.position = a;
+        }
+      }, Mb = class {
+        La = {};
+        Ma = {};
+        ab = null;
+        constructor(a, b, c, d) {
+          a ||= this;
+          this.parent = a;
+          this.Xa = a.Xa;
+          this.id = Hb++;
+          this.name = b;
+          this.mode = c;
+          this.rdev = d;
+          this.atime = this.mtime = this.ctime = Date.now();
+        }
+        get read() {
+          return (this.mode & 365) === 365;
+        }
+        set read(a) {
+          a ? this.mode |= 365 : this.mode &= -366;
+        }
+        get write() {
+          return (this.mode & 146) === 146;
+        }
+        set write(a) {
+          a ? this.mode |= 146 : this.mode &= -147;
+        }
+      };
+      function S2(a, b = {}) {
+        if (!a)
+          throw new N(44);
+        b.nb ?? (b.nb = true);
+        a.charAt(0) === "/" || (a = "//" + a);
+        var c = 0;
+        a:
+          for (;40 > c; c++) {
+            a = a.split("/").filter((q) => !!q);
+            for (var d = Eb, e2 = "/", h2 = 0;h2 < a.length; h2++) {
+              var k = h2 === a.length - 1;
+              if (k && b.parent)
+                break;
+              if (a[h2] !== ".")
+                if (a[h2] === "..")
+                  e2 = fb(e2), d = d.parent;
+                else {
+                  e2 = ka(e2 + "/" + a[h2]);
+                  try {
+                    d = Q(d, a[h2]);
+                  } catch (q) {
+                    if (q?.Pa === 44 && k && b.Jb)
+                      return { path: e2 };
+                    throw q;
+                  }
+                  !d.ab || k && !b.nb || (d = d.ab.root);
+                  if ((d.mode & 61440) === 40960 && (!k || b.$a)) {
+                    if (!d.La.readlink)
+                      throw new N(52);
+                    d = d.La.readlink(d);
+                    d.charAt(0) === "/" || (d = fb(e2) + "/" + d);
+                    a = d + "/" + a.slice(h2 + 1).join("/");
+                    continue a;
+                  }
+                }
+            }
+            return { path: e2, node: d };
+          }
+        throw new N(32);
+      }
+      function ja(a) {
+        for (var b;; ) {
+          if (a === a.parent)
+            return a = a.Xa.zb, b ? a[a.length - 1] !== "/" ? `${a}/${b}` : a + b : a;
+          b = b ? `${a.name}/${b}` : a.name;
+          a = a.parent;
+        }
+      }
+      function Nb(a, b) {
+        for (var c = 0, d = 0;d < b.length; d++)
+          c = (c << 5) - c + b.charCodeAt(d) | 0;
+        return (a + c >>> 0) % R.length;
+      }
+      function Cb(a) {
+        var b = Nb(a.parent.id, a.name);
+        if (R[b] === a)
+          R[b] = a.bb;
+        else
+          for (b = R[b];b; ) {
+            if (b.bb === a) {
+              b.bb = a.bb;
+              break;
+            }
+            b = b.bb;
+          }
+      }
+      function Q(a, b) {
+        var c = P(a.mode) ? (c = Ob(a, "x")) ? c : a.La.lookup ? 0 : 2 : 54;
+        if (c)
+          throw new N(c);
+        for (c = R[Nb(a.id, b)];c; c = c.bb) {
+          var d = c.name;
+          if (c.parent.id === a.id && d === b)
+            return c;
+        }
+        return a.La.lookup(a, b);
+      }
+      function Bb(a, b, c, d) {
+        a = new Mb(a, b, c, d);
+        b = Nb(a.parent.id, a.name);
+        a.bb = R[b];
+        return R[b] = a;
+      }
+      function P(a) {
+        return (a & 61440) === 16384;
+      }
+      function Pb(a) {
+        var b = ["r", "w", "rw"][a & 3];
+        a & 512 && (b += "w");
+        return b;
+      }
+      function Ob(a, b) {
+        if (Jb)
+          return 0;
+        if (!b.includes("r") || a.mode & 292) {
+          if (b.includes("w") && !(a.mode & 146) || b.includes("x") && !(a.mode & 73))
+            return 2;
+        } else
+          return 2;
+        return 0;
+      }
+      function Qb(a, b) {
+        if (!P(a.mode))
+          return 54;
+        try {
+          return Q(a, b), 20;
+        } catch (c) {}
+        return Ob(a, "wx");
+      }
+      function Rb(a, b, c) {
+        try {
+          var d = Q(a, b);
+        } catch (e2) {
+          return e2.Pa;
+        }
+        if (a = Ob(a, "wx"))
+          return a;
+        if (c) {
+          if (!P(d.mode))
+            return 54;
+          if (d === d.parent || ja(d) === "/")
+            return 10;
+        } else if (P(d.mode))
+          return 31;
+        return 0;
+      }
+      function Sb(a) {
+        if (!a)
+          throw new N(63);
+        return a;
+      }
+      function T(a) {
+        a = Gb[a];
+        if (!a)
+          throw new N(8);
+        return a;
+      }
+      function Tb(a, b = -1) {
+        a = Object.assign(new Lb, a);
+        if (b == -1)
+          a: {
+            for (b = 0;4096 >= b; b++)
+              if (!Gb[b])
+                break a;
+            throw new N(33);
+          }
+        a.fd = b;
+        return Gb[b] = a;
+      }
+      function Ub(a, b = -1) {
+        a = Tb(a, b);
+        a.Ma?.Rb?.(a);
+        return a;
+      }
+      function Vb(a, b, c) {
+        var d = a?.Ma.Ua;
+        a = d ? a : b;
+        d ??= b.La.Ua;
+        Sb(d);
+        d(a, c);
+      }
+      var Ab = { open(a) {
+        a.Ma = Fb[a.node.rdev].Ma;
+        a.Ma.open?.(a);
+      }, Va() {
+        throw new N(70);
+      } };
+      function wb(a, b) {
+        Fb[a] = { Ma: b };
+      }
+      function Wb(a, b) {
+        var c = b === "/";
+        if (c && Eb)
+          throw new N(10);
+        if (!c && b) {
+          var d = S2(b, { nb: false });
+          b = d.path;
+          d = d.node;
+          if (d.ab)
+            throw new N(10);
+          if (!P(d.mode))
+            throw new N(54);
+        }
+        b = { type: a, Wb: {}, zb: b, Ib: [] };
+        a = a.Xa(b);
+        a.Xa = b;
+        b.root = a;
+        c ? Eb = a : d && (d.ab = b, d.Xa && d.Xa.Ib.push(b));
+      }
+      function Xb(a, b, c) {
+        var d = S2(a, { parent: true }).node;
+        a = gb(a);
+        if (!a)
+          throw new N(28);
+        if (a === "." || a === "..")
+          throw new N(20);
+        var e2 = Qb(d, a);
+        if (e2)
+          throw new N(e2);
+        if (!d.La.hb)
+          throw new N(63);
+        return d.La.hb(d, a, b, c);
+      }
+      function ma(a, b = 438) {
+        return Xb(a, b & 4095 | 32768, 0);
+      }
+      function U(a, b = 511) {
+        return Xb(a, b & 1023 | 16384, 0);
+      }
+      function Yb(a, b, c) {
+        typeof c == "undefined" && (c = b, b = 438);
+        Xb(a, b | 8192, c);
+      }
+      function Zb(a, b) {
+        if (!jb(a))
+          throw new N(44);
+        var c = S2(b, { parent: true }).node;
+        if (!c)
+          throw new N(44);
+        b = gb(b);
+        var d = Qb(c, b);
+        if (d)
+          throw new N(d);
+        if (!c.La.symlink)
+          throw new N(63);
+        c.La.symlink(c, b, a);
+      }
+      function $b(a) {
+        var b = S2(a, { parent: true }).node;
+        a = gb(a);
+        var c = Q(b, a), d = Rb(b, a, true);
+        if (d)
+          throw new N(d);
+        if (!b.La.rmdir)
+          throw new N(63);
+        if (c.ab)
+          throw new N(10);
+        b.La.rmdir(b, a);
+        Cb(c);
+      }
+      function za(a) {
+        var b = S2(a, { parent: true }).node;
+        if (!b)
+          throw new N(44);
+        a = gb(a);
+        var c = Q(b, a), d = Rb(b, a, false);
+        if (d)
+          throw new N(d);
+        if (!b.La.unlink)
+          throw new N(63);
+        if (c.ab)
+          throw new N(10);
+        b.La.unlink(b, a);
+        Cb(c);
+      }
+      function ac(a, b) {
+        a = S2(a, { $a: !b }).node;
+        return Sb(a.La.Ta)(a);
+      }
+      function bc(a, b, c, d) {
+        Vb(a, b, { mode: c & 4095 | b.mode & -4096, ctime: Date.now(), Fb: d });
+      }
+      function na(a, b) {
+        a = typeof a == "string" ? S2(a, { $a: true }).node : a;
+        bc(null, a, b);
+      }
+      function cc(a, b, c) {
+        if (P(b.mode))
+          throw new N(31);
+        if ((b.mode & 61440) !== 32768)
+          throw new N(28);
+        var d = Ob(b, "w");
+        if (d)
+          throw new N(d);
+        Vb(a, b, { size: c, timestamp: Date.now() });
+      }
+      function oa(a, b, c = 438) {
+        if (a === "")
+          throw new N(44);
+        if (typeof b == "string") {
+          var d = { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 }[b];
+          if (typeof d == "undefined")
+            throw Error(`Unknown file open mode: ${b}`);
+          b = d;
+        }
+        c = b & 64 ? c & 4095 | 32768 : 0;
+        if (typeof a == "object")
+          d = a;
+        else {
+          var e2 = a.endsWith("/");
+          a = S2(a, { $a: !(b & 131072), Jb: true });
+          d = a.node;
+          a = a.path;
+        }
+        var h2 = false;
+        if (b & 64)
+          if (d) {
+            if (b & 128)
+              throw new N(20);
+          } else {
+            if (e2)
+              throw new N(31);
+            d = Xb(a, c | 511, 0);
+            h2 = true;
+          }
+        if (!d)
+          throw new N(44);
+        (d.mode & 61440) === 8192 && (b &= -513);
+        if (b & 65536 && !P(d.mode))
+          throw new N(54);
+        if (!h2 && (e2 = d ? (d.mode & 61440) === 40960 ? 32 : P(d.mode) && (Pb(b) !== "r" || b & 576) ? 31 : Ob(d, Pb(b)) : 44))
+          throw new N(e2);
+        b & 512 && !h2 && (e2 = d, e2 = typeof e2 == "string" ? S2(e2, { $a: true }).node : e2, cc(null, e2, 0));
+        b &= -131713;
+        e2 = Tb({ node: d, path: ja(d), flags: b, seekable: true, position: 0, Ma: d.Ma, Lb: [], error: false });
+        e2.Ma.open && e2.Ma.open(e2);
+        h2 && na(d, c & 511);
+        !f3.logReadFiles || b & 1 || a in Kb || (Kb[a] = 1);
+        return e2;
+      }
+      function qa(a) {
+        if (a.fd === null)
+          throw new N(8);
+        a.ob && (a.ob = null);
+        try {
+          a.Ma.close && a.Ma.close(a);
+        } catch (b) {
+          throw b;
+        } finally {
+          Gb[a.fd] = null;
+        }
+        a.fd = null;
+      }
+      function mc(a, b, c) {
+        if (a.fd === null)
+          throw new N(8);
+        if (!a.seekable || !a.Ma.Va)
+          throw new N(70);
+        if (c != 0 && c != 1 && c != 2)
+          throw new N(28);
+        a.position = a.Ma.Va(a, b, c);
+        a.Lb = [];
+      }
+      function Ec(a, b, c, d, e2) {
+        if (0 > d || 0 > e2)
+          throw new N(28);
+        if (a.fd === null)
+          throw new N(8);
+        if ((a.flags & 2097155) === 1)
+          throw new N(8);
+        if (P(a.node.mode))
+          throw new N(31);
+        if (!a.Ma.read)
+          throw new N(28);
+        var h2 = typeof e2 != "undefined";
+        if (!h2)
+          e2 = a.position;
+        else if (!a.seekable)
+          throw new N(70);
+        b = a.Ma.read(a, b, c, d, e2);
+        h2 || (a.position += b);
+        return b;
+      }
+      function pa(a, b, c, d, e2) {
+        if (0 > d || 0 > e2)
+          throw new N(28);
+        if (a.fd === null)
+          throw new N(8);
+        if ((a.flags & 2097155) === 0)
+          throw new N(8);
+        if (P(a.node.mode))
+          throw new N(31);
+        if (!a.Ma.write)
+          throw new N(28);
+        a.seekable && a.flags & 1024 && mc(a, 0, 2);
+        var h2 = typeof e2 != "undefined";
+        if (!h2)
+          e2 = a.position;
+        else if (!a.seekable)
+          throw new N(70);
+        b = a.Ma.write(a, b, c, d, e2, undefined);
+        h2 || (a.position += b);
+        return b;
+      }
+      function ya(a) {
+        var b = "binary";
+        if (b !== "utf8" && b !== "binary")
+          throw Error(`Invalid encoding type "${b}"`);
+        var c;
+        var d = oa(a, d || 0);
+        a = ac(a).size;
+        var e2 = new Uint8Array(a);
+        Ec(d, e2, 0, a, 0);
+        b === "utf8" ? c = B(e2) : b === "binary" && (c = e2);
+        qa(d);
+        return c;
+      }
+      function V(a, b, c) {
+        a = ka("/dev/" + a);
+        var d = la(!!b, !!c);
+        V.yb ?? (V.yb = 64);
+        var e2 = V.yb++ << 8 | 0;
+        wb(e2, { open(h2) {
+          h2.seekable = false;
+        }, close() {
+          c?.buffer?.length && c(10);
+        }, read(h2, k, q, w) {
+          for (var v = 0, C = 0;C < w; C++) {
+            try {
+              var G = b();
+            } catch (pb) {
+              throw new N(29);
+            }
+            if (G === undefined && v === 0)
+              throw new N(6);
+            if (G === null || G === undefined)
+              break;
+            v++;
+            k[q + C] = G;
+          }
+          v && (h2.node.atime = Date.now());
+          return v;
+        }, write(h2, k, q, w) {
+          for (var v = 0;v < w; v++)
+            try {
+              c(k[q + v]);
+            } catch (C) {
+              throw new N(29);
+            }
+          w && (h2.node.mtime = h2.node.ctime = Date.now());
+          return v;
+        } });
+        Yb(a, d, e2);
+      }
+      var W = {};
+      function Gc(a, b, c) {
+        if (b.charAt(0) === "/")
+          return b;
+        a = a === -100 ? "/" : T(a).path;
+        if (b.length == 0) {
+          if (!c)
+            throw new N(44);
+          return a;
+        }
+        return a + "/" + b;
+      }
+      function Hc(a, b) {
+        E[a >> 2] = b.dev;
+        E[a + 4 >> 2] = b.mode;
+        F2[a + 8 >> 2] = b.nlink;
+        E[a + 12 >> 2] = b.uid;
+        E[a + 16 >> 2] = b.gid;
+        E[a + 20 >> 2] = b.rdev;
+        H[a + 24 >> 3] = BigInt(b.size);
+        E[a + 32 >> 2] = 4096;
+        E[a + 36 >> 2] = b.blocks;
+        var c = b.atime.getTime(), d = b.mtime.getTime(), e2 = b.ctime.getTime();
+        H[a + 40 >> 3] = BigInt(Math.floor(c / 1000));
+        F2[a + 48 >> 2] = c % 1000 * 1e6;
+        H[a + 56 >> 3] = BigInt(Math.floor(d / 1000));
+        F2[a + 64 >> 2] = d % 1000 * 1e6;
+        H[a + 72 >> 3] = BigInt(Math.floor(e2 / 1000));
+        F2[a + 80 >> 2] = e2 % 1000 * 1e6;
+        H[a + 88 >> 3] = BigInt(b.ino);
+        return 0;
+      }
+      var Ic = undefined, Jc = () => {
+        var a = E[+Ic >> 2];
+        Ic += 4;
+        return a;
+      }, Kc = 0, Lc = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], Mc = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], Nc = {}, Oc = (a) => {
+        Ma = a;
+        cb || 0 < Kc || (f3.onExit?.(a), La = true);
+        Da(a, new Ya(a));
+      }, Pc = (a) => {
+        if (!La)
+          try {
+            if (a(), !(cb || 0 < Kc))
+              try {
+                Ma = a = Ma, Oc(a);
+              } catch (b) {
+                b instanceof Ya || b == "unwind" || Da(1, b);
+              }
+          } catch (b) {
+            b instanceof Ya || b == "unwind" || Da(1, b);
+          }
+      }, Qc = {}, Sc = () => {
+        if (!Rc) {
+          var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: Ca || "./this.program" }, b;
+          for (b in Qc)
+            Qc[b] === undefined ? delete a[b] : a[b] = Qc[b];
+          var c = [];
+          for (b in a)
+            c.push(`${b}=${a[b]}`);
+          Rc = c;
+        }
+        return Rc;
+      }, Rc, xa = (a) => {
+        var b = ha(a) + 1, c = z2(b);
+        u(a, x2, c, b);
+        return c;
+      }, Tc = (a, b, c, d) => {
+        var e2 = { string: (v) => {
+          var C = 0;
+          v !== null && v !== undefined && v !== 0 && (C = xa(v));
+          return C;
+        }, array: (v) => {
+          var C = z2(v.length);
+          p.set(v, C);
+          return C;
+        } };
+        a = f3["_" + a];
+        var h2 = [], k = 0;
+        if (d)
+          for (var q = 0;q < d.length; q++) {
+            var w = e2[c[q]];
+            w ? (k === 0 && (k = sa()), h2[q] = w(d[q])) : h2[q] = d[q];
+          }
+        c = a(...h2);
+        return c = function(v) {
+          k !== 0 && wa(k);
+          return b === "string" ? v ? B(x2, v) : "" : b === "boolean" ? !!v : v;
+        }(c);
+      }, ea = 0, da = (a, b) => {
+        b = b == 1 ? z2(a.length) : ia(a.length);
+        a.subarray || a.slice || (a = new Uint8Array(a));
+        x2.set(a, b);
+        return b;
+      }, Uc, Vc = [], Y, A2 = (a) => {
+        Uc.delete(Y.get(a));
+        Y.set(a, null);
+        Vc.push(a);
+      }, Aa = (a, b) => {
+        if (!Uc) {
+          Uc = new WeakMap;
+          var c = Y.length;
+          if (Uc)
+            for (var d = 0;d < 0 + c; d++) {
+              var e2 = Y.get(d);
+              e2 && Uc.set(e2, d);
+            }
+        }
+        if (c = Uc.get(a) || 0)
+          return c;
+        if (Vc.length)
+          c = Vc.pop();
+        else {
+          try {
+            Y.grow(1);
+          } catch (w) {
+            if (!(w instanceof RangeError))
+              throw w;
+            throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
+          }
+          c = Y.length - 1;
+        }
+        try {
+          Y.set(c, a);
+        } catch (w) {
+          if (!(w instanceof TypeError))
+            throw w;
+          if (typeof WebAssembly.Function == "function") {
+            var h2 = WebAssembly.Function;
+            d = { i: "i32", j: "i64", f: "f32", d: "f64", e: "externref", p: "i32" };
+            e2 = { parameters: [], results: b[0] == "v" ? [] : [d[b[0]]] };
+            for (var k = 1;k < b.length; ++k)
+              e2.parameters.push(d[b[k]]);
+            b = new h2(e2, a);
+          } else {
+            d = [1];
+            e2 = b.slice(0, 1);
+            b = b.slice(1);
+            k = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
+            d.push(96);
+            var q = b.length;
+            128 > q ? d.push(q) : d.push(q % 128 | 128, q >> 7);
+            for (h2 of b)
+              d.push(k[h2]);
+            e2 == "v" ? d.push(0) : d.push(1, k[e2]);
+            b = [0, 97, 115, 109, 1, 0, 0, 0, 1];
+            h2 = d.length;
+            128 > h2 ? b.push(h2) : b.push(h2 % 128 | 128, h2 >> 7);
+            b.push(...d);
+            b.push(2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+            b = new WebAssembly.Module(new Uint8Array(b));
+            b = new WebAssembly.Instance(b, { e: { f: a } }).exports.f;
+          }
+          Y.set(c, b);
+        }
+        Uc.set(a, c);
+        return c;
+      };
+      R = Array(4096);
+      Wb(O, "/");
+      U("/tmp");
+      U("/home");
+      U("/home/web_user");
+      (function() {
+        U("/dev");
+        wb(259, { read: () => 0, write: (d, e2, h2, k) => k, Va: () => 0 });
+        Yb("/dev/null", 259);
+        nb(1280, yb);
+        nb(1536, zb);
+        Yb("/dev/tty", 1280);
+        Yb("/dev/tty1", 1536);
+        var a = new Uint8Array(1024), b = 0, c = () => {
+          b === 0 && (ib(a), b = a.byteLength);
+          return a[--b];
+        };
+        V("random", c);
+        V("urandom", c);
+        U("/dev/shm");
+        U("/dev/shm/tmp");
+      })();
+      (function() {
+        U("/proc");
+        var a = U("/proc/self");
+        U("/proc/self/fd");
+        Wb({ Xa() {
+          var b = Bb(a, "fd", 16895, 73);
+          b.Ma = { Va: O.Ma.Va };
+          b.La = { lookup(c, d) {
+            c = +d;
+            var e2 = T(c);
+            c = { parent: null, Xa: { zb: "fake" }, La: { readlink: () => e2.path }, id: c + 1 };
+            return c.parent = c;
+          }, readdir() {
+            return Array.from(Gb.entries()).filter(([, c]) => c).map(([c]) => c.toString());
+          } };
+          return b;
+        } }, "/proc/self/fd");
+      })();
+      O.vb = new N(44);
+      O.vb.stack = "<generic error, no stack>";
+      var Xc = { a: (a, b, c, d) => Ta(`Assertion failed: ${a ? B(x2, a) : ""}, at: ` + [b ? b ? B(x2, b) : "" : "unknown filename", c, d ? d ? B(x2, d) : "" : "unknown function"]), i: function(a, b) {
+        try {
+          return a = a ? B(x2, a) : "", na(a, b), 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, L: function(a, b, c) {
+        try {
+          b = b ? B(x2, b) : "";
+          b = Gc(a, b);
+          if (c & -8)
+            return -28;
+          var d = S2(b, { $a: true }).node;
+          if (!d)
+            return -44;
+          a = "";
+          c & 4 && (a += "r");
+          c & 2 && (a += "w");
+          c & 1 && (a += "x");
+          return a && Ob(d, a) ? -2 : 0;
+        } catch (e2) {
+          if (typeof W == "undefined" || e2.name !== "ErrnoError")
+            throw e2;
+          return -e2.Pa;
+        }
+      }, j: function(a, b) {
+        try {
+          var c = T(a);
+          bc(c, c.node, b, false);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, h: function(a) {
+        try {
+          var b = T(a);
+          Vb(b, b.node, { timestamp: Date.now(), Fb: false });
+          return 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, b: function(a, b, c) {
+        Ic = c;
+        try {
+          var d = T(a);
+          switch (b) {
+            case 0:
+              var e2 = Jc();
+              if (0 > e2)
+                break;
+              for (;Gb[e2]; )
+                e2++;
+              return Ub(d, e2).fd;
+            case 1:
+            case 2:
+              return 0;
+            case 3:
+              return d.flags;
+            case 4:
+              return e2 = Jc(), d.flags |= e2, 0;
+            case 12:
+              return e2 = Jc(), Na[e2 + 0 >> 1] = 2, 0;
+            case 13:
+            case 14:
+              return 0;
+          }
+          return -28;
+        } catch (h2) {
+          if (typeof W == "undefined" || h2.name !== "ErrnoError")
+            throw h2;
+          return -h2.Pa;
+        }
+      }, g: function(a, b) {
+        try {
+          var c = T(a), d = c.node, e2 = c.Ma.Ta;
+          a = e2 ? c : d;
+          e2 ??= d.La.Ta;
+          Sb(e2);
+          var h2 = e2(a);
+          return Hc(b, h2);
+        } catch (k) {
+          if (typeof W == "undefined" || k.name !== "ErrnoError")
+            throw k;
+          return -k.Pa;
+        }
+      }, H: function(a, b) {
+        b = -9007199254740992 > b || 9007199254740992 < b ? NaN : Number(b);
+        try {
+          if (isNaN(b))
+            return 61;
+          var c = T(a);
+          if (0 > b || (c.flags & 2097155) === 0)
+            throw new N(28);
+          cc(c, c.node, b);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, G: function(a, b) {
+        try {
+          if (b === 0)
+            return -28;
+          var c = ha("/") + 1;
+          if (b < c)
+            return -68;
+          u("/", x2, a, b);
+          return c;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, K: function(a, b) {
+        try {
+          return a = a ? B(x2, a) : "", Hc(b, ac(a, true));
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, C: function(a, b, c) {
+        try {
+          return b = b ? B(x2, b) : "", b = Gc(a, b), U(b, c), 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, J: function(a, b, c, d) {
+        try {
+          b = b ? B(x2, b) : "";
+          var e2 = d & 256;
+          b = Gc(a, b, d & 4096);
+          return Hc(c, e2 ? ac(b, true) : ac(b));
+        } catch (h2) {
+          if (typeof W == "undefined" || h2.name !== "ErrnoError")
+            throw h2;
+          return -h2.Pa;
+        }
+      }, x: function(a, b, c, d) {
+        Ic = d;
+        try {
+          b = b ? B(x2, b) : "";
+          b = Gc(a, b);
+          var e2 = d ? Jc() : 0;
+          return oa(b, c, e2).fd;
+        } catch (h2) {
+          if (typeof W == "undefined" || h2.name !== "ErrnoError")
+            throw h2;
+          return -h2.Pa;
+        }
+      }, v: function(a, b, c, d) {
+        try {
+          b = b ? B(x2, b) : "";
+          b = Gc(a, b);
+          if (0 >= d)
+            return -28;
+          var e2 = S2(b).node;
+          if (!e2)
+            throw new N(44);
+          if (!e2.La.readlink)
+            throw new N(28);
+          var h2 = e2.La.readlink(e2);
+          var k = Math.min(d, ha(h2)), q = p[c + k];
+          u(h2, x2, c, d + 1);
+          p[c + k] = q;
+          return k;
+        } catch (w) {
+          if (typeof W == "undefined" || w.name !== "ErrnoError")
+            throw w;
+          return -w.Pa;
+        }
+      }, u: function(a) {
+        try {
+          return a = a ? B(x2, a) : "", $b(a), 0;
+        } catch (b) {
+          if (typeof W == "undefined" || b.name !== "ErrnoError")
+            throw b;
+          return -b.Pa;
+        }
+      }, f: function(a, b) {
+        try {
+          return a = a ? B(x2, a) : "", Hc(b, ac(a));
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return -c.Pa;
+        }
+      }, r: function(a, b, c) {
+        try {
+          return b = b ? B(x2, b) : "", b = Gc(a, b), c === 0 ? za(b) : c === 512 ? $b(b) : Ta("Invalid flags passed to unlinkat"), 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return -d.Pa;
+        }
+      }, q: function(a, b, c) {
+        try {
+          b = b ? B(x2, b) : "";
+          b = Gc(a, b, true);
+          var d = Date.now(), e2, h2;
+          if (c) {
+            var k = F2[c >> 2] + 4294967296 * E[c + 4 >> 2], q = E[c + 8 >> 2];
+            q == 1073741823 ? e2 = d : q == 1073741822 ? e2 = null : e2 = 1000 * k + q / 1e6;
+            c += 16;
+            k = F2[c >> 2] + 4294967296 * E[c + 4 >> 2];
+            q = E[c + 8 >> 2];
+            q == 1073741823 ? h2 = d : q == 1073741822 ? h2 = null : h2 = 1000 * k + q / 1e6;
+          } else
+            h2 = e2 = d;
+          if ((h2 ?? e2) !== null) {
+            a = e2;
+            var w = S2(b, { $a: true }).node;
+            Sb(w.La.Ua)(w, { atime: a, mtime: h2 });
+          }
+          return 0;
+        } catch (v) {
+          if (typeof W == "undefined" || v.name !== "ErrnoError")
+            throw v;
+          return -v.Pa;
+        }
+      }, m: () => Ta(""), l: () => {
+        cb = false;
+        Kc = 0;
+      }, A: function(a, b) {
+        a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);
+        a = new Date(1000 * a);
+        E[b >> 2] = a.getSeconds();
+        E[b + 4 >> 2] = a.getMinutes();
+        E[b + 8 >> 2] = a.getHours();
+        E[b + 12 >> 2] = a.getDate();
+        E[b + 16 >> 2] = a.getMonth();
+        E[b + 20 >> 2] = a.getFullYear() - 1900;
+        E[b + 24 >> 2] = a.getDay();
+        var c = a.getFullYear();
+        E[b + 28 >> 2] = (c % 4 !== 0 || c % 100 === 0 && c % 400 !== 0 ? Mc : Lc)[a.getMonth()] + a.getDate() - 1 | 0;
+        E[b + 36 >> 2] = -(60 * a.getTimezoneOffset());
+        c = new Date(a.getFullYear(), 6, 1).getTimezoneOffset();
+        var d = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();
+        E[b + 32 >> 2] = (c != d && a.getTimezoneOffset() == Math.min(d, c)) | 0;
+      }, y: function(a, b, c, d, e2, h2, k) {
+        e2 = -9007199254740992 > e2 || 9007199254740992 < e2 ? NaN : Number(e2);
+        try {
+          if (isNaN(e2))
+            return 61;
+          var q = T(d);
+          if ((b & 2) !== 0 && (c & 2) === 0 && (q.flags & 2097155) !== 2)
+            throw new N(2);
+          if ((q.flags & 2097155) === 1)
+            throw new N(2);
+          if (!q.Ma.ib)
+            throw new N(43);
+          if (!a)
+            throw new N(28);
+          var w = q.Ma.ib(q, a, e2, b, c);
+          var v = w.Kb;
+          E[h2 >> 2] = w.Ab;
+          F2[k >> 2] = v;
+          return 0;
+        } catch (C) {
+          if (typeof W == "undefined" || C.name !== "ErrnoError")
+            throw C;
+          return -C.Pa;
+        }
+      }, z: function(a, b, c, d, e2, h2) {
+        h2 = -9007199254740992 > h2 || 9007199254740992 < h2 ? NaN : Number(h2);
+        try {
+          var k = T(e2);
+          if (c & 2) {
+            c = h2;
+            if ((k.node.mode & 61440) !== 32768)
+              throw new N(43);
+            if (!(d & 2)) {
+              var q = x2.slice(a, a + b);
+              k.Ma.jb && k.Ma.jb(k, q, c, b, d);
+            }
+          }
+        } catch (w) {
+          if (typeof W == "undefined" || w.name !== "ErrnoError")
+            throw w;
+          return -w.Pa;
+        }
+      }, n: (a, b) => {
+        Nc[a] && (clearTimeout(Nc[a].id), delete Nc[a]);
+        if (!b)
+          return 0;
+        var c = setTimeout(() => {
+          delete Nc[a];
+          Pc(() => Wc(a, performance.now()));
+        }, b);
+        Nc[a] = {
+          id: c,
+          Xb: b
+        };
+        return 0;
+      }, B: (a, b, c, d) => {
+        var e2 = new Date().getFullYear(), h2 = new Date(e2, 0, 1).getTimezoneOffset();
+        e2 = new Date(e2, 6, 1).getTimezoneOffset();
+        F2[a >> 2] = 60 * Math.max(h2, e2);
+        E[b >> 2] = Number(h2 != e2);
+        b = (k) => {
+          var q = Math.abs(k);
+          return `UTC${0 <= k ? "-" : "+"}${String(Math.floor(q / 60)).padStart(2, "0")}${String(q % 60).padStart(2, "0")}`;
+        };
+        a = b(h2);
+        b = b(e2);
+        e2 < h2 ? (u(a, x2, c, 17), u(b, x2, d, 17)) : (u(a, x2, d, 17), u(b, x2, c, 17));
+      }, d: () => Date.now(), s: () => 2147483648, c: () => performance.now(), o: (a) => {
+        var b = x2.length;
+        a >>>= 0;
+        if (2147483648 < a)
+          return false;
+        for (var c = 1;4 >= c; c *= 2) {
+          var d = b * (1 + 0.2 / c);
+          d = Math.min(d, a + 100663296);
+          a: {
+            d = (Math.min(2147483648, 65536 * Math.ceil(Math.max(a, d) / 65536)) - Ka.buffer.byteLength + 65535) / 65536 | 0;
+            try {
+              Ka.grow(d);
+              Qa();
+              var e2 = 1;
+              break a;
+            } catch (h2) {}
+            e2 = undefined;
+          }
+          if (e2)
+            return true;
+        }
+        return false;
+      }, E: (a, b) => {
+        var c = 0;
+        Sc().forEach((d, e2) => {
+          var h2 = b + c;
+          e2 = F2[a + 4 * e2 >> 2] = h2;
+          for (h2 = 0;h2 < d.length; ++h2)
+            p[e2++] = d.charCodeAt(h2);
+          p[e2] = 0;
+          c += d.length + 1;
+        });
+        return 0;
+      }, F: (a, b) => {
+        var c = Sc();
+        F2[a >> 2] = c.length;
+        var d = 0;
+        c.forEach((e2) => d += e2.length + 1);
+        F2[b >> 2] = d;
+        return 0;
+      }, e: function(a) {
+        try {
+          var b = T(a);
+          qa(b);
+          return 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return c.Pa;
+        }
+      }, p: function(a, b) {
+        try {
+          var c = T(a);
+          p[b] = c.tty ? 2 : P(c.mode) ? 3 : (c.mode & 61440) === 40960 ? 7 : 4;
+          Na[b + 2 >> 1] = 0;
+          H[b + 8 >> 3] = BigInt(0);
+          H[b + 16 >> 3] = BigInt(0);
+          return 0;
+        } catch (d) {
+          if (typeof W == "undefined" || d.name !== "ErrnoError")
+            throw d;
+          return d.Pa;
+        }
+      }, w: function(a, b, c, d) {
+        try {
+          a: {
+            var e2 = T(a);
+            a = b;
+            for (var h2, k = b = 0;k < c; k++) {
+              var q = F2[a >> 2], w = F2[a + 4 >> 2];
+              a += 8;
+              var v = Ec(e2, p, q, w, h2);
+              if (0 > v) {
+                var C = -1;
+                break a;
+              }
+              b += v;
+              if (v < w)
+                break;
+              typeof h2 != "undefined" && (h2 += v);
+            }
+            C = b;
+          }
+          F2[d >> 2] = C;
+          return 0;
+        } catch (G) {
+          if (typeof W == "undefined" || G.name !== "ErrnoError")
+            throw G;
+          return G.Pa;
+        }
+      }, D: function(a, b, c, d) {
+        b = -9007199254740992 > b || 9007199254740992 < b ? NaN : Number(b);
+        try {
+          if (isNaN(b))
+            return 61;
+          var e2 = T(a);
+          mc(e2, b, c);
+          H[d >> 3] = BigInt(e2.position);
+          e2.ob && b === 0 && c === 0 && (e2.ob = null);
+          return 0;
+        } catch (h2) {
+          if (typeof W == "undefined" || h2.name !== "ErrnoError")
+            throw h2;
+          return h2.Pa;
+        }
+      }, I: function(a) {
+        try {
+          var b = T(a);
+          return b.Ma?.fsync ? b.Ma.fsync(b) : 0;
+        } catch (c) {
+          if (typeof W == "undefined" || c.name !== "ErrnoError")
+            throw c;
+          return c.Pa;
+        }
+      }, t: function(a, b, c, d) {
+        try {
+          a: {
+            var e2 = T(a);
+            a = b;
+            for (var h2, k = b = 0;k < c; k++) {
+              var q = F2[a >> 2], w = F2[a + 4 >> 2];
+              a += 8;
+              var v = pa(e2, p, q, w, h2);
+              if (0 > v) {
+                var C = -1;
+                break a;
+              }
+              b += v;
+              if (v < w)
+                break;
+              typeof h2 != "undefined" && (h2 += v);
+            }
+            C = b;
+          }
+          F2[d >> 2] = C;
+          return 0;
+        } catch (G) {
+          if (typeof W == "undefined" || G.name !== "ErrnoError")
+            throw G;
+          return G.Pa;
+        }
+      }, k: Oc }, Z2;
+      (async function() {
+        function a(c) {
+          Z2 = c.exports;
+          Ka = Z2.M;
+          Qa();
+          Y = Z2.O;
+          K--;
+          f3.monitorRunDependencies?.(K);
+          K == 0 && Sa && (c = Sa, Sa = null, c());
+          return Z2;
+        }
+        K++;
+        f3.monitorRunDependencies?.(K);
+        var b = { a: Xc };
+        if (f3.instantiateWasm)
+          return new Promise((c) => {
+            f3.instantiateWasm(b, (d, e2) => {
+              a(d, e2);
+              c(d.exports);
+            });
+          });
+        Ua ??= f3.locateFile ? f3.locateFile("sql-wasm.wasm", D) : D + "sql-wasm.wasm";
+        return a((await Xa(b)).instance);
+      })();
+      f3._sqlite3_free = (a) => (f3._sqlite3_free = Z2.P)(a);
+      f3._sqlite3_value_text = (a) => (f3._sqlite3_value_text = Z2.Q)(a);
+      f3._sqlite3_prepare_v2 = (a, b, c, d, e2) => (f3._sqlite3_prepare_v2 = Z2.R)(a, b, c, d, e2);
+      f3._sqlite3_step = (a) => (f3._sqlite3_step = Z2.S)(a);
+      f3._sqlite3_reset = (a) => (f3._sqlite3_reset = Z2.T)(a);
+      f3._sqlite3_exec = (a, b, c, d, e2) => (f3._sqlite3_exec = Z2.U)(a, b, c, d, e2);
+      f3._sqlite3_finalize = (a) => (f3._sqlite3_finalize = Z2.V)(a);
+      f3._sqlite3_column_name = (a, b) => (f3._sqlite3_column_name = Z2.W)(a, b);
+      f3._sqlite3_column_text = (a, b) => (f3._sqlite3_column_text = Z2.X)(a, b);
+      f3._sqlite3_column_type = (a, b) => (f3._sqlite3_column_type = Z2.Y)(a, b);
+      f3._sqlite3_errmsg = (a) => (f3._sqlite3_errmsg = Z2.Z)(a);
+      f3._sqlite3_clear_bindings = (a) => (f3._sqlite3_clear_bindings = Z2._)(a);
+      f3._sqlite3_value_blob = (a) => (f3._sqlite3_value_blob = Z2.$)(a);
+      f3._sqlite3_value_bytes = (a) => (f3._sqlite3_value_bytes = Z2.aa)(a);
+      f3._sqlite3_value_double = (a) => (f3._sqlite3_value_double = Z2.ba)(a);
+      f3._sqlite3_value_int = (a) => (f3._sqlite3_value_int = Z2.ca)(a);
+      f3._sqlite3_value_type = (a) => (f3._sqlite3_value_type = Z2.da)(a);
+      f3._sqlite3_result_blob = (a, b, c, d) => (f3._sqlite3_result_blob = Z2.ea)(a, b, c, d);
+      f3._sqlite3_result_double = (a, b) => (f3._sqlite3_result_double = Z2.fa)(a, b);
+      f3._sqlite3_result_error = (a, b, c) => (f3._sqlite3_result_error = Z2.ga)(a, b, c);
+      f3._sqlite3_result_int = (a, b) => (f3._sqlite3_result_int = Z2.ha)(a, b);
+      f3._sqlite3_result_int64 = (a, b) => (f3._sqlite3_result_int64 = Z2.ia)(a, b);
+      f3._sqlite3_result_null = (a) => (f3._sqlite3_result_null = Z2.ja)(a);
+      f3._sqlite3_result_text = (a, b, c, d) => (f3._sqlite3_result_text = Z2.ka)(a, b, c, d);
+      f3._sqlite3_aggregate_context = (a, b) => (f3._sqlite3_aggregate_context = Z2.la)(a, b);
+      f3._sqlite3_column_count = (a) => (f3._sqlite3_column_count = Z2.ma)(a);
+      f3._sqlite3_data_count = (a) => (f3._sqlite3_data_count = Z2.na)(a);
+      f3._sqlite3_column_blob = (a, b) => (f3._sqlite3_column_blob = Z2.oa)(a, b);
+      f3._sqlite3_column_bytes = (a, b) => (f3._sqlite3_column_bytes = Z2.pa)(a, b);
+      f3._sqlite3_column_double = (a, b) => (f3._sqlite3_column_double = Z2.qa)(a, b);
+      f3._sqlite3_bind_blob = (a, b, c, d, e2) => (f3._sqlite3_bind_blob = Z2.ra)(a, b, c, d, e2);
+      f3._sqlite3_bind_double = (a, b, c) => (f3._sqlite3_bind_double = Z2.sa)(a, b, c);
+      f3._sqlite3_bind_int = (a, b, c) => (f3._sqlite3_bind_int = Z2.ta)(a, b, c);
+      f3._sqlite3_bind_text = (a, b, c, d, e2) => (f3._sqlite3_bind_text = Z2.ua)(a, b, c, d, e2);
+      f3._sqlite3_bind_parameter_index = (a, b) => (f3._sqlite3_bind_parameter_index = Z2.va)(a, b);
+      f3._sqlite3_sql = (a) => (f3._sqlite3_sql = Z2.wa)(a);
+      f3._sqlite3_normalized_sql = (a) => (f3._sqlite3_normalized_sql = Z2.xa)(a);
+      f3._sqlite3_changes = (a) => (f3._sqlite3_changes = Z2.ya)(a);
+      f3._sqlite3_close_v2 = (a) => (f3._sqlite3_close_v2 = Z2.za)(a);
+      f3._sqlite3_create_function_v2 = (a, b, c, d, e2, h2, k, q, w) => (f3._sqlite3_create_function_v2 = Z2.Aa)(a, b, c, d, e2, h2, k, q, w);
+      f3._sqlite3_update_hook = (a, b, c) => (f3._sqlite3_update_hook = Z2.Ba)(a, b, c);
+      f3._sqlite3_open = (a, b) => (f3._sqlite3_open = Z2.Ca)(a, b);
+      var ia = f3._malloc = (a) => (ia = f3._malloc = Z2.Da)(a), fa = f3._free = (a) => (fa = f3._free = Z2.Ea)(a);
+      f3._RegisterExtensionFunctions = (a) => (f3._RegisterExtensionFunctions = Z2.Fa)(a);
+      var Db = (a, b) => (Db = Z2.Ga)(a, b), Wc = (a, b) => (Wc = Z2.Ha)(a, b), wa = (a) => (wa = Z2.Ia)(a), z2 = (a) => (z2 = Z2.Ja)(a), sa = () => (sa = Z2.Ka)();
+      f3.stackSave = () => sa();
+      f3.stackRestore = (a) => wa(a);
+      f3.stackAlloc = (a) => z2(a);
+      f3.cwrap = (a, b, c, d) => {
+        var e2 = !c || c.every((h2) => h2 === "number" || h2 === "boolean");
+        return b !== "string" && e2 && !d ? f3["_" + a] : (...h2) => Tc(a, b, c, h2);
+      };
+      f3.addFunction = Aa;
+      f3.removeFunction = A2;
+      f3.UTF8ToString = ua;
+      f3.ALLOC_NORMAL = ea;
+      f3.allocate = da;
+      f3.allocateUTF8OnStack = xa;
+      function Yc() {
+        function a() {
+          f3.calledRun = true;
+          if (!La) {
+            if (!f3.noFSInit && !Ib) {
+              var b, c;
+              Ib = true;
+              d ??= f3.stdin;
+              b ??= f3.stdout;
+              c ??= f3.stderr;
+              d ? V("stdin", d) : Zb("/dev/tty", "/dev/stdin");
+              b ? V("stdout", null, b) : Zb("/dev/tty", "/dev/stdout");
+              c ? V("stderr", null, c) : Zb("/dev/tty1", "/dev/stderr");
+              oa("/dev/stdin", 0);
+              oa("/dev/stdout", 1);
+              oa("/dev/stderr", 1);
+            }
+            Z2.N();
+            Jb = false;
+            f3.onRuntimeInitialized?.();
+            if (f3.postRun)
+              for (typeof f3.postRun == "function" && (f3.postRun = [f3.postRun]);f3.postRun.length; ) {
+                var d = f3.postRun.shift();
+                $a.unshift(d);
+              }
+            Za($a);
+          }
+        }
+        if (0 < K)
+          Sa = Yc;
+        else {
+          if (f3.preRun)
+            for (typeof f3.preRun == "function" && (f3.preRun = [f3.preRun]);f3.preRun.length; )
+              bb();
+          Za(ab);
+          0 < K ? Sa = Yc : f3.setStatus ? (f3.setStatus("Running..."), setTimeout(() => {
+            setTimeout(() => f3.setStatus(""), 1);
+            a();
+          }, 1)) : a();
+        }
+      }
+      if (f3.preInit)
+        for (typeof f3.preInit == "function" && (f3.preInit = [f3.preInit]);0 < f3.preInit.length; )
+          f3.preInit.pop()();
+      Yc();
+      return Module;
+    });
+    return initSqlJsPromise;
+  };
+  if (typeof exports === "object" && typeof module === "object") {
+    module.exports = initSqlJs;
+    module.exports.default = initSqlJs;
+  } else if (typeof define === "function" && define["amd"]) {
+    define([], function() {
+      return initSqlJs;
+    });
+  } else if (typeof exports === "object") {
+    exports["Module"] = initSqlJs;
+  }
+});
+
 // src/config.ts
 import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -48641,6 +50925,57 @@ function date4(params) {
 
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
+// ../core/src/config/base.ts
+var baseModelConfigSchema = exports_external.object({
+  provider: exports_external.string().optional(),
+  model: exports_external.string().optional(),
+  parameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+});
+var baseApprovalConfigSchema = exports_external.object({
+  level: exports_external.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApprove: exports_external.boolean().optional(),
+  maxCost: exports_external.number().positive().optional()
+});
+var providerConfigSchema = exports_external.object({
+  apiKey: exports_external.string().optional(),
+  defaultModel: exports_external.string().optional(),
+  defaultParameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  location: exports_external.string().optional(),
+  project: exports_external.string().optional(),
+  keyFile: exports_external.string().optional(),
+  baseUrl: exports_external.string().optional(),
+  name: exports_external.string().optional()
+});
+var modelConfigSchema = baseModelConfigSchema.extend({
+  budget: exports_external.number().positive().optional(),
+  rules: exports_external.union([exports_external.string(), exports_external.array(exports_external.string()).optional()]).optional()
+});
+var toolConfigSchema = exports_external.union([
+  exports_external.boolean(),
+  baseModelConfigSchema
+]);
+
+// ../core/src/config/memory.ts
+var memoryConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional().default(true),
+  type: exports_external.enum(["sqlite", "memory"]).optional().default("sqlite"),
+  path: exports_external.string().optional().default("~/.config/polka-codes/memory.sqlite")
+}).strict().optional();
+var DEFAULT_MEMORY_CONFIG = {
+  enabled: true,
+  type: "sqlite",
+  path: "~/.config/polka-codes/memory.sqlite"
+};
+function resolveHomePath(path) {
+  if (path.startsWith("~")) {
+    const home = process.env.HOME || process.env.USERPROFILE || ".";
+    if (home === ".") {
+      throw new Error("Cannot resolve home directory: HOME and USERPROFILE environment variables are not set");
+    }
+    return `${home}${path.slice(1)}`;
+  }
+  return path;
+}
 // ../core/src/config.ts
 var ruleSchema = exports_external.union([
   exports_external.string(),
@@ -48654,20 +50989,10 @@ var ruleSchema = exports_external.union([
     branch: exports_external.string().optional()
   }).strict()
 ]);
-var providerConfigSchema = exports_external.object({
-  apiKey: exports_external.string().optional(),
-  defaultModel: exports_external.string().optional(),
-  defaultParameters: exports_external.record(exports_external.string(), exports_external.any()).optional(),
-  location: exports_external.string().optional(),
-  project: exports_external.string().optional(),
-  keyFile: exports_external.string().optional(),
-  baseUrl: exports_external.string().optional(),
-  name: exports_external.string().optional()
-});
 var providerModelSchema = exports_external.object({
   provider: exports_external.string().optional(),
   model: exports_external.string().optional(),
-  parameters: exports_external.record(exports_external.string(), exports_external.any()).optional(),
+  parameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
   budget: exports_external.number().positive().optional(),
   rules: exports_external.array(ruleSchema).optional().or(exports_external.string()).optional()
 });
@@ -48680,7 +51005,7 @@ var scriptSchema = exports_external.union([
   exports_external.object({
     workflow: exports_external.string(),
     description: exports_external.string().optional(),
-    input: exports_external.record(exports_external.string(), exports_external.any()).optional()
+    input: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
   }).strict(),
   exports_external.object({
     script: exports_external.string(),
@@ -48759,7 +51084,7 @@ var configSchema = exports_external.object({
   providers: exports_external.record(exports_external.string(), providerConfigSchema).optional(),
   defaultProvider: exports_external.string().optional(),
   defaultModel: exports_external.string().optional(),
-  defaultParameters: exports_external.record(exports_external.string(), exports_external.any()).optional(),
+  defaultParameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
   maxMessageCount: exports_external.number().int().positive().optional(),
   budget: exports_external.number().positive().optional(),
   retryCount: exports_external.number().int().min(0).optional(),
@@ -48773,7 +51098,8 @@ var configSchema = exports_external.object({
   mcpServers: exports_external.record(exports_external.string(), mcpServerConfigSchema).optional(),
   rules: exports_external.array(ruleSchema).optional().or(exports_external.string()).optional(),
   excludeFiles: exports_external.array(exports_external.string()).optional(),
-  agent: agentSchema
+  agent: agentSchema,
+  memory: memoryConfigSchema
 }).strict().nullish();
 // ../core/src/skills/constants.ts
 var SKILL_LIMITS = {
@@ -49246,14 +51572,40 @@ var readBinaryFile_default = {
 // ../core/src/tools/readFile.ts
 var toolInfo6 = {
   name: "readFile",
-  description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.",
+  description: `Request to read the contents of one or multiple files at the specified paths.
+
+When to use:
+- Examining file contents you don't know
+- Analyzing code, reviewing text files, extracting configuration info
+- Reading multiple files at once (use comma-separated paths)
+- Understanding file structure before editing
+
+When NOT to use:
+- For file existence checks: Use listFiles instead
+- For searching within files: Use grep instead
+- For file name searches: Use searchFiles instead
+- Prefer this tool over executeCommand with cat/head/tail
+
+Features:
+- Supports comma-separated paths for multiple files
+- Line numbers included for easy reference
+- Optional offset/limit for partial file reading
+- Automatically handles different file types
+
+IMPORTANT:
+- Line numbers are included for easy reference
+- Use offset/limit for large files to read specific sections`,
   parameters: exports_external.object({
     path: exports_external.preprocess((val) => {
       if (!val)
         return [];
-      const values = Array.isArray(val) ? val : [val];
-      return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
+      if (Array.isArray(val)) {
+        return val.filter((s) => typeof s === "string" && s.length > 0);
+      }
+      return val.split(",").filter((s) => s.length > 0);
     }, exports_external.array(exports_external.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
+    offset: exports_external.number().optional().describe("Skip first N lines (for partial file reading)").meta({ usageValue: "100" }),
+    limit: exports_external.number().optional().describe("Read at most N lines (for partial file reading)").meta({ usageValue: "50" }),
     includeIgnored: exports_external.preprocess(preprocessBoolean, exports_external.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
@@ -49268,6 +51620,14 @@ var toolInfo6 = {
         input: {
           path: "src/main.js,src/index.js"
         }
+      },
+      {
+        description: "Read partial file (lines 100-150)",
+        input: {
+          path: "src/large-file.ts",
+          offset: 100,
+          limit: 50
+        }
       }
     ]
   })
@@ -49276,15 +51636,39 @@ var handler6 = async (provider, args) => {
   if (!provider.readFile) {
     return createProviderErrorResponse("read file");
   }
-  const { path: paths, includeIgnored } = toolInfo6.parameters.parse(args);
+  const parsed = toolInfo6.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      success: false,
+      message: {
+        type: "error-text",
+        value: `Invalid arguments for readFile: ${parsed.error.message}`
+      }
+    };
+  }
+  const { path: paths, offset, limit, includeIgnored } = parsed.data;
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path, includeIgnored ?? false);
     if (!fileContent) {
       resp.push(createFileElement("read_file_file_content", path, undefined, { file_not_found: "true" }));
-    } else {
-      resp.push(createFileElement("read_file_file_content", path, fileContent));
+      continue;
     }
+    let lines = fileContent.split(`
+`);
+    const start = offset ?? 0;
+    const end = limit ? start + limit : lines.length;
+    if (offset !== undefined || limit !== undefined) {
+      lines = lines.slice(start, end);
+    }
+    const lineOffset = offset ?? 0;
+    const numberedContent = lines.map((line, i) => {
+      const lineNumber = lineOffset + i + 1;
+      const paddedNumber = String(lineNumber).padStart(6, " ");
+      return `${paddedNumber}→${line}`;
+    }).join(`
+`);
+    resp.push(createFileElement("read_file_file_content", path, numberedContent));
   }
   return {
     success: true,
@@ -49481,7 +51865,43 @@ var replaceInFile = (fileContent, diff) => {
 // ../core/src/tools/replaceInFile.ts
 var toolInfo9 = {
   name: "replaceInFile",
-  description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
+  description: `Request to replace sections of content in an existing file using
+SEARCH/REPLACE blocks.
+
+When to use:
+- Making targeted changes to specific parts of a file
+- Replacing variable names, function signatures, imports
+- Fixing bugs in existing code
+- When you know the exact content to replace
+
+When NOT to use:
+- For creating new files: Use writeToFile instead
+- For completely replacing file contents: Use writeToFile instead
+- When you don't know the exact content: Read file first
+
+SEARCH/REPLACE FORMAT:
+<<<<<<< SEARCH
+[exact content to find]
+=======
+[new content to replace with]
+>>>>>>> REPLACE
+
+Critical rules:
+1. SEARCH content must match EXACTLY (character-for-character including whitespace)
+2. Each block replaces only first occurrence
+3. Include just enough lines for uniqueness (not too many, not too few)
+4. Keep blocks concise (don't include long unchanged sections)
+5. List blocks in order they appear in file
+6. Use multiple blocks for multiple independent changes
+
+Special operations:
+- Move code: Two blocks (delete from original + insert at new location)
+- Delete code: Empty REPLACE section
+
+IMPORTANT CONSTRAINTS:
+- SEARCH text must match file content exactly
+- Each block is independent (doesn't affect other blocks)
+- Cannot use for appending or inserting without SEARCH context`,
   parameters: exports_external.object({
     path: exports_external.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
     diff: exports_external.string().describe(`One or more SEARCH/REPLACE blocks following this exact format:
@@ -49507,7 +51927,7 @@ Critical rules:
     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
 4. Special operations:
     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
-    * To delete code: Use empty REPLACE section`).meta({ usageValue: "Search and replace blocks here" })
+    * To delete code: Empty REPLACE section`).meta({ usageValue: "Search and replace blocks here" })
   }).meta({
     examples: [
       {
@@ -49835,7 +52255,27 @@ var UpdateTodoItemOutputSchema = exports_external.object({
 // ../core/src/tools/writeToFile.ts
 var toolInfo12 = {
   name: "writeToFile",
-  description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.",
+  description: `Request to write content to a file at the specified path.
+
+When to use:
+- Creating new files
+- Completely replacing file contents
+- When you have the complete intended content
+
+When NOT to use:
+- For modifying existing files: Use replaceInFile instead
+- For appending content: Use executeCommand with echo >> instead
+- For targeted edits: Use replaceInFile instead
+
+Features:
+- Automatically creates any directories needed
+- Overwrites existing files completely
+- Must provide complete file content (no truncation)
+
+IMPORTANT CONSTRAINT:
+- Always provide COMPLETE intended content (no omissions)
+- Ensure no incorrect escape sequences (&lt;, &gt;, &amp;)
+- Ensure no unwanted CDATA tags in content`,
   parameters: exports_external.object({
     path: exports_external.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
     content: exports_external.string().describe("The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.").meta({ usageValue: "Your file content here" })
@@ -49876,10 +52316,7 @@ var handler12 = async (provider, args) => {
       }
     };
   }
-  let { path, content } = parsed.data;
-  const trimmedContent = content.trim();
-  if (trimmedContent.startsWith("<![CDATA[") && trimmedContent.endsWith("]]>"))
-    content = trimmedContent.slice(9, -3);
+  const { path, content } = parsed.data;
   await provider.writeFile(path, content);
   return {
     success: true,
@@ -53028,9 +55465,9 @@ class ZodUnion2 extends ZodType2 {
     return this._def.options;
   }
 }
-ZodUnion2.create = (types2, params) => {
+ZodUnion2.create = (types3, params) => {
   return new ZodUnion2({
-    options: types2,
+    options: types3,
     typeName: ZodFirstPartyTypeKind2.ZodUnion,
     ...processCreateParams(params)
   });
@@ -55524,15 +57961,15 @@ var primitiveMappings = {
 function parseUnionDef(def, refs) {
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every((x) => (x._def.typeName in primitiveMappings) && (!x._def.checks || !x._def.checks.length))) {
-    const types2 = options.reduce((types22, x) => {
+    const types3 = options.reduce((types22, x) => {
       const type = primitiveMappings[x._def.typeName];
       return type && !types22.includes(type) ? [...types22, type] : types22;
     }, []);
     return {
-      type: types2.length > 1 ? types2 : types2[0]
+      type: types3.length > 1 ? types3 : types3[0]
     };
   } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types2 = options.reduce((acc, x) => {
+    const types3 = options.reduce((acc, x) => {
       const type = typeof x._def.value;
       switch (type) {
         case "string":
@@ -55551,8 +57988,8 @@ function parseUnionDef(def, refs) {
           return acc;
       }
     }, []);
-    if (types2.length === options.length) {
-      const uniqueTypes = types2.filter((x, i, a) => a.indexOf(x) === i);
+    if (types3.length === options.length) {
+      const uniqueTypes = types3.filter((x, i, a) => a.indexOf(x) === i);
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
         enum: options.reduce((acc, x) => {
@@ -59733,7 +62170,7 @@ var uiMessagesSchema = lazyValidator(() => zodSchema(exports_external.array(expo
 var WorkflowInputDefinitionSchema = exports_external.object({
   id: exports_external.string(),
   description: exports_external.string().nullish(),
-  default: exports_external.any().nullish()
+  default: exports_external.unknown().nullish()
 });
 var WorkflowStepDefinitionSchema = exports_external.object({
   id: exports_external.string(),
@@ -59741,7 +62178,7 @@ var WorkflowStepDefinitionSchema = exports_external.object({
   task: exports_external.string(),
   output: exports_external.string().nullish(),
   expected_outcome: exports_external.string().nullish(),
-  outputSchema: exports_external.any().nullish(),
+  outputSchema: exports_external.unknown().nullish(),
   timeout: exports_external.number().positive().nullish()
 });
 var WhileLoopStepSchema = exports_external.object({
@@ -60290,9 +62727,9 @@ var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
 var freeProcess = moduleExports2 && _freeGlobal_default.process;
 var nodeUtil = function() {
   try {
-    var types3 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
-    if (types3) {
-      return types3;
+    var types4 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types4) {
+      return types4;
     }
     return freeProcess && freeProcess.binding && freeProcess.binding("util");
   } catch (e) {}
@@ -60839,7 +63276,12 @@ function getGlobalConfigPath(home = homedir()) {
 function loadConfigAtPath(path) {
   try {
     return readConfig(path);
-  } catch (_error) {
+  } catch (error48) {
+    if (error48 instanceof ZodError) {
+      console.warn(`Config validation failed for ${path}: ${error48.message}`);
+    } else {
+      console.debug(`Could not load config from ${path}: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
     return;
   }
 }
@@ -60867,7 +63309,7 @@ function mergeConfigs(configs) {
     merged.rules = mergeArray(accRules, configRules);
     merged.excludeFiles = mergeArray(acc.excludeFiles, config3.excludeFiles);
     return merged;
-  });
+  }, {});
   return mergedConfig;
 }
 async function resolveRules(rules) {
@@ -60988,14 +63430,103 @@ var readConfig = (path) => {
 var readLocalConfig = (path) => {
   try {
     return readConfig(path ?? localConfigFileName);
-  } catch (_error) {
+  } catch (error48) {
+    if (error48 instanceof ZodError) {
+      console.warn(`Local config validation failed for ${path ?? localConfigFileName}: ${error48.message}`);
+    } else {
+      console.debug(`Could not load local config from ${path ?? localConfigFileName}: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
     return;
   }
 };
+// src/memory-manager.ts
+class MemoryManager {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  async readMemory(topic) {
+    return this.store.readMemory(topic);
+  }
+  async updateMemory(operation, topic, content, metadata) {
+    return this.store.updateMemory(operation, topic, content, metadata);
+  }
+  async queryMemory(query = {}, options) {
+    const finalQuery = {
+      ...query
+    };
+    const operation = options?.operation;
+    if ((operation === "select" || !operation) && !finalQuery.limit) {
+      finalQuery.limit = 1000;
+    }
+    return this.store.queryMemory(finalQuery, options);
+  }
+  async batchUpdateMemory(operations) {
+    return this.store.batchUpdateMemory(operations);
+  }
+  async getStats() {
+    return this.store.getStats();
+  }
+  async close() {
+    await this.store.close();
+  }
+  async transaction(callback) {
+    const storeWithTransaction = this.store;
+    if (typeof storeWithTransaction.transaction === "function") {
+      return storeWithTransaction.transaction(callback);
+    }
+    return callback();
+  }
+}
+// src/project-scope.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname, normalize, resolve as resolve2, sep } from "node:path";
+function detectProjectScope(cwd) {
+  const projectPath = findProjectRoot(cwd);
+  if (!projectPath) {
+    return "global";
+  }
+  const normalizedPath = normalizePath(projectPath);
+  return `project:${normalizedPath}`;
+}
+function findProjectRoot(dir) {
+  if (!existsSync2(dir)) {
+    return null;
+  }
+  const primaryMarkers = [".git", "package.json"];
+  const secondaryMarkers = [
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    "requirements.txt",
+    "setup.py",
+    "Gemfile",
+    "pom.xml",
+    "build.gradle"
+  ];
+  for (const marker16 of primaryMarkers) {
+    if (existsSync2(resolve2(dir, marker16))) {
+      return dir;
+    }
+  }
+  for (const marker16 of secondaryMarkers) {
+    if (existsSync2(resolve2(dir, marker16))) {
+      return dir;
+    }
+  }
+  const parent = dirname(dir);
+  if (parent === dir) {
+    return null;
+  }
+  return findProjectRoot(parent);
+}
+function normalizePath(path) {
+  return normalize(path).split(sep).join("/");
+}
 // src/provider.ts
 import { spawn as spawn2 } from "node:child_process";
 import { mkdir, readFile as readFile2, rename, unlink, writeFile } from "node:fs/promises";
-import { dirname, normalize, resolve as resolve3 } from "node:path";
+import { dirname as dirname2, normalize as normalize2, resolve as resolve4 } from "node:path";
 
 // ../../node_modules/@ai-sdk/google-vertex/dist/index.mjs
 var import_google_auth_library = __toESM(require_src7(), 1);
@@ -63074,12 +65605,12 @@ function isPlainObject3(value) {
   }
   return Object.getPrototypeOf(value) === proto;
 }
-function deepMerge(...objects) {
+function deepMerge2(...objects) {
   const output = {};
   for (const obj of objects) {
     for (const [key, value] of Object.entries(obj)) {
       const prevValue = output[key];
-      output[key] = isPlainObject3(prevValue) && isPlainObject3(value) ? deepMerge(prevValue, value) : value;
+      output[key] = isPlainObject3(prevValue) && isPlainObject3(value) ? deepMerge2(prevValue, value) : value;
     }
   }
   return output;
@@ -63089,7 +65620,7 @@ function makeTheme(...themes) {
     defaultTheme,
     ...themes.filter((theme) => theme != null)
   ];
-  return deepMerge(...themesToMerge);
+  return deepMerge2(...themesToMerge);
 }
 
 // ../../node_modules/@inquirer/core/dist/lib/use-prefix.js
@@ -63967,13 +66498,13 @@ class ScreenManager {
 // ../../node_modules/@inquirer/core/dist/lib/promise-polyfill.js
 class PromisePolyfill extends Promise {
   static withResolver() {
-    let resolve2;
+    let resolve3;
     let reject;
     const promise2 = new Promise((res, rej) => {
-      resolve2 = res;
+      resolve3 = res;
       reject = rej;
     });
-    return { promise: promise2, resolve: resolve2, reject };
+    return { promise: promise2, resolve: resolve3, reject };
   }
 }
 
@@ -64007,7 +66538,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise: promise2, resolve: resolve2, reject } = PromisePolyfill.withResolver();
+    const { promise: promise2, resolve: resolve3, reject } = PromisePolyfill.withResolver();
     const cancel = () => reject(new CancelPromptError);
     if (signal) {
       const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -64034,7 +66565,7 @@ function createPrompt(view) {
       cycle(() => {
         try {
           const nextView = view(config3, (value) => {
-            setImmediate(() => resolve2(value));
+            setImmediate(() => resolve3(value));
           });
           if (nextView === undefined) {
             const callerFilename = callSites[1]?.getFileName();
@@ -64357,7 +66888,7 @@ function lookup(path) {
   }
   return $types[extension2] || false;
 }
-function populateMaps(extensions, types5) {
+function populateMaps(extensions, types6) {
   Object.keys(db).forEach(function forEachMimeType(type) {
     var mime = db[type];
     var exts = mime.extensions;
@@ -64367,10 +66898,10 @@ function populateMaps(extensions, types5) {
     extensions[type] = exts;
     for (var i2 = 0;i2 < exts.length; i2++) {
       var extension2 = exts[i2];
-      types5[extension2] = _preferredType(extension2, types5[extension2], type);
-      const legacyType = _preferredTypeLegacy(extension2, types5[extension2], type);
-      if (legacyType !== types5[extension2]) {
-        $_extensionConflicts.push([extension2, legacyType, types5[extension2]]);
+      types6[extension2] = _preferredType(extension2, types6[extension2], type);
+      const legacyType = _preferredTypeLegacy(extension2, types6[extension2], type);
+      if (legacyType !== types6[extension2]) {
+        $_extensionConflicts.push([extension2, legacyType, types6[extension2]]);
       }
     }
   });
@@ -64411,7 +66942,7 @@ function checkRipgrep() {
 // src/utils/listFiles.ts
 var import_ignore = __toESM(require_ignore(), 1);
 import { promises as fs3 } from "node:fs";
-import { join as join2, relative, resolve as resolve2 } from "node:path";
+import { join as join2, relative, resolve as resolve3 } from "node:path";
 var DEFAULT_IGNORES = [
   "__pycache__",
   ".DS_Store",
@@ -64454,9 +66985,9 @@ async function listFiles(dirPath, recursive, maxCount, cwd, excludeFiles, includ
   const processedDirs = new Set;
   const queue = [
     {
-      path: resolve2(dirPath),
+      path: resolve3(dirPath),
       patterns: rootPatterns,
-      relPath: relative(cwd, resolve2(dirPath)).replace(/\\/g, "/") || "."
+      relPath: relative(cwd, resolve3(dirPath)).replace(/\\/g, "/") || "."
     }
   ];
   while (queue.length > 0) {
@@ -64537,7 +67068,7 @@ async function searchFiles(path, regex2, filePattern, cwd, excludeFiles) {
     }
   }
   args.push(regex2, path);
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const results = [];
     const rg = spawn("rg", args, {
       cwd,
@@ -64556,7 +67087,7 @@ async function searchFiles(path, regex2, filePattern, cwd, excludeFiles) {
         reject(new Error(`Ripgrep process exited with code ${code}`));
         return;
       }
-      resolve3(results);
+      resolve4(results);
     });
   });
 }
@@ -64571,12 +67102,59 @@ class InMemoryStore {
     this.#data = data;
   }
 }
+function isIMemoryStore(store) {
+  return "readMemory" in store && "updateMemory" in store;
+}
 var getProvider = (options = {}) => {
   const ig = import_ignore2.default().add(options.excludeFiles ?? []);
   const memoryStore = options.memoryStore ?? new InMemoryStore;
   const todoItemStore = options.todoItemStore ?? new InMemoryStore;
   const defaultMemoryTopic = ":default:";
   const searchModel = options.getModel?.("search");
+  const readMemoryKV = async (topic) => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      return data[topic];
+    }
+    return memoryStore.readMemory(topic);
+  };
+  const updateMemoryKV = async (operation, topic, content) => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      switch (operation) {
+        case "append":
+          if (content === undefined) {
+            throw new Error("Content is required for append operation.");
+          }
+          data[topic] = `${data[topic] || ""}
+${content}`;
+          break;
+        case "replace":
+          if (content === undefined) {
+            throw new Error("Content is required for replace operation.");
+          }
+          data[topic] = content;
+          break;
+        case "remove":
+          delete data[topic];
+          break;
+      }
+      await memoryStore.write(data);
+      return;
+    }
+    await memoryStore.updateMemory(operation, topic, content);
+  };
+  const listMemoryTopicsKV = async () => {
+    if (!isIMemoryStore(memoryStore)) {
+      const data = await memoryStore.read() ?? {};
+      return Object.keys(data);
+    }
+    const entries = await memoryStore.queryMemory({});
+    if (Array.isArray(entries)) {
+      return entries.map((e2) => e2.name);
+    }
+    return [];
+  };
   const provider2 = {
     listTodoItems: async (id, status) => {
       const todoItems = await todoItemStore.read() ?? [];
@@ -64675,35 +67253,14 @@ var getProvider = (options = {}) => {
       }
     },
     listMemoryTopics: async () => {
-      const memory = await memoryStore.read() ?? {};
-      return Object.keys(memory);
+      return listMemoryTopicsKV();
     },
     readMemory: async (topic = defaultMemoryTopic) => {
-      const memory = await memoryStore.read() ?? {};
-      return memory[topic];
+      return readMemoryKV(topic);
     },
     updateMemory: async (operation, topic, content) => {
       const memoryTopic = topic ?? defaultMemoryTopic;
-      const memory = await memoryStore.read() ?? {};
-      switch (operation) {
-        case "append":
-          if (content === undefined) {
-            throw new Error("Content is required for append operation.");
-          }
-          memory[memoryTopic] = `${memory[memoryTopic] || ""}
-${content}`;
-          break;
-        case "replace":
-          if (content === undefined) {
-            throw new Error("Content is required for replace operation.");
-          }
-          memory[memoryTopic] = content;
-          break;
-        case "remove":
-          delete memory[memoryTopic];
-          break;
-      }
-      await memoryStore.write(memory);
+      await updateMemoryKV(operation, memoryTopic, content);
     },
     readFile: async (path, includeIgnored) => {
       if (!includeIgnored && ig.ignores(path)) {
@@ -64719,7 +67276,7 @@ ${content}`;
       if (ig.ignores(path)) {
         throw new Error(`Not allow to access file ${path}`);
       }
-      await mkdir(dirname(path), { recursive: true });
+      await mkdir(dirname2(path), { recursive: true });
       return await writeFile(path, content, "utf8");
     },
     removeFile: async (path) => {
@@ -64740,7 +67297,7 @@ ${content}`;
     readBinaryFile: async (url2) => {
       if (url2.startsWith("file://")) {
         const filePath = decodeURIComponent(url2.substring("file://".length));
-        const resolvedPath = normalize(resolve3(process.cwd(), filePath));
+        const resolvedPath = normalize2(resolve4(process.cwd(), filePath));
         if (!resolvedPath.startsWith(process.cwd())) {
           throw new Error(`Access to file path "${filePath}" is restricted.`);
         }
@@ -64763,7 +67320,7 @@ ${content}`;
       };
     },
     executeCommand: (command, _needApprove) => {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve5, reject) => {
         options.command?.onStarted(command);
         const child = spawn2(command, [], {
           shell: true,
@@ -64788,7 +67345,7 @@ ${content}`;
             try {
               const summary = await options.summarizeOutput(stdoutText, stderrText);
               if (summary) {
-                resolve4({
+                resolve5({
                   summary,
                   stdout: stdoutText,
                   stderr: stderrText,
@@ -64800,7 +67357,7 @@ ${content}`;
               console.error("Summarization failed:", _e);
             }
           }
-          resolve4({
+          resolve5({
             stdout: stdoutText,
             stderr: stderrText,
             exitCode: code ?? 0
@@ -64870,6 +67427,634 @@ ${content}`;
   }
   return provider2;
 };
+// src/sqlite-memory-store.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir2, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3, resolve as resolve5 } from "node:path";
+var import_sql = __toESM(require_sql_wasm(), 1);
+
+class FileLock {
+  lockfilePath;
+  static LOCK_TIMEOUT = 30000;
+  constructor(dbPath) {
+    this.lockfilePath = `${dbPath}.lock`;
+  }
+  async acquire(retries = 10, delay2 = 100) {
+    for (let i2 = 0;i2 < retries; i2++) {
+      try {
+        const lockData = JSON.stringify({
+          pid: process.pid,
+          acquiredAt: Date.now()
+        });
+        await writeFile2(this.lockfilePath, lockData, {
+          flag: "wx",
+          mode: 384
+        });
+        return;
+      } catch (error48) {
+        const errorCode = error48?.code;
+        if (errorCode === "EEXIST") {
+          try {
+            const lockContent = await readFile3(this.lockfilePath, "utf-8");
+            const lockData = JSON.parse(lockContent);
+            if (!lockData || typeof lockData.acquiredAt !== "number" || lockData.acquiredAt <= 0) {
+              console.warn(`[FileLock] Lock file has invalid acquiredAt, treating as stale`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.invalid.${Date.now()}`);
+              continue;
+            }
+            const lockAge = Date.now() - lockData.acquiredAt;
+            if (lockAge > FileLock.LOCK_TIMEOUT) {
+              console.warn(`[FileLock] Breaking stale lock (age: ${lockAge}ms)`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.stale.${Date.now()}`);
+              continue;
+            }
+          } catch (readError) {
+            if (readError instanceof SyntaxError) {
+              console.warn(`[FileLock] Lock file contains invalid JSON, treating as stale`);
+              await rename2(this.lockfilePath, `${this.lockfilePath}.corrupt.${Date.now()}`);
+              continue;
+            }
+          }
+          if (i2 < retries - 1) {
+            await new Promise((resolve6) => setTimeout(resolve6, delay2));
+          } else {
+            throw new Error(`Cannot acquire lock after ${retries} retries (file: ${this.lockfilePath})`);
+          }
+        } else {
+          throw error48;
+        }
+      }
+    }
+  }
+  async release() {
+    try {
+      await rename2(this.lockfilePath, `${this.lockfilePath}.released.${Date.now()}`);
+    } catch (error48) {
+      const errorCode = error48.code;
+      if (errorCode !== "ENOENT") {
+        console.warn(`[FileLock] Error releasing lock: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      }
+    }
+  }
+}
+
+class ReentrantMutex {
+  queue = [];
+  locked = false;
+  lockCount = 0;
+  owner = null;
+  async acquire(owner) {
+    if (this.locked && this.owner === owner) {
+      this.lockCount++;
+      return () => this.release(owner);
+    }
+    while (this.locked) {
+      await new Promise((resolve6) => this.queue.push(resolve6));
+    }
+    this.locked = true;
+    this.owner = owner;
+    this.lockCount = 1;
+    return () => this.release(owner);
+  }
+  release(owner) {
+    if (this.owner !== owner) {
+      return;
+    }
+    this.lockCount--;
+    if (this.lockCount === 0) {
+      this.locked = false;
+      this.owner = null;
+      const next = this.queue.shift();
+      if (next) {
+        next();
+      }
+    }
+  }
+}
+var SqlJs = null;
+var SqlJsInitPromise = null;
+async function getSqlJs() {
+  if (SqlJs) {
+    return SqlJs;
+  }
+  if (SqlJsInitPromise) {
+    return SqlJsInitPromise;
+  }
+  SqlJsInitPromise = import_sql.default({});
+  SqlJs = await SqlJsInitPromise;
+  return SqlJs;
+}
+var transactionOwnerStorage = new AsyncLocalStorage2;
+
+class SQLiteMemoryStore {
+  db = null;
+  dbPromise = null;
+  config;
+  currentScope;
+  inTransaction = false;
+  transactionMutex = new ReentrantMutex;
+  fileLock;
+  getDbPath() {
+    return this.config.path || DEFAULT_MEMORY_CONFIG.path;
+  }
+  getFileLock() {
+    if (!this.fileLock) {
+      const dbPath = this.resolvePath(this.getDbPath());
+      this.fileLock = new FileLock(dbPath);
+    }
+    return this.fileLock;
+  }
+  static SORT_COLUMNS = {
+    created: "created_at",
+    updated: "updated_at",
+    accessed: "last_accessed",
+    name: "name"
+  };
+  static ALLOWED_SORT_ORDERS = ["asc", "desc"];
+  static ALLOWED_PRIORITIES = ["low", "medium", "high", "critical"];
+  constructor(config3, scope) {
+    this.config = config3;
+    this.currentScope = scope;
+  }
+  async initializeDatabase() {
+    if (this.dbPromise) {
+      return this.dbPromise;
+    }
+    this.dbPromise = (async () => {
+      if (this.db) {
+        return this.db;
+      }
+      const dbPath = this.resolvePath(this.getDbPath());
+      try {
+        const dir = dirname3(dbPath);
+        if (!existsSync3(dir)) {
+          await mkdir2(dir, { recursive: true, mode: 448 });
+        }
+        let dbData;
+        if (existsSync3(dbPath)) {
+          const lock = this.getFileLock();
+          await lock.acquire();
+          try {
+            try {
+              dbData = await readFile3(dbPath);
+              if (dbData.length >= 16) {
+                const header = String.fromCharCode(...dbData.subarray(0, 15));
+                if (header !== "SQLite format 3") {
+                  console.warn("[SQLiteMemoryStore] Invalid SQLite database header, will recreate");
+                  dbData = undefined;
+                }
+              }
+            } catch (error48) {
+              const errorCode = error48?.code;
+              if (errorCode === "ENOENT") {
+                dbData = undefined;
+              } else {
+                throw new Error(`Failed to read database file at ${dbPath}: ${error48 instanceof Error ? error48.message : String(error48)}`);
+              }
+            }
+          } finally {
+            await lock.release();
+          }
+        }
+        const SqlJs2 = await getSqlJs();
+        const db2 = new SqlJs2.Database(dbData);
+        this.configurePragmas(db2);
+        this.checkIntegrity(db2);
+        this.initializeSchema(db2);
+        this.db = db2;
+        return db2;
+      } catch (error48) {
+        console.error("[SQLiteMemoryStore] Initialization failed:", error48);
+        if (existsSync3(dbPath)) {
+          const backupPath = `${dbPath}.corrupted.${Date.now()}`;
+          console.warn(`[SQLiteMemoryStore] Backing up corrupted database to: ${backupPath}`);
+          try {
+            await rename2(dbPath, backupPath);
+          } catch (backupError) {
+            console.error("[SQLiteMemoryStore] Failed to backup corrupted database:", backupError);
+            this.dbPromise = null;
+            throw backupError;
+          }
+          this.dbPromise = null;
+          return this.initializeDatabase();
+        }
+        this.dbPromise = null;
+        throw error48;
+      }
+    })();
+    return this.dbPromise;
+  }
+  async saveDatabase() {
+    if (!this.db) {
+      return;
+    }
+    const lock = this.getFileLock();
+    await lock.acquire();
+    try {
+      const dbPath = this.resolvePath(this.getDbPath());
+      const tempPath = `${dbPath}.tmp`;
+      const data = this.db.export();
+      await writeFile2(tempPath, data, { mode: 384 });
+      await rename2(tempPath, dbPath);
+    } finally {
+      await lock.release();
+    }
+  }
+  configurePragmas(db2) {
+    db2.run("PRAGMA synchronous = NORMAL");
+    db2.run("PRAGMA busy_timeout = 5000");
+    db2.run("PRAGMA foreign_keys = ON");
+    db2.run("PRAGMA temp_store = MEMORY");
+  }
+  checkIntegrity(db2) {
+    try {
+      const results = db2.exec("SELECT 1");
+      if (results.length === 0) {
+        throw new Error("Database query returned no results");
+      }
+    } catch (error48) {
+      console.error("[SQLiteMemoryStore] Integrity check failed:", error48);
+      throw new Error("Database is corrupted");
+    }
+  }
+  initializeSchema(db2) {
+    db2.run(`
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL CHECK(length(name) > 0),
+        scope TEXT NOT NULL CHECK(scope IN ('global') OR scope LIKE 'project:%'),
+        content TEXT NOT NULL CHECK(length(content) > 0),
+        entry_type TEXT NOT NULL CHECK(length(entry_type) > 0),
+        status TEXT CHECK(status IS NULL OR length(status) > 0),
+        priority TEXT CHECK(priority IS NULL OR priority IN ('low', 'medium', 'high', 'critical')),
+        tags TEXT CHECK(tags IS NULL OR length(tags) > 0),
+        metadata TEXT CHECK(metadata IS NULL OR json_valid(metadata)),
+        created_at INTEGER NOT NULL CHECK(created_at > 0),
+        updated_at INTEGER NOT NULL CHECK(updated_at > 0),
+        last_accessed INTEGER NOT NULL CHECK(last_accessed > 0),
+        UNIQUE(name, scope)
+      )
+    `);
+    db2.run("CREATE INDEX IF NOT EXISTS idx_memory_entries_scope_type ON memory_entries(scope, entry_type)");
+    db2.run("CREATE INDEX IF NOT EXISTS idx_memory_entries_updated ON memory_entries(updated_at)");
+  }
+  async getDatabase() {
+    if (!this.db) {
+      this.db = await this.initializeDatabase();
+    }
+    return this.db;
+  }
+  resolvePath(path) {
+    const resolved = resolveHomePath(path);
+    return resolve5(resolved);
+  }
+  generateUUID() {
+    return randomUUID();
+  }
+  now() {
+    return Date.now();
+  }
+  async transaction(callback) {
+    let owner = transactionOwnerStorage.getStore();
+    if (!owner) {
+      owner = Symbol("transaction");
+    }
+    const release = await this.transactionMutex.acquire(owner);
+    return transactionOwnerStorage.run(owner, async () => {
+      try {
+        const db2 = await this.getDatabase();
+        const shouldBegin = !this.inTransaction;
+        try {
+          if (shouldBegin) {
+            db2.run("BEGIN TRANSACTION");
+            this.inTransaction = true;
+          }
+          const result = await callback();
+          if (shouldBegin) {
+            db2.run("COMMIT");
+            this.inTransaction = false;
+            try {
+              await this.saveDatabase();
+            } catch (saveError) {
+              console.error("[SQLiteMemoryStore] Failed to save database after commit, closing:", saveError);
+              await this.close(true);
+              throw saveError;
+            }
+          }
+          return result;
+        } catch (error48) {
+          if (this.inTransaction) {
+            try {
+              db2.run("ROLLBACK");
+            } catch (rollbackError) {
+              console.error("[SQLiteMemoryStore] ROLLBACK failed:", rollbackError);
+            }
+            this.inTransaction = false;
+          }
+          throw error48;
+        }
+      } finally {
+        release();
+      }
+    });
+  }
+  async readMemory(topic) {
+    const db2 = await this.getDatabase();
+    const scope = this.currentScope;
+    const stmt = db2.prepare("SELECT content FROM memory_entries WHERE name = ? AND scope = ?");
+    stmt.bind([topic, scope]);
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      const content = row.content;
+      stmt.free();
+      return content;
+    }
+    stmt.free();
+    return;
+  }
+  async updateMemoryInternal(db2, operation, topic, content, metadata) {
+    const scope = this.currentScope;
+    const now = this.now();
+    const createdAt = metadata?.created_at ?? now;
+    const updatedAt = metadata?.updated_at ?? now;
+    const lastAccessed = metadata?.last_accessed ?? now;
+    if (operation === "remove") {
+      const stmt2 = db2.prepare("DELETE FROM memory_entries WHERE name = ? AND scope = ?");
+      stmt2.run([topic, scope]);
+      stmt2.free();
+      return;
+    }
+    const stmt = db2.prepare("SELECT content, entry_type, status, priority, tags FROM memory_entries WHERE name = ? AND scope = ?");
+    stmt.bind([topic, scope]);
+    let existing;
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      existing = {
+        content: row.content,
+        entry_type: row.entry_type,
+        status: row.status,
+        priority: row.priority,
+        tags: row.tags
+      };
+      stmt.free();
+    } else {
+      existing = undefined;
+      stmt.free();
+    }
+    let finalContent;
+    let entry_type;
+    let status;
+    let priority;
+    let tags;
+    if (existing) {
+      if (operation === "append") {
+        if (!content) {
+          throw new Error("Content is required for append operation.");
+        }
+        finalContent = `${existing.content}
+${content}`;
+      } else {
+        if (!content) {
+          throw new Error("Content is required for replace operation.");
+        }
+        finalContent = content;
+      }
+      entry_type = metadata?.entry_type || existing.entry_type;
+      status = (metadata?.status || existing.status) ?? undefined;
+      priority = (metadata?.priority || existing.priority) ?? undefined;
+      tags = (metadata?.tags || existing.tags) ?? undefined;
+    } else {
+      if (!content) {
+        throw new Error("Content is required for new memory entries.");
+      }
+      finalContent = content;
+      entry_type = metadata?.entry_type || "note";
+      status = metadata?.status;
+      priority = metadata?.priority;
+      tags = metadata?.tags;
+    }
+    const upsertStmt = db2.prepare(`
+      INSERT INTO memory_entries (id, name, scope, content, entry_type, status, priority, tags, created_at, updated_at, last_accessed)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(name, scope) DO UPDATE SET
+        content = excluded.content,
+        entry_type = excluded.entry_type,
+        status = excluded.status,
+        priority = excluded.priority,
+        tags = excluded.tags,
+        updated_at = excluded.updated_at,
+        last_accessed = excluded.last_accessed
+    `);
+    upsertStmt.run([
+      this.generateUUID(),
+      topic,
+      scope,
+      finalContent,
+      entry_type,
+      status ?? null,
+      priority ?? null,
+      tags ?? null,
+      createdAt,
+      updatedAt,
+      lastAccessed
+    ]);
+    upsertStmt.free();
+  }
+  async updateMemory(operation, topic, content, metadata) {
+    return this.transaction(async () => {
+      const db2 = await this.getDatabase();
+      await this.updateMemoryInternal(db2, operation, topic, content, metadata);
+    });
+  }
+  async queryMemory(query = {}, options = {}) {
+    if (options.operation === "delete") {
+      return this.transaction(async () => {
+        const db3 = await this.getDatabase();
+        const { sql: sql2, params: params2 } = this.buildQuery(query);
+        const deleteSql = `DELETE FROM memory_entries WHERE id IN (SELECT id FROM (${sql2}))`;
+        const stmt2 = db3.prepare(deleteSql);
+        stmt2.bind(params2);
+        stmt2.step();
+        stmt2.free();
+        return db3.getRowsModified();
+      });
+    }
+    const db2 = await this.getDatabase();
+    const { sql, params } = this.buildQuery(query);
+    if (options.operation === "count") {
+      const countSql = `SELECT COUNT(*) as count FROM (${sql})`;
+      const stmt2 = db2.prepare(countSql);
+      stmt2.bind(params);
+      let count = 0;
+      if (stmt2.step()) {
+        const row = stmt2.getAsObject();
+        count = row.count;
+      }
+      stmt2.free();
+      return count;
+    }
+    const stmt = db2.prepare(sql);
+    stmt.bind(params);
+    const entries = [];
+    while (stmt.step()) {
+      entries.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return entries;
+  }
+  buildQuery(query) {
+    const conditions = [];
+    const params = [];
+    let sql = "SELECT * FROM memory_entries WHERE 1=1";
+    const scope = query.scope === "auto" ? this.currentScope : query.scope;
+    if (scope === "global") {
+      conditions.push(`scope = ?`);
+      params.push("global");
+    } else if (scope === "project" || !scope && this.currentScope !== "global") {
+      conditions.push(`scope = ?`);
+      params.push(this.currentScope);
+    }
+    if (query.name) {
+      if (!query.name.trim()) {
+        throw new Error("Name cannot be empty");
+      }
+      conditions.push(`name = ?`);
+      params.push(query.name.trim());
+    }
+    if (query.type) {
+      if (!query.type.trim()) {
+        throw new Error("Type cannot be empty");
+      }
+      conditions.push(`entry_type = ?`);
+      params.push(query.type.trim());
+    }
+    if (query.status) {
+      conditions.push(`status = ?`);
+      params.push(query.status);
+    }
+    if (query.priority) {
+      if (!SQLiteMemoryStore.ALLOWED_PRIORITIES.includes(query.priority)) {
+        throw new Error(`Invalid priority: ${query.priority}`);
+      }
+      conditions.push(`priority = ?`);
+      params.push(query.priority);
+    }
+    if (query.tags) {
+      const tags = Array.isArray(query.tags) ? query.tags : [query.tags];
+      for (const tag of tags) {
+        const trimmed = tag.trim();
+        if (!trimmed) {
+          throw new Error("Tags cannot be empty");
+        }
+        const escaped = trimmed.replace(/[\\_%]/g, "\\$&");
+        conditions.push(`(tags = ? OR tags LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\' OR tags LIKE ? ESCAPE '\\')`);
+        params.push(trimmed, `${escaped},%`, `%,${escaped}`, `%,${escaped},%`);
+      }
+    }
+    if (query.search) {
+      const searchTerm = query.search.trim();
+      conditions.push(`(content LIKE ? ESCAPE '\\' OR name LIKE ? ESCAPE '\\')`);
+      const searchPattern = `%${searchTerm.replace(/[\\_%]/g, "\\$&")}%`;
+      params.push(searchPattern, searchPattern);
+    }
+    if (query.createdAfter) {
+      conditions.push(`created_at >= ?`);
+      params.push(query.createdAfter);
+    }
+    if (query.createdBefore) {
+      conditions.push(`created_at <= ?`);
+      params.push(query.createdBefore);
+    }
+    if (query.updatedAfter) {
+      conditions.push(`updated_at >= ?`);
+      params.push(query.updatedAfter);
+    }
+    if (query.updatedBefore) {
+      conditions.push(`updated_at <= ?`);
+      params.push(query.updatedBefore);
+    }
+    if (conditions.length > 0) {
+      sql += ` AND ${conditions.join(" AND ")}`;
+    }
+    if (query.sortBy) {
+      const column = SQLiteMemoryStore.SORT_COLUMNS[query.sortBy];
+      if (!column) {
+        throw new Error(`Invalid sortBy: ${query.sortBy}`);
+      }
+      const order = query.sortOrder || "desc";
+      if (!SQLiteMemoryStore.ALLOWED_SORT_ORDERS.includes(order)) {
+        throw new Error(`Invalid sortOrder: ${order}`);
+      }
+      sql += ` ORDER BY ${column} ${order.toUpperCase()}`;
+    }
+    if (query.limit) {
+      const limit = Number(query.limit);
+      if (Number.isNaN(limit) || limit < 1 || limit > 1e4) {
+        throw new Error("Limit must be between 1 and 10000");
+      }
+      sql += ` LIMIT ?`;
+      params.push(limit);
+    }
+    if (query.offset) {
+      const offset = Number(query.offset);
+      if (Number.isNaN(offset) || offset < 0) {
+        throw new Error("Offset must be >= 0");
+      }
+      sql += ` OFFSET ?`;
+      params.push(offset);
+    }
+    return { sql, params };
+  }
+  async batchUpdateMemory(operations) {
+    return this.transaction(async () => {
+      const db2 = await this.getDatabase();
+      for (const op of operations) {
+        await this.updateMemoryInternal(db2, op.operation, op.name, op.content, op.metadata);
+      }
+    });
+  }
+  async close(skipSave = false) {
+    const db2 = this.db;
+    if (db2) {
+      try {
+        if (!skipSave) {
+          await this.saveDatabase();
+        }
+      } finally {
+        if (this.db === db2) {
+          db2.close();
+          this.db = null;
+        }
+      }
+    }
+    this.dbPromise = null;
+  }
+  async getStats() {
+    const db2 = await this.getDatabase();
+    const results = db2.exec("SELECT COUNT(*) as count FROM memory_entries");
+    const totalEntries = results[0]?.values[0]?.[0] || 0;
+    const typeResults = db2.exec("SELECT entry_type, COUNT(*) as count FROM memory_entries GROUP BY entry_type");
+    const entriesByType = {};
+    if (typeResults.length > 0) {
+      for (const row of typeResults[0].values) {
+        entriesByType[row[0]] = row[1];
+      }
+    }
+    const dbPath = this.resolvePath(this.getDbPath());
+    let databaseSize = 0;
+    try {
+      const stats = await import("node:fs/promises").then((fs4) => fs4.stat(dbPath));
+      databaseSize = stats.size;
+    } catch {}
+    return {
+      totalEntries,
+      entriesByType,
+      databaseSize
+    };
+  }
+}
 // src/utils/eventHandler.ts
 import { Console } from "node:console";
 
@@ -65363,40 +68548,36 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/utils/parameterSimplifier.ts
-function replaceInFileSimplifier(params) {
-  return { path: params.path };
-}
-function writeToFileSimplifier(params) {
-  return { path: params.path };
-}
-function readFileSimplifier(params) {
-  return { path: params.path, includeIgnored: params.includeIgnored };
-}
-function listFilesSimplifier(params) {
-  const maxCount = params.maxCount;
-  return {
-    path: params.path,
-    recursive: params.recursive,
-    ...maxCount !== 2000 && { maxCount }
+function createSimplifier(keepFields) {
+  return (params) => {
+    const result = {};
+    for (const field of keepFields) {
+      if (params[field] !== undefined) {
+        result[field] = params[field];
+      }
+    }
+    return result;
   };
 }
-function searchFilesSimplifier(params) {
-  return { ...params };
-}
-function executeCommandSimplifier(params) {
-  return { command: params.command, requiresApproval: params.requiresApproval };
-}
-function updateMemorySimplifier(params) {
-  return { operation: params.operation, topic: params.topic };
+function createCustomSimplifier(transform2) {
+  return transform2;
 }
 var SIMPLIFIERS = {
-  replaceInFile: replaceInFileSimplifier,
-  writeToFile: writeToFileSimplifier,
-  readFile: readFileSimplifier,
-  listFiles: listFilesSimplifier,
-  searchFiles: searchFilesSimplifier,
-  executeCommand: executeCommandSimplifier,
-  updateMemory: updateMemorySimplifier
+  replaceInFile: createSimplifier(["path"]),
+  writeToFile: createSimplifier(["path"]),
+  readFile: createSimplifier(["path", "includeIgnored"]),
+  executeCommand: createSimplifier(["command", "requiresApproval"]),
+  updateMemory: createSimplifier(["operation", "topic"]),
+  searchFiles: createCustomSimplifier((params) => ({ ...params })),
+  listFiles: createCustomSimplifier((params) => {
+    const DEFAULT_MAX_COUNT = 2000;
+    const maxCount = params.maxCount;
+    return {
+      path: params.path,
+      recursive: params.recursive,
+      ...maxCount !== DEFAULT_MAX_COUNT && { maxCount }
+    };
+  })
 };
 function simplifyToolParameters(toolName, params) {
   if (params === undefined || params === null) {
@@ -65630,7 +68811,7 @@ Tool error:`, event.tool));
 // src/utils/readMultiline.ts
 import readline3 from "node:readline";
 function readMultiline(prompt = "Enter text (Ctrl+D to finish):") {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     console.log(prompt);
     const rl = readline3.createInterface({
       input: process.stdin,
@@ -65642,7 +68823,7 @@ function readMultiline(prompt = "Enter text (Ctrl+D to finish):") {
       lines.push(line);
     });
     rl.on("close", () => {
-      resolve4(lines.join(`
+      resolve6(lines.join(`
 `));
     });
   });
@@ -65664,7 +68845,10 @@ export {
   listFiles,
   getProvider,
   getGlobalConfigPath,
+  detectProjectScope,
   configSchema,
   checkRipgrep,
+  SQLiteMemoryStore,
+  MemoryManager,
   InMemoryStore
 };