@kb-labs/core-state-daemon 1.7.0 → 1.8.0

package/dist/bin.cjs

@@ -2,7 +2,7 @@
 'use strict';
 
 var crypto = require('crypto');
-var path4 = require('path');
+var path5 = require('path');
 var net = require('net');
 var fs4 = require('fs');
 var os = require('os');
@@ -32,7 +32,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
+var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
 var net__namespace = /*#__PURE__*/_interopNamespace(net);
 var fs4__namespace = /*#__PURE__*/_interopNamespace(fs4);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
@@ -1490,16 +1490,16 @@ var init_dist2 = __esm({
         this.realStorage = realStorage;
         this.analytics = analytics;
       }
-      async read(path32) {
+      async read(path33) {
         const startTime = Date.now();
         const requestId = generateRequestId5();
         try {
-          const result = await this.realStorage.read(path32);
+          const result = await this.realStorage.read(path33);
           const durationMs = Date.now() - startTime;
           const bytesRead = result?.length ?? 0;
           await this.analytics.track("storage.read.completed", {
             requestId,
-            path: path32,
+            path: path33,
             bytesRead,
             durationMs,
             found: result !== null
@@ -1508,50 +1508,50 @@ var init_dist2 = __esm({
         } catch (error48) {
           await this.analytics.track("storage.read.error", {
             requestId,
-            path: path32,
+            path: path33,
             error: error48 instanceof Error ? error48.message : String(error48),
             durationMs: Date.now() - startTime
           });
           throw error48;
         }
       }
-      async write(path32, data) {
+      async write(path33, data) {
         const startTime = Date.now();
         const requestId = generateRequestId5();
         try {
-          await this.realStorage.write(path32, data);
+          await this.realStorage.write(path33, data);
           const durationMs = Date.now() - startTime;
           await this.analytics.track("storage.write.completed", {
             requestId,
-            path: path32,
+            path: path33,
             bytesWritten: data.length,
             durationMs
           });
         } catch (error48) {
           await this.analytics.track("storage.write.error", {
             requestId,
-            path: path32,
+            path: path33,
             error: error48 instanceof Error ? error48.message : String(error48),
             durationMs: Date.now() - startTime
           });
           throw error48;
         }
       }
-      async delete(path32) {
+      async delete(path33) {
         const startTime = Date.now();
         const requestId = generateRequestId5();
         try {
-          await this.realStorage.delete(path32);
+          await this.realStorage.delete(path33);
           const durationMs = Date.now() - startTime;
           await this.analytics.track("storage.delete.completed", {
             requestId,
-            path: path32,
+            path: path33,
             durationMs
           });
         } catch (error48) {
           await this.analytics.track("storage.delete.error", {
             requestId,
-            path: path32,
+            path: path33,
             error: error48 instanceof Error ? error48.message : String(error48),
             durationMs: Date.now() - startTime
           });
@@ -1581,15 +1581,15 @@ var init_dist2 = __esm({
           throw error48;
         }
       }
-      async exists(path32) {
+      async exists(path33) {
         const startTime = Date.now();
         const requestId = generateRequestId5();
         try {
-          const result = await this.realStorage.exists(path32);
+          const result = await this.realStorage.exists(path33);
           const durationMs = Date.now() - startTime;
           await this.analytics.track("storage.exists.completed", {
             requestId,
-            path: path32,
+            path: path33,
             exists: result,
             durationMs
           });
@@ -1597,7 +1597,7 @@ var init_dist2 = __esm({
         } catch (error48) {
           await this.analytics.track("storage.exists.error", {
             requestId,
-            path: path32,
+            path: path33,
             error: error48 instanceof Error ? error48.message : String(error48),
             durationMs: Date.now() - startTime
           });
@@ -1910,7 +1910,7 @@ var init_dist2 = __esm({
         const month = String(date5.getMonth() + 1).padStart(2, "0");
         const year = date5.getFullYear();
         const filename = `${this.filePrefix}${year}${month}${day}-${ts}.jsonl`;
-        return path4__namespace.default.posix.join(this.basePath, filename);
+        return path5__namespace.default.posix.join(this.basePath, filename);
       }
       async enforceRotation() {
         const files = await this.getFilesSorted();
@@ -2023,7 +2023,7 @@ var init_dist2 = __esm({
         const month = String(date5.getMonth() + 1).padStart(2, "0");
         const year = date5.getFullYear();
         const filename = `${this.filePrefix}${year}${month}${day}-${ts}.jsonl`;
-        return path4__namespace.default.posix.join(this.basePath, filename);
+        return path5__namespace.default.posix.join(this.basePath, filename);
       }
       async enforceRotation() {
         const files = await this.getFilesSorted();
@@ -16083,7 +16083,7 @@ var init_dist3 = __esm({
           return { type: "inline", payload: json2 };
         }
         const tempId = `bulk-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        const tempPath = path4.join(opts.tempDir, `${tempId}.json`);
+        const tempPath = path5.join(opts.tempDir, `${tempId}.json`);
         await fs3.writeFile(tempPath, json2, "utf8");
         this.tempFiles.set(tempPath, tempPath);
         return { type: "file", payload: tempPath };
@@ -16968,10 +16968,10 @@ function matchesGlobPattern(filePath, pattern, cwd) {
     return true;
   }
   if (!pattern.includes("*") && !pattern.includes("?")) {
-    const resolvedPattern2 = path4__namespace.resolve(cwd, pattern);
+    const resolvedPattern2 = path5__namespace.resolve(cwd, pattern);
     return filePath.startsWith(resolvedPattern2);
   }
-  const resolvedPattern = path4__namespace.resolve(cwd, pattern);
+  const resolvedPattern = path5__namespace.resolve(cwd, pattern);
   const regex = globToRegex(resolvedPattern);
   return regex.test(filePath);
 }
@@ -16988,7 +16988,7 @@ function createFSShim(options) {
     ...permissions.fs?.write ?? []
   ];
   function normalizePath(filePath) {
-    return path4__namespace.normalize(path4__namespace.resolve(cwd, filePath));
+    return path5__namespace.normalize(path5__namespace.resolve(cwd, filePath));
   }
   function checkDeniedPatterns(normalizedPath) {
     for (const pattern of HARDCODED_DENIED_PATTERNS) {
@@ -17034,7 +17034,7 @@ function createFSShim(options) {
     },
     async writeFile(filePath, content, options2) {
       const resolved = checkWritePermission(filePath);
-      await fs3__namespace.mkdir(path4__namespace.dirname(resolved), { recursive: true });
+      await fs3__namespace.mkdir(path5__namespace.dirname(resolved), { recursive: true });
       const writeOptions = {
         encoding: options2?.encoding ?? "utf-8"
       };
@@ -17090,17 +17090,17 @@ function createFSShim(options) {
     async copy(src, dest) {
       const resolvedSrc = checkReadPermission(src);
       const resolvedDest = checkWritePermission(dest);
-      await fs3__namespace.mkdir(path4__namespace.dirname(resolvedDest), { recursive: true });
+      await fs3__namespace.mkdir(path5__namespace.dirname(resolvedDest), { recursive: true });
       await fs3__namespace.cp(resolvedSrc, resolvedDest, { recursive: true });
     },
     async move(src, dest) {
       const resolvedSrc = checkWritePermission(src);
       const resolvedDest = checkWritePermission(dest);
-      await fs3__namespace.mkdir(path4__namespace.dirname(resolvedDest), { recursive: true });
+      await fs3__namespace.mkdir(path5__namespace.dirname(resolvedDest), { recursive: true });
       await fs3__namespace.rename(resolvedSrc, resolvedDest);
     },
     async glob(pattern, options2) {
-      const searchCwd = options2?.cwd ? path4__namespace.resolve(cwd, options2.cwd) : cwd;
+      const searchCwd = options2?.cwd ? path5__namespace.resolve(cwd, options2.cwd) : cwd;
       const ignorePatterns = options2?.ignore ?? [];
       const matches = [];
       async function walk(dir) {
@@ -17111,8 +17111,8 @@ function createFSShim(options) {
         }
         const entries = await fs3__namespace.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path4__namespace.join(dir, entry.name);
-          const relativePath = path4__namespace.relative(searchCwd, fullPath);
+          const fullPath = path5__namespace.join(dir, entry.name);
+          const relativePath = path5__namespace.relative(searchCwd, fullPath);
           if (ignorePatterns.some((ignore) => matchesGlobPattern(fullPath, ignore, searchCwd))) {
             continue;
           }
@@ -17127,22 +17127,22 @@ function createFSShim(options) {
       return matches;
     },
     resolve(filePath) {
-      return path4__namespace.resolve(cwd, filePath);
+      return path5__namespace.resolve(cwd, filePath);
     },
     relative(filePath) {
-      return path4__namespace.relative(cwd, filePath);
+      return path5__namespace.relative(cwd, filePath);
     },
     join(...segments) {
-      return path4__namespace.join(...segments);
+      return path5__namespace.join(...segments);
     },
     dirname(filePath) {
-      return path4__namespace.dirname(filePath);
+      return path5__namespace.dirname(filePath);
     },
     basename(filePath, ext) {
-      return path4__namespace.basename(filePath, ext);
+      return path5__namespace.basename(filePath, ext);
     },
     extname(filePath) {
-      return path4__namespace.extname(filePath);
+      return path5__namespace.extname(filePath);
     }
   };
 }
@@ -17276,13 +17276,13 @@ function createArtifactsAPI(options) {
     await fs3__namespace.mkdir(outdir, { recursive: true });
   }
   function artifactPath(name) {
-    return path4__namespace.join(outdir, name);
+    return path5__namespace.join(outdir, name);
   }
   return {
     async write(name, content) {
       await ensureOutdir();
       const filePath = artifactPath(name);
-      await fs3__namespace.mkdir(path4__namespace.dirname(filePath), { recursive: true });
+      await fs3__namespace.mkdir(path5__namespace.dirname(filePath), { recursive: true });
       await fs3__namespace.writeFile(filePath, content);
       return filePath;
     },
@@ -17293,7 +17293,7 @@ function createArtifactsAPI(options) {
         const artifacts = [];
         for (const entry of entries) {
           if (entry.isFile()) {
-            const filePath = path4__namespace.join(outdir, entry.name);
+            const filePath = path5__namespace.join(outdir, entry.name);
             const stats = await fs3__namespace.stat(filePath);
             artifacts.push({
               name: entry.name,
@@ -18706,17 +18706,17 @@ async function runInSubprocess(options) {
   const startTime = Date.now();
   return new Promise((resolve22, reject) => {
     const BOOTSTRAP = "bootstrap.js";
-    const currentDir = path4__namespace.dirname(new URL((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))).pathname);
+    const currentDir = path5__namespace.dirname(new URL((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))).pathname);
     const possiblePaths = [
-      path4__namespace.join(currentDir, BOOTSTRAP),
+      path5__namespace.join(currentDir, BOOTSTRAP),
       // Production (same dir)
-      path4__namespace.join(currentDir, "sandbox", BOOTSTRAP),
+      path5__namespace.join(currentDir, "sandbox", BOOTSTRAP),
       // Nested sandbox dir
-      path4__namespace.join(process.cwd(), "dist", "sandbox", BOOTSTRAP),
+      path5__namespace.join(process.cwd(), "dist", "sandbox", BOOTSTRAP),
       // Test/dev mode
-      path4__namespace.join(process.cwd(), "dist", BOOTSTRAP),
+      path5__namespace.join(process.cwd(), "dist", BOOTSTRAP),
       // Fallback
-      path4__namespace.join(process.cwd(), "packages", "plugin-runtime", "dist", "sandbox", BOOTSTRAP)
+      path5__namespace.join(process.cwd(), "packages", "plugin-runtime", "dist", "sandbox", BOOTSTRAP)
       // Monorepo test mode
     ];
     let bootstrapPath;
@@ -19044,7 +19044,7 @@ function getWorkspaceManager(platform2) {
   return platform2.workspaceManager;
 }
 async function tryResolveWorkspaceRootPath(workspaceId) {
-  const registryFile = path4__namespace.default.resolve(process.cwd(), ".kb/runtime/workspace-registry", `${workspaceId}.json`);
+  const registryFile = path5__namespace.default.resolve(process.cwd(), ".kb/runtime/workspace-registry", `${workspaceId}.json`);
   try {
     const raw = await fs3.readFile(registryFile, "utf8");
     const parsed = JSON.parse(raw);
@@ -19518,9 +19518,9 @@ var init_dist5 = __esm({
           });
           const hashIndex = requestToExecute.handlerRef.indexOf("#");
           const relPath = hashIndex > 0 ? requestToExecute.handlerRef.slice(0, hashIndex) : requestToExecute.handlerRef;
-          let handlerPath = path4__namespace.resolve(lease.pluginRoot, relPath);
+          let handlerPath = path5__namespace.resolve(lease.pluginRoot, relPath);
           if (!fs4__namespace.existsSync(handlerPath)) {
-            const distPath = path4__namespace.resolve(lease.pluginRoot, "dist", relPath.replace(/^\.\//, ""));
+            const distPath = path5__namespace.resolve(lease.pluginRoot, "dist", relPath.replace(/^\.\//, ""));
             if (fs4__namespace.existsSync(distPath)) {
               handlerPath = distPath;
             }
@@ -19702,9 +19702,9 @@ var init_dist5 = __esm({
           });
           const hashIndex = requestToExecute.handlerRef.indexOf("#");
           const relPath = hashIndex > 0 ? requestToExecute.handlerRef.slice(0, hashIndex) : requestToExecute.handlerRef;
-          let handlerPath = path4__namespace.resolve(lease.pluginRoot, relPath);
+          let handlerPath = path5__namespace.resolve(lease.pluginRoot, relPath);
           if (!fs4__namespace.existsSync(handlerPath)) {
-            const distPath = path4__namespace.resolve(lease.pluginRoot, "dist", relPath.replace(/^\.\//, ""));
+            const distPath = path5__namespace.resolve(lease.pluginRoot, "dist", relPath.replace(/^\.\//, ""));
             if (fs4__namespace.existsSync(distPath)) {
               handlerPath = distPath;
             }
@@ -20763,7 +20763,7 @@ var init_dist5 = __esm({
         await this.lifecycleManager.shutdown(timeoutMs);
       }
     };
-    __dirname$1 = path4__namespace.dirname(url$1.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
+    __dirname$1 = path5__namespace.dirname(url$1.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
     WorkerPoolBackend = class {
       pool = null;
       startTime = Date.now();
@@ -20779,7 +20779,7 @@ var init_dist5 = __esm({
       constructor(options) {
         this.platform = options.platform;
         this.uiProvider = options.uiProvider ?? (() => noopUI);
-        this.workerScript = options.workerScript ?? path4__namespace.join(__dirname$1, "backends", "worker-pool", "worker-script.js");
+        this.workerScript = options.workerScript ?? path5__namespace.join(__dirname$1, "backends", "worker-pool", "worker-script.js");
         this.config = {
           min: options.min ?? 2,
           max: options.max ?? 10,
@@ -27615,7 +27615,7 @@ var require_transport = __commonJS({
     var { existsSync: existsSync6 } = __require("fs");
     var getCallers = require_caller();
     var { join: join6, isAbsolute, sep: sep2 } = __require("path");
-    var { fileURLToPath: fileURLToPath2 } = __require("url");
+    var { fileURLToPath: fileURLToPath3 } = __require("url");
     var sleep3 = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
     var ThreadStream = require_thread_stream();
@@ -27681,7 +27681,7 @@ var require_transport = __commonJS({
       let path6 = unquoted;
       if (path6.startsWith("file://")) {
         try {
-          path6 = fileURLToPath2(path6);
+          path6 = fileURLToPath3(path6);
         } catch {
           return false;
         }
@@ -48661,7 +48661,7 @@ var require_util3 = __commonJS({
     exports$1.esc = esc2;
     exports$1.slugify = slugify2;
     exports$1.isObject = isObject3;
-    exports$1.isPlainObject = isPlainObject2;
+    exports$1.isPlainObject = isPlainObject3;
     exports$1.shallowClone = shallowClone2;
     exports$1.numKeys = numKeys2;
     exports$1.escapeRegex = escapeRegex2;
@@ -48804,8 +48804,8 @@ var require_util3 = __commonJS({
     }
     function promiseAllObject2(promisesObj) {
       const keys = Object.keys(promisesObj);
-      const promises4 = keys.map((key) => promisesObj[key]);
-      return Promise.all(promises4).then((results) => {
+      const promises5 = keys.map((key) => promisesObj[key]);
+      return Promise.all(promises5).then((results) => {
         const resolvedObj = {};
         for (let i = 0; i < keys.length; i++) {
           resolvedObj[keys[i]] = results[i];
@@ -48844,7 +48844,7 @@ var require_util3 = __commonJS({
         return false;
       }
     });
-    function isPlainObject2(o) {
+    function isPlainObject3(o) {
       if (isObject3(o) === false)
         return false;
       const ctor = o.constructor;
@@ -48861,7 +48861,7 @@ var require_util3 = __commonJS({
       return true;
     }
     function shallowClone2(o) {
-      if (isPlainObject2(o))
+      if (isPlainObject3(o))
         return { ...o };
       if (Array.isArray(o))
         return [...o];
@@ -49055,7 +49055,7 @@ var require_util3 = __commonJS({
       return clone2(schema, def);
     }
     function extend2(schema, shape) {
-      if (!isPlainObject2(shape)) {
+      if (!isPlainObject3(shape)) {
         throw new Error("Invalid input to extend: expected a plain object");
       }
       const checks = schema._zod.def.checks;
@@ -49078,7 +49078,7 @@ var require_util3 = __commonJS({
       return clone2(schema, def);
     }
     function safeExtend2(schema, shape) {
-      if (!isPlainObject2(shape)) {
+      if (!isPlainObject3(shape)) {
         throw new Error("Invalid input to safeExtend: expected a plain object");
       }
       const def = mergeDefs2(schema._zod.def, {
@@ -65354,12 +65354,12 @@ var MemoryEventBus = class {
     if (!topicHandlers) {
       return;
     }
-    const promises4 = Array.from(topicHandlers).map(
+    const promises5 = Array.from(topicHandlers).map(
       (handler) => handler(event).catch((err) => {
         console.error(`[EventBus] Handler error for topic "${topic}":`, err);
       })
     );
-    await Promise.all(promises4);
+    await Promise.all(promises5);
   }
   subscribe(topic, handler) {
     let topicHandlers = this.handlers.get(topic);
@@ -65704,7 +65704,7 @@ var DiagnosticCollector = class {
 var LOCK_FILE = ".kb/marketplace.lock";
 var SCHEMA_VERSION = "kb.marketplace/2";
 async function readMarketplaceLock(root, diag) {
-  const lockPath = path4__namespace.join(root, LOCK_FILE);
+  const lockPath = path5__namespace.join(root, LOCK_FILE);
   let raw;
   try {
     raw = await fs3__namespace.readFile(lockPath, "utf-8");
@@ -66935,6 +66935,98 @@ function createQueuedVectorStore(broker, vectorStore) {
   return new QueuedVectorStore(broker, vectorStore);
 }
 
+// ../../../../node_modules/.pnpm/ulid@2.4.0/node_modules/ulid/dist/index.esm.js
+function createError(message) {
+  const err = new Error(message);
+  err.source = "ulid";
+  return err;
+}
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_MAX = Math.pow(2, 48) - 1;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function randomChar(prng) {
+  let rand = Math.floor(prng() * ENCODING_LEN);
+  if (rand === ENCODING_LEN) {
+    rand = ENCODING_LEN - 1;
+  }
+  return ENCODING.charAt(rand);
+}
+function encodeTime(now, len) {
+  if (isNaN(now)) {
+    throw new Error(now + " must be a number");
+  }
+  if (now > TIME_MAX) {
+    throw createError("cannot encode time greater than " + TIME_MAX);
+  }
+  if (now < 0) {
+    throw createError("time must be positive");
+  }
+  if (Number.isInteger(Number(now)) === false) {
+    throw createError("time must be an integer");
+  }
+  let mod;
+  let str = "";
+  for (; len > 0; len--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING.charAt(mod) + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len, prng) {
+  let str = "";
+  for (; len > 0; len--) {
+    str = randomChar(prng) + str;
+  }
+  return str;
+}
+function detectPrng(allowInsecure = false, root) {
+  if (!root) {
+    root = typeof window !== "undefined" ? window : null;
+  }
+  const browserCrypto = root && (root.crypto || root.msCrypto);
+  if (browserCrypto) {
+    return () => {
+      const buffer = new Uint8Array(1);
+      browserCrypto.getRandomValues(buffer);
+      return buffer[0] / 255;
+    };
+  } else {
+    try {
+      const nodeCrypto = __require("crypto");
+      return () => nodeCrypto.randomBytes(1).readUInt8() / 255;
+    } catch (e) {
+    }
+  }
+  if (allowInsecure) {
+    try {
+      console.error("secure crypto unusable, falling back to insecure Math.random()!");
+    } catch (e) {
+    }
+    return () => Math.random();
+  }
+  throw createError("secure crypto unusable, insecure Math.random not allowed");
+}
+function factory(currPrng) {
+  if (!currPrng) {
+    currPrng = detectPrng();
+  }
+  return function ulid4(seedTime) {
+    if (isNaN(seedTime)) {
+      seedTime = Date.now();
+    }
+    return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, currPrng);
+  };
+}
+factory();
+
+// ../core-platform/dist/adapters/index.js
+function isDisposable2(value) {
+  return typeof value === "object" && value !== null && "dispose" in value && typeof value.dispose === "function";
+}
+
 // ../core-config/dist/index.js
 __toESM(require_dist());
 
@@ -70981,32 +71073,6 @@ var NEVER = INVALID;
 // ../core-config/dist/index.js
 var import_ajv = __toESM(require_ajv());
 var import_ajv_formats = __toESM(require_dist2());
-async function findNearestConfig(opts) {
-  const start = path4__namespace.default.resolve(opts.startDir ?? process.cwd());
-  const stop = opts.stopDir ? path4__namespace.default.resolve(opts.stopDir) : null;
-  const tried = [];
-  let dir = start;
-  while (true) {
-    for (const name of opts.filenames) {
-      const candidate = path4__namespace.default.join(dir, name);
-      tried.push(candidate);
-      try {
-        await fs4.promises.access(candidate);
-        return { path: candidate, tried };
-      } catch {
-      }
-    }
-    const parent = path4__namespace.default.dirname(dir);
-    if (parent === dir) {
-      break;
-    }
-    if (stop && (dir === stop || parent === stop)) {
-      break;
-    }
-    dir = parent;
-  }
-  return { path: null, tried };
-}
 async function readJsonWithDiagnostics(p) {
   const diagnostics = [];
   try {
@@ -71023,6 +71089,34 @@ async function readJsonWithDiagnostics(p) {
     return { ok: false, diagnostics };
   }
 }
+function mergeDefined(base, over) {
+  if (!over) {
+    return base;
+  }
+  if (Array.isArray(base) && Array.isArray(over)) {
+    return [...base, ...over.filter((v) => v !== void 0)];
+  }
+  if (isPlainObject(base) && isPlainObject(over)) {
+    const out = { ...base };
+    for (const [k, v] of Object.entries(over)) {
+      if (v === void 0) {
+        continue;
+      }
+      if (isPlainObject(base[k]) && isPlainObject(v)) {
+        out[k] = mergeDefined(base[k], v);
+      } else if (Array.isArray(base[k]) && Array.isArray(v)) {
+        out[k] = mergeDefined(base[k], v);
+      } else {
+        out[k] = v;
+      }
+    }
+    return out;
+  }
+  return over ?? base;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && Object.getPrototypeOf(v) === Object.prototype;
+}
 var GlobSchema = external_exports.string().min(1, "Glob pattern must be a non-empty string");
 var ProductOverridesSchema = external_exports.record(external_exports.string(), external_exports.unknown());
 var ProductsMapSchema = external_exports.record(external_exports.string(), ProductOverridesSchema);
@@ -71088,97 +71182,223 @@ external_exports.object({
 module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href)));
 var ajv = new import_ajv.default({ allErrors: true, strict: false });
 (0, import_ajv_formats.default)(ajv);
+async function findRepoRoot(startDir = process.cwd()) {
+  const markersPriority = ["pnpm-workspace.yaml", ".git", "package.json"];
+  for (const marker of markersPriority) {
+    let dir = path5__namespace.default.resolve(startDir);
+    while (true) {
+      try {
+        await fs4.promises.access(path5__namespace.default.join(dir, marker));
+        return dir;
+      } catch {
+      }
+      const parent = path5__namespace.default.dirname(dir);
+      if (parent === dir) {
+        break;
+      }
+      dir = parent;
+    }
+  }
+  return path5__namespace.default.resolve(startDir);
+}
 
-// ../../../../node_modules/.pnpm/ulid@2.4.0/node_modules/ulid/dist/index.esm.js
-function createError(message) {
-  const err = new Error(message);
-  err.source = "ulid";
-  return err;
+// ../core-workspace/dist/index.js
+var WORKSPACE_CONFIG_RELATIVE = path5__namespace.default.join(".kb", "kb.config.json");
+var PLATFORM_PACKAGE_MARKERS = [
+  "@kb-labs/cli-bin",
+  "@kb-labs/core-runtime"
+];
+var defaultFs = {
+  async exists(target) {
+    try {
+      await fs4.promises.access(target);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function resolveProjectEnvRoot(env) {
+  if (!env) {
+    return void 0;
+  }
+  return env.KB_PROJECT_ROOT ?? env.KB_LABS_WORKSPACE_ROOT ?? env.KB_LABS_REPO_ROOT;
 }
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ENCODING_LEN = ENCODING.length;
-var TIME_MAX = Math.pow(2, 48) - 1;
-var TIME_LEN = 10;
-var RANDOM_LEN = 16;
-function randomChar(prng) {
-  let rand = Math.floor(prng() * ENCODING_LEN);
-  if (rand === ENCODING_LEN) {
-    rand = ENCODING_LEN - 1;
+async function findConfigRoot(startDir, fs5) {
+  let current = path5__namespace.default.resolve(startDir);
+  while (true) {
+    const configPath = path5__namespace.default.join(current, WORKSPACE_CONFIG_RELATIVE);
+    if (await fs5.exists(configPath)) {
+      return current;
+    }
+    const parent = path5__namespace.default.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
   }
-  return ENCODING.charAt(rand);
 }
-function encodeTime(now, len) {
-  if (isNaN(now)) {
-    throw new Error(now + " must be a number");
+async function resolveProjectRoot(options = {}) {
+  const {
+    cwd,
+    env = process.env,
+    fs: fs5 = defaultFs,
+    startDir = process.cwd()
+  } = options;
+  if (cwd) {
+    return {
+      rootDir: path5__namespace.default.resolve(cwd),
+      source: "explicit"
+    };
   }
-  if (now > TIME_MAX) {
-    throw createError("cannot encode time greater than " + TIME_MAX);
+  const envRoot = resolveProjectEnvRoot(env);
+  if (envRoot) {
+    return {
+      rootDir: path5__namespace.default.resolve(envRoot),
+      source: "env"
+    };
   }
-  if (now < 0) {
-    throw createError("time must be positive");
+  const configRoot = await findConfigRoot(startDir, fs5);
+  if (configRoot) {
+    return {
+      rootDir: configRoot,
+      source: "config"
+    };
   }
-  if (Number.isInteger(Number(now)) === false) {
-    throw createError("time must be an integer");
+  try {
+    const repoRoot = await findRepoRoot(startDir);
+    const resolvedRepo = path5__namespace.default.resolve(repoRoot);
+    const fsRoot = path5__namespace.default.parse(resolvedRepo).root;
+    if (resolvedRepo !== fsRoot) {
+      return {
+        rootDir: resolvedRepo,
+        source: "repo"
+      };
+    }
+  } catch {
   }
-  let mod;
-  let str = "";
-  for (; len > 0; len--) {
-    mod = now % ENCODING_LEN;
-    str = ENCODING.charAt(mod) + str;
-    now = (now - mod) / ENCODING_LEN;
+  return {
+    rootDir: path5__namespace.default.resolve(startDir),
+    source: "fallback"
+  };
+}
+async function hasPlatformMarker(candidate, fs5) {
+  for (const marker of PLATFORM_PACKAGE_MARKERS) {
+    const markerPath = path5__namespace.default.join(candidate, "node_modules", marker);
+    if (await fs5.exists(markerPath)) {
+      return true;
+    }
   }
-  return str;
+  return false;
 }
-function encodeRandom(len, prng) {
-  let str = "";
-  for (; len > 0; len--) {
-    str = randomChar(prng) + str;
+async function walkUpForPlatformMarker(startDir, fs5) {
+  let current = path5__namespace.default.resolve(startDir);
+  while (true) {
+    if (await hasPlatformMarker(current, fs5)) {
+      return current;
+    }
+    if (await fs5.exists(path5__namespace.default.join(current, "pnpm-workspace.yaml"))) {
+      return current;
+    }
+    const parent = path5__namespace.default.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
   }
-  return str;
 }
-function detectPrng(allowInsecure = false, root) {
-  if (!root) {
-    root = typeof window !== "undefined" ? window : null;
+async function resolvePlatformRootFromModuleUrl(moduleUrl, fs5) {
+  let modulePath;
+  try {
+    modulePath = url$1.fileURLToPath(moduleUrl);
+  } catch {
+    return void 0;
   }
-  const browserCrypto = root && (root.crypto || root.msCrypto);
-  if (browserCrypto) {
-    return () => {
-      const buffer = new Uint8Array(1);
-      browserCrypto.getRandomValues(buffer);
-      return buffer[0] / 255;
-    };
-  } else {
-    try {
-      const nodeCrypto = __require("crypto");
-      return () => nodeCrypto.randomBytes(1).readUInt8() / 255;
-    } catch (e) {
+  let current = path5__namespace.default.dirname(modulePath);
+  let firstMarkerHit;
+  let topMostWorkspace;
+  while (true) {
+    if (!firstMarkerHit && await hasPlatformMarker(current, fs5)) {
+      firstMarkerHit = current;
     }
-  }
-  if (allowInsecure) {
-    try {
-      console.error("secure crypto unusable, falling back to insecure Math.random()!");
-    } catch (e) {
+    if (await fs5.exists(path5__namespace.default.join(current, "pnpm-workspace.yaml"))) {
+      topMostWorkspace = current;
     }
-    return () => Math.random();
+    const parent = path5__namespace.default.dirname(current);
+    if (parent === current) {
+      return topMostWorkspace ?? firstMarkerHit;
+    }
+    current = parent;
   }
-  throw createError("secure crypto unusable, insecure Math.random not allowed");
 }
-function factory(currPrng) {
-  if (!currPrng) {
-    currPrng = detectPrng();
+async function resolvePlatformRoot(options = {}) {
+  const {
+    cwd,
+    moduleUrl,
+    env = process.env,
+    fs: fs5 = defaultFs,
+    startDir = process.cwd()
+  } = options;
+  if (cwd) {
+    return {
+      rootDir: path5__namespace.default.resolve(cwd),
+      source: "explicit"
+    };
   }
-  return function ulid4(seedTime) {
-    if (isNaN(seedTime)) {
-      seedTime = Date.now();
+  const envRoot = env?.KB_PLATFORM_ROOT;
+  if (envRoot) {
+    return {
+      rootDir: path5__namespace.default.resolve(envRoot),
+      source: "env"
+    };
+  }
+  if (moduleUrl) {
+    const fromModule = await resolvePlatformRootFromModuleUrl(moduleUrl, fs5);
+    if (fromModule) {
+      return {
+        rootDir: fromModule,
+        source: "module"
+      };
     }
-    return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, currPrng);
+  }
+  const fromMarker = await walkUpForPlatformMarker(startDir, fs5);
+  if (fromMarker) {
+    return {
+      rootDir: fromMarker,
+      source: "marker"
+    };
+  }
+  try {
+    const repoRoot = await findRepoRoot(startDir);
+    const resolvedRepo = path5__namespace.default.resolve(repoRoot);
+    const fsRoot = path5__namespace.default.parse(resolvedRepo).root;
+    if (resolvedRepo !== fsRoot) {
+      return {
+        rootDir: resolvedRepo,
+        source: "repo"
+      };
+    }
+  } catch {
+  }
+  return {
+    rootDir: path5__namespace.default.resolve(startDir),
+    source: "fallback"
   };
 }
-factory();
-
-// ../core-platform/dist/adapters/index.js
-function isDisposable2(value) {
-  return typeof value === "object" && value !== null && "dispose" in value && typeof value.dispose === "function";
+async function resolveRoots(options = {}) {
+  const [platform2, project] = await Promise.all([
+    resolvePlatformRoot(options),
+    resolveProjectRoot(options)
+  ]);
+  return {
+    platformRoot: platform2.rootDir,
+    projectRoot: project.rootDir,
+    sameLocation: path5__namespace.default.resolve(platform2.rootDir) === path5__namespace.default.resolve(project.rootDir),
+    sources: {
+      platform: platform2.source,
+      project: project.source
+    }
+  };
 }
 
 // ../core-runtime/dist/index.js
@@ -71957,15 +72177,15 @@ async function discoverAdapters(cwd) {
     if (entry.enabled === false) {
       continue;
     }
-    const pkgRoot = path4__namespace.default.resolve(cwd, entry.resolvedPath);
+    const pkgRoot = path5__namespace.default.resolve(cwd, entry.resolvedPath);
     let mainPath = "dist/index.js";
     try {
-      const pkgContent = await fs4.promises.readFile(path4__namespace.default.join(pkgRoot, "package.json"), "utf-8");
+      const pkgContent = await fs4.promises.readFile(path5__namespace.default.join(pkgRoot, "package.json"), "utf-8");
       const pkg = JSON.parse(pkgContent);
       mainPath = pkg.main || mainPath;
     } catch {
     }
-    const distPath = path4__namespace.default.join(pkgRoot, mainPath);
+    const distPath = path5__namespace.default.join(pkgRoot, mainPath);
     try {
       await fs4.promises.access(distPath);
       const module = await loadAdapterModule(distPath);
@@ -71989,7 +72209,7 @@ async function resolveAdapter(adapterPath, cwd) {
   const subpath = adapterPath.includes("/") ? adapterPath.split("/").slice(2).join("/") : null;
   const adapter = discovered.get(basePkgName);
   if (adapter && subpath) {
-    const subpathFile = path4__namespace.default.join(adapter.pkgRoot, "dist", `${subpath}.js`);
+    const subpathFile = path5__namespace.default.join(adapter.pkgRoot, "dist", `${subpath}.js`);
     try {
       await fs4.promises.access(subpathFile);
       const module = await loadAdapterModule(subpathFile);
@@ -72415,7 +72635,7 @@ var init_bulk_transfer = __esm2({
           return { type: "inline", payload: json2 };
         }
         const tempId = `bulk-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        const tempPath = path4.join(opts.tempDir, `${tempId}.json`);
+        const tempPath = path5.join(opts.tempDir, `${tempId}.json`);
         await fs3.writeFile(tempPath, json2, "utf8");
         this.tempFiles.set(tempPath, tempPath);
         return { type: "file", payload: tempPath };
@@ -72454,7 +72674,7 @@ var init_bulk_transfer = __esm2({
        */
       static async cleanup() {
         const cleanupPromises = Array.from(this.tempFiles.values()).map(
-          (path42) => fs3.unlink(path42).catch(() => {
+          (path52) => fs3.unlink(path52).catch(() => {
           })
         );
         await Promise.all(cleanupPromises);
@@ -72471,9 +72691,9 @@ var init_bulk_transfer = __esm2({
       }
     };
     process.on("exit", () => {
-      for (const path42 of BulkTransferHelper2.getStats().tempFilePaths) {
+      for (const path52 of BulkTransferHelper2.getStats().tempFilePaths) {
         try {
-          fs4.unlinkSync(path42);
+          fs4.unlinkSync(path52);
         } catch {
         }
       }
@@ -72961,8 +73181,8 @@ var init_storage_proxy = __esm2({
        * @param path - File path
        * @returns File contents or null if not found
        */
-      async read(path42) {
-        return await this.callRemote("read", [path42]);
+      async read(path52) {
+        return await this.callRemote("read", [path52]);
       }
       /**
        * Write file contents.
@@ -72970,16 +73190,16 @@ var init_storage_proxy = __esm2({
        * @param path - File path
        * @param data - File contents
        */
-      async write(path42, data) {
-        await this.callRemote("write", [path42, data]);
+      async write(path52, data) {
+        await this.callRemote("write", [path52, data]);
       }
       /**
        * Delete a file.
        *
        * @param path - File path
        */
-      async delete(path42) {
-        await this.callRemote("delete", [path42]);
+      async delete(path52) {
+        await this.callRemote("delete", [path52]);
       }
       /**
        * List files matching a prefix.
@@ -72996,8 +73216,8 @@ var init_storage_proxy = __esm2({
        * @param path - File path
        * @returns True if file exists, false otherwise
        */
-      async exists(path42) {
-        return await this.callRemote("exists", [path42]);
+      async exists(path52) {
+        return await this.callRemote("exists", [path52]);
       }
       // ═══════════════════════════════════════════════════════════════════════
       // EXTENDED METHODS (optional - implements IStorage extended interface)
@@ -73009,8 +73229,8 @@ var init_storage_proxy = __esm2({
        * @param path - File path
        * @returns File metadata or null if not found
        */
-      async stat(path42) {
-        return await this.callRemote("stat", [path42]);
+      async stat(path52) {
+        return await this.callRemote("stat", [path52]);
       }
       /**
        * Copy file within storage.
@@ -73370,7 +73590,7 @@ async function createAnalyticsContext(cwd) {
 }
 async function detectSource(cwd) {
   try {
-    const pkgPath = path4.join(cwd, "package.json");
+    const pkgPath = path5.join(cwd, "package.json");
     const pkgContent = await fs3.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     return {
@@ -75760,7 +75980,7 @@ async function initPlatform(config2 = {}, cwd = process.cwd(), uiProvider) {
           const subpath = modulePath.includes("/") && modulePath.split("/").length > 2 ? modulePath.split("/").slice(2).join("/") : null;
           const adapter = discovered.get(basePkgName);
           if (adapter && subpath) {
-            const subpathFile = path4__namespace.default.join(adapter.pkgRoot, "dist", `${subpath}.js`);
+            const subpathFile = path5__namespace.default.join(adapter.pkgRoot, "dist", `${subpath}.js`);
             try {
               await fs4.promises.access(subpathFile);
               const module = await import(url$1.pathToFileURL(subpathFile).href);
@@ -75779,7 +75999,7 @@ async function initPlatform(config2 = {}, cwd = process.cwd(), uiProvider) {
               return { createAdapter: factory2, manifest: manifest2 };
             } catch (err) {
               const baseModule = await import(url$1.pathToFileURL(
-                path4__namespace.default.join(adapter.pkgRoot, "dist", "index.js")
+                path5__namespace.default.join(adapter.pkgRoot, "dist", "index.js")
               ).href);
               const factory2 = baseModule.createAdapter || baseModule.default;
               const manifest2 = baseModule.manifest;
@@ -75797,7 +76017,7 @@ async function initPlatform(config2 = {}, cwd = process.cwd(), uiProvider) {
             }
           } else if (adapter) {
             const module = await import(url$1.pathToFileURL(
-              path4__namespace.default.join(adapter.pkgRoot, "dist", "index.js")
+              path5__namespace.default.join(adapter.pkgRoot, "dist", "index.js")
             ).href);
             const factory2 = module.createAdapter || module.default;
             const manifest2 = module.manifest;
@@ -76262,11 +76482,12 @@ async function initPlatform(config2 = {}, cwd = process.cwd(), uiProvider) {
   }
 }
 init_container();
-var _initialized = false;
-var _registeredHooks = /* @__PURE__ */ new Set();
-var _signalHandlersRegistered = false;
-function _loadEnvFile(dir) {
-  const envPath = path4__namespace.default.join(dir, ".env");
+var CONFIG_RELATIVE_PATHS = [
+  path5__namespace.default.join(".kb", "kb.config.json"),
+  "kb.config.json"
+];
+function loadEnvFile(dir) {
+  const envPath = path5__namespace.default.join(dir, ".env");
   if (!fs4.existsSync(envPath)) {
     return;
   }
@@ -76289,10 +76510,88 @@ function _loadEnvFile(dir) {
   } catch {
   }
 }
-function _resolvePlatformRoot(configPath) {
-  const configDir = path4__namespace.default.dirname(configPath);
-  return path4__namespace.default.basename(configDir) === ".kb" ? path4__namespace.default.dirname(configDir) : configDir;
+function findConfigAtRoot(root) {
+  for (const rel of CONFIG_RELATIVE_PATHS) {
+    const full = path5__namespace.default.join(root, rel);
+    if (fs4.existsSync(full)) {
+      return full;
+    }
+  }
+  return void 0;
+}
+async function readConfigFile(configPath) {
+  const result = await readJsonWithDiagnostics(configPath);
+  if (!result.ok) {
+    return {};
+  }
+  const data = result.data;
+  return {
+    platformSection: data.platform,
+    rawConfig: data
+  };
+}
+async function loadPlatformConfig(options = {}) {
+  const {
+    moduleUrl,
+    startDir = process.cwd(),
+    env = process.env,
+    loadEnvFile: shouldLoadEnv = true
+  } = options;
+  const roots = await resolveRoots({
+    moduleUrl,
+    startDir,
+    env
+  });
+  if (shouldLoadEnv) {
+    loadEnvFile(roots.projectRoot);
+  }
+  const platformConfigPath = findConfigAtRoot(roots.platformRoot);
+  const projectConfigPath = findConfigAtRoot(roots.projectRoot);
+  let platformDefaults;
+  let projectPlatformConfig;
+  let rawProjectConfig;
+  let platformDefaultsSource;
+  let projectConfigSource;
+  const samePath = !!platformConfigPath && !!projectConfigPath && path5__namespace.default.resolve(platformConfigPath) === path5__namespace.default.resolve(projectConfigPath);
+  if (samePath && projectConfigPath) {
+    const { platformSection, rawConfig } = await readConfigFile(projectConfigPath);
+    projectPlatformConfig = platformSection;
+    rawProjectConfig = rawConfig;
+    projectConfigSource = projectConfigPath;
+  } else {
+    if (platformConfigPath) {
+      const { platformSection } = await readConfigFile(platformConfigPath);
+      platformDefaults = platformSection;
+      platformDefaultsSource = platformConfigPath;
+    }
+    if (projectConfigPath) {
+      const { platformSection, rawConfig } = await readConfigFile(projectConfigPath);
+      projectPlatformConfig = platformSection;
+      rawProjectConfig = rawConfig;
+      projectConfigSource = projectConfigPath;
+    }
+  }
+  const base = { adapters: {} };
+  const effective = mergeDefined(
+    mergeDefined(base, platformDefaults),
+    projectPlatformConfig
+  );
+  return {
+    platformConfig: effective,
+    rawConfig: rawProjectConfig,
+    platformRoot: roots.platformRoot,
+    projectRoot: roots.projectRoot,
+    sameLocation: roots.sameLocation,
+    sources: {
+      platformDefaults: platformDefaultsSource,
+      projectConfig: projectConfigSource,
+      roots: roots.sources
+    }
+  };
 }
+var _initialized = false;
+var _registeredHooks = /* @__PURE__ */ new Set();
+var _signalHandlersRegistered = false;
 function _ensureSignalHandlers(appId) {
   if (_signalHandlersRegistered) {
     return;
@@ -76358,51 +76657,41 @@ async function createServiceBootstrap(options) {
   if (_initialized) {
     return platform;
   }
-  if (loadEnv) {
-    _loadEnvFile(repoRoot);
-  }
   try {
-    const { path: configPath } = await findNearestConfig({
+    const {
+      platformConfig,
+      rawConfig,
+      platformRoot,
+      projectRoot,
+      sources
+    } = await loadPlatformConfig({
       startDir: repoRoot,
-      filenames: [".kb/kb.config.json", "kb.config.json"]
+      loadEnvFile: loadEnv
     });
-    if (!configPath) {
-      process.stderr.write(`[${appId}:platform] No kb.config.json found, using NoOp adapters
-`);
-      await initPlatform({ adapters: {} }, repoRoot);
-      _initialized = true;
-      return platform;
-    }
-    const result = await readJsonWithDiagnostics(configPath);
-    const platformRoot = _resolvePlatformRoot(configPath);
-    if (!result.ok) {
-      process.stderr.write(`[${appId}:platform] Failed to read kb.config.json, using NoOp adapters
-`);
-      await initPlatform({ adapters: {} }, repoRoot);
-      _initialized = true;
-      return platform;
+    if (storeRawConfig && rawConfig) {
+      globalThis.__KB_RAW_CONFIG__ = rawConfig;
     }
-    if (storeRawConfig) {
-      globalThis.__KB_RAW_CONFIG__ = result.data;
-    }
-    const platformConfig = result.data.platform;
-    if (!platformConfig) {
-      process.stderr.write(`[${appId}:platform] No platform section in kb.config.json, using NoOp adapters
-`);
-      await initPlatform({ adapters: {} }, repoRoot);
-      _initialized = true;
-      return platform;
-    }
-    await initPlatform(platformConfig, platformRoot);
+    await initPlatform(platformConfig, projectRoot);
     _initialized = true;
+    const hasConfig = !!sources.platformDefaults || !!sources.projectConfig;
+    if (!hasConfig) {
+      process.stderr.write(
+        `[${appId}:platform] No kb.config.json found, using NoOp adapters
+`
+      );
+    }
     platform.logger.info("Platform adapters initialized", {
       app: appId,
       adapters: Object.keys(platformConfig.adapters ?? {}),
-      platformRoot
+      platformRoot,
+      projectRoot,
+      sources
     });
   } catch (error48) {
-    process.stderr.write(`[${appId}:platform] Initialization failed, using NoOp adapters: ${error48 instanceof Error ? error48.message : String(error48)}
-`);
+    process.stderr.write(
+      `[${appId}:platform] Initialization failed, using NoOp adapters: ${error48 instanceof Error ? error48.message : String(error48)}
+`
+    );
     await initPlatform({ adapters: {} }, repoRoot);
     _initialized = true;
   }
@@ -76424,25 +76713,6 @@ init_embeddings_proxy();
 init_vector_store_proxy();
 init_storage_proxy();
 init_container();
-async function findRepoRoot(startDir = process.cwd()) {
-  const markersPriority = ["pnpm-workspace.yaml", ".git", "package.json"];
-  for (const marker of markersPriority) {
-    let dir = path4__namespace.default.resolve(startDir);
-    while (true) {
-      try {
-        await fs4.promises.access(path4__namespace.default.join(dir, marker));
-        return dir;
-      } catch {
-      }
-      const parent = path4__namespace.default.dirname(dir);
-      if (parent === dir) {
-        break;
-      }
-      dir = parent;
-    }
-  }
-  return path4__namespace.default.resolve(startDir);
-}
 
 // src/server.ts
 var import_fastify = __toESM(require_fastify());
@@ -77232,7 +77502,7 @@ __export(util_exports, {
   getSizableOrigin: () => getSizableOrigin,
   hexToUint8Array: () => hexToUint8Array,
   isObject: () => isObject,
-  isPlainObject: () => isPlainObject,
+  isPlainObject: () => isPlainObject2,
   issue: () => issue,
   joinValues: () => joinValues,
   jsonStringifyReplacer: () => jsonStringifyReplacer,
@@ -77374,8 +77644,8 @@ function getElementAtPath(obj, path6) {
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises4 = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises4).then((results) => {
+  const promises5 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises5).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -77414,7 +77684,7 @@ var allowsEval = cached(() => {
     return false;
   }
 });
-function isPlainObject(o) {
+function isPlainObject2(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -77431,7 +77701,7 @@ function isPlainObject(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject(o))
+  if (isPlainObject2(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -77624,7 +77894,7 @@ function omit(schema, mask) {
   return clone(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -77647,7 +77917,7 @@ function extend(schema, shape) {
   return clone(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = mergeDefs(schema._zod.def, {
@@ -79922,7 +80192,7 @@ function mergeValues2(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject(a) && isPlainObject(b)) {
+  if (isPlainObject2(a) && isPlainObject2(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -80076,7 +80346,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
     const input = payload.value;
-    if (!isPlainObject(input)) {
+    if (!isPlainObject2(input)) {
       payload.issues.push({
         expected: "record",
         code: "invalid_type",