@schoolai/shipyard 3.2.3-rc.20260422.2 → 3.2.3-rc.20260422.3

package/dist/index.js

@@ -106,7 +106,7 @@ async function handleSubcommand() {
     return true;
   }
   if (subcommand === "start") {
-    const { startCommand } = await import("./start-4KHICMP2.js");
+    const { startCommand } = await import("./start-NH5IIB6O.js");
     await startCommand();
     return true;
   }
@@ -123,7 +123,7 @@ async function main() {
   const args = parseCliArgs();
   if (args.serve) {
     await loadAuthFromConfig(env);
-    const { serve } = await import("./serve-3FTGY4YL.js");
+    const { serve } = await import("./serve-ZAI7K2HR.js");
     return serve({ isDev: env.SHIPYARD_DEV });
   }
   logger.error("Use `shipyard start` to run the daemon. Use --help for usage.");

package/dist/{serve-3FTGY4YL.js → serve-ZAI7K2HR.js}

@@ -87774,6 +87774,7 @@ function skipForMainChannel(content) {
 
 // src/services/plan/plan-handler.ts
 import { existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { readFile as readFile30 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { join as join39 } from "path";
 
@@ -87851,6 +87852,80 @@ var PlanFileBridge = class _PlanFileBridge {
       });
     }, PERIODIC_REREAD_MS);
   }
+  /**
+   * Re-initialize the bridge for a plan file known from a prior daemon session.
+   *
+   * Differs from `attach()` in that the caller explicitly decides whether to
+   * preserve CRDT content. This lets PlanHandler do a three-way compare
+   * (file vs CRDT vs last stored PlanVersion) and tell the bridge which side
+   * is authoritative:
+   *
+   * - `preserveCrdt: false` — file is truth (fresh daemon start, or Claude
+   *   rewrote the plan while the daemon was down). Overwrite CRDT with file
+   *   content, same as `attach()`.
+   * - `preserveCrdt: true` — CRDT has edits not yet written to disk (browser
+   *   edited before the daemon's debounced write-back fired). Keep CRDT
+   *   content; the subscription below will flush it on the next loro change.
+   *
+   * Returns `{ fileContent }` so callers can emit catch-up versions, or
+   * `null` if the file is unreadable.
+   */
+  async reattach(filePath, options) {
+    if (this.#disposed) return null;
+    this.#dirWatcher?.close();
+    this.#dirWatcher = null;
+    this.#crdtUnsub?.();
+    this.#crdtUnsub = null;
+    if (this.#periodicRereadTimer) {
+      clearInterval(this.#periodicRereadTimer);
+      this.#periodicRereadTimer = null;
+    }
+    let fileContent;
+    try {
+      fileContent = await this.#readFileWithRetry(filePath);
+    } catch (err) {
+      this.#config.log({
+        event: "plan_bridge_reattach_read_failed",
+        taskId: this.#config.taskId,
+        filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+    this.#filePath = filePath;
+    this.#config.planRepo.setMetadata(this.#config.taskId, filePath);
+    this.#lastWrittenHash = contentHash(fileContent);
+    if (!options.preserveCrdt) {
+      this.#config.planRepo.updateContent(this.#config.taskId, fileContent);
+    }
+    this.#hasAttachedContent = true;
+    this.#config.log({
+      event: "plan_bridge_reattached",
+      taskId: this.#config.taskId,
+      filePath,
+      crdtPreserved: options.preserveCrdt,
+      fileLength: fileContent.length
+    });
+    this.#startDirectoryWatcher(filePath);
+    this.#startCrdtSubscription();
+    this.#periodicRereadTimer = setInterval(() => {
+      this.#handleFileChanged().catch(() => {
+      });
+    }, PERIODIC_REREAD_MS);
+    if (options.preserveCrdt) {
+      try {
+        await this.flushWriteBack();
+      } catch (err) {
+        this.#config.log({
+          event: "plan_bridge_reattach_flush_failed",
+          taskId: this.#config.taskId,
+          filePath,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    return { fileContent };
+  }
   /**
    * Watch the plans DIRECTORY (not the file) for changes.
    * This survives inode changes from atomic writes (tmp + rename).
@@ -88273,8 +88348,177 @@ var PlanHandler = class {
       this.#lastPersistedPlanDetection = deps.initialPlanDetection;
       this.#planPublished = true;
       this.#processedPlanToolUseIds.add(deps.initialPlanDetection.toolUseId);
+      const seedFilePath = deps.initialPlanDetection.filePath;
+      const seedToolUseId = deps.initialPlanDetection.toolUseId;
+      deps.enqueueAsync(() => this.#rehydratePlanFileBridge(seedFilePath, seedToolUseId));
+    }
+  }
+  async #rehydratePlanFileBridge(filePath, toolUseId) {
+    if (this.#deps.isDisposed()) return;
+    if (!existsSync7(filePath)) {
+      this.#deps.log({
+        event: "plan_bridge_rehydrate_file_missing",
+        taskId: this.#deps.taskId,
+        filePath
+      });
+      return;
+    }
+    const fileContent = await this.#readFileForRehydrate(filePath);
+    if (fileContent === null || this.#deps.isDisposed()) return;
+    const versions = await this.#deps.annotationStore.getPlanVersions(this.#deps.taskId);
+    if (this.#deps.isDisposed()) return;
+    const lastVersionMarkdown = versions.at(-1)?.markdown ?? "";
+    const preserveCrdt = this.#shouldPreserveCrdt(fileContent, lastVersionMarkdown);
+    const result = await this.#ensureBridgeAttached(filePath, toolUseId, {
+      mode: "rehydrate",
+      preserveCrdt
+    });
+    if (!result || this.#deps.isDisposed()) return;
+    await this.#maybeEmitRehydrateCatchup(lastVersionMarkdown, preserveCrdt, toolUseId);
+  }
+  /**
+   * Three-way compare of {file on disk, CRDT content, last stored PlanVersion}:
+   *
+   *   Case 1 (all equal)            → preserveCrdt=false (no-op attach)
+   *   Case 2 (file drifted)         → preserveCrdt=false (file wins)
+   *   Case 3 (browser-edited CRDT)  → preserveCrdt=true (keep in-flight edits)
+   *   Case 4 (both drifted)         → preserveCrdt=false (file wins)
+   *
+   * Case 3 also requires a non-empty lastVersionMarkdown — otherwise a
+   * brand-new task with no prior stored versions would preserve whatever
+   * happens to be in CRDT (e.g. a stale browser session's edits on a fresh
+   * epoch) over an authoritative empty file.
+   */
+  #shouldPreserveCrdt(fileContent, lastVersionMarkdown) {
+    if (lastVersionMarkdown === "") return false;
+    const crdtContent = this.#deps.planRepo.getContent(this.#deps.taskId);
+    const fileMatchesLast = fileContent === lastVersionMarkdown;
+    const crdtHasUnsavedEdits = crdtContent.length > 0 && crdtContent !== lastVersionMarkdown;
+    return fileMatchesLast && crdtHasUnsavedEdits;
+  }
+  /**
+   * Post-attach catch-up: read whatever CRDT now holds (file content or
+   * preserved CRDT content) and emit a single version if it drifted from
+   * `lastVersionMarkdown`. Covers file-drifted and browser-edited cases.
+   *
+   * Source labeling follows authoritative side: preserved CRDT = 'human',
+   * file-overwritten CRDT = 'agent'. Mislabeling would corrupt
+   * `findLastAgentVersion`'s baseline for plan-review diffs.
+   */
+  async #maybeEmitRehydrateCatchup(lastVersionMarkdown, preserveCrdt, toolUseId) {
+    const postAttachMarkdown = this.#deps.planRepo.getContent(this.#deps.taskId);
+    if (postAttachMarkdown.length === 0 || postAttachMarkdown === lastVersionMarkdown) return;
+    const source = preserveCrdt ? "human" : "agent";
+    await this.#emitCatchupVersion(postAttachMarkdown, toolUseId, source);
+  }
+  async #readFileForRehydrate(filePath) {
+    try {
+      return await readFile30(filePath, "utf-8");
+    } catch (err) {
+      this.#deps.log({
+        event: "plan_bridge_rehydrate_read_failed",
+        taskId: this.#deps.taskId,
+        filePath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  async #emitCatchupVersion(markdown, toolUseId, source) {
+    const version = {
+      markdown,
+      timestamp: Date.now(),
+      source,
+      toolUseId
+    };
+    try {
+      await this.#deps.annotationStore.addPlanVersion(this.#deps.taskId, version);
+      const msg = {
+        type: "annotation_version_added",
+        taskId: this.#deps.taskId,
+        version
+      };
+      const send = this.#deps.getSendControlMessage();
+      if (send) {
+        send(msg);
+      } else {
+        this.#deps.enqueueControlMessage(msg);
+      }
+    } catch (err) {
+      this.#deps.log({
+        event: "plan_version_add_failed",
+        taskId: this.#deps.taskId,
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
   }
+  /**
+   * Ensure a PlanFileBridge is attached for this task at the given file path.
+   * Creates the bridge lazily and routes attach vs reattach based on options:
+   *
+   * - `mode: 'fresh'` — new ExitPlanMode cycle, no prior context. Uses
+   *   `attach()` which overwrites CRDT with file content.
+   * - `mode: 'rehydrate'` — daemon restart. Uses `reattach()` with an
+   *   explicit `preserveCrdt` flag so the caller's three-way compare picks
+   *   the authoritative side.
+   *
+   * Noop if the bridge is already attached to the same filePath. Re-attaches
+   * if the bridge points at a different filePath (Scenario A: a 2nd
+   * ExitPlanMode cycle writes to a new UUID).
+   */
+  async #ensureBridgeAttached(filePath, toolUseId, options) {
+    if (this.#deps.isDisposed()) return null;
+    const isFirstAttach = !this.#planFileBridge;
+    if (!this.#planFileBridge) {
+      this.#planFileBridge = this.#createPlanFileBridge(toolUseId);
+    } else if (this.#planFileBridge.filePath === filePath) {
+      return { isFirstAttach: false };
+    }
+    if (options.mode === "rehydrate") {
+      const result = await this.#planFileBridge.reattach(filePath, {
+        preserveCrdt: options.preserveCrdt
+      });
+      if (!result) return null;
+    } else {
+      await this.#planFileBridge.attach(filePath);
+    }
+    if (this.#deps.isDisposed()) return null;
+    return { isFirstAttach };
+  }
+  #createPlanFileBridge(fallbackToolUseId) {
+    return new PlanFileBridge({
+      taskId: this.#deps.taskId,
+      planRepo: this.#deps.planRepo,
+      log: this.#deps.log,
+      onBeforeContentUpdate: (currentMarkdown) => {
+        const version = {
+          markdown: currentMarkdown,
+          timestamp: Date.now(),
+          source: "agent",
+          toolUseId: this.#lastPlanDetection?.toolUseId ?? fallbackToolUseId
+        };
+        this.#deps.annotationStore.addPlanVersion(this.#deps.taskId, version).then(() => {
+          const msg = {
+            type: "annotation_version_added",
+            taskId: this.#deps.taskId,
+            version
+          };
+          const send = this.#deps.getSendControlMessage();
+          if (send) {
+            send(msg);
+          } else {
+            this.#deps.enqueueControlMessage(msg);
+          }
+        }).catch((err) => {
+          this.#deps.log({
+            event: "plan_version_add_failed",
+            taskId: this.#deps.taskId,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }
+    });
+  }
   /**
    * Persist a detection (or null clear) with shadow-pending semantics:
    * optimistically update #lastPlanDetection so concurrent reads see the new
@@ -88410,9 +88654,10 @@ var PlanHandler = class {
     });
   }
   detectPlanEvents(content) {
-    if (this.#approvalReceived || this.#planPublished) return;
+    if (this.#approvalReceived) return;
     for (const block2 of content) {
       if (block2.type !== "tool_use" || block2.toolName !== "ExitPlanMode") continue;
+      if (this.#processedPlanToolUseIds.has(block2.toolUseId)) continue;
       this.#deps.log({
         event: "exit_plan_mode_detected",
         taskId: this.#deps.taskId,
@@ -88577,51 +88822,32 @@ var PlanHandler = class {
     this.#pendingPlanAllowedPrompts.delete(toolUseId);
     this.#deps.enqueueAsync(async () => {
       if (this.#deps.isDisposed()) return;
-      const isFirstAttach = !this.#planFileBridge;
-      if (!this.#planFileBridge) {
-        this.#planFileBridge = new PlanFileBridge({
-          taskId: this.#deps.taskId,
-          planRepo: this.#deps.planRepo,
-          log: this.#deps.log,
-          onBeforeContentUpdate: (currentMarkdown) => {
-            const version = {
-              markdown: currentMarkdown,
-              timestamp: Date.now(),
-              source: "agent",
-              toolUseId: this.#lastPlanDetection?.toolUseId ?? toolUseId
-            };
-            this.#deps.annotationStore.addPlanVersion(this.#deps.taskId, version).then(() => {
-              this.#deps.getSendControlMessage()?.({
-                type: "annotation_version_added",
-                taskId: this.#deps.taskId,
-                version
-              });
-            }).catch((err) => {
-              this.#deps.log({
-                event: "plan_version_add_failed",
-                taskId: this.#deps.taskId,
-                error: err instanceof Error ? err.message : String(err)
-              });
-            });
-          }
-        });
-      }
-      await this.#planFileBridge.attach(filePath);
+      const attachResult = await this.#ensureBridgeAttached(filePath, toolUseId, {
+        mode: "fresh"
+      });
+      if (!attachResult) return;
       const markdown = this.#deps.planRepo.getContent(this.#deps.taskId);
-      if (isFirstAttach && markdown.length > 0) {
-        const initialVersion = {
-          markdown,
-          timestamp: Date.now(),
-          source: "agent",
-          toolUseId
-        };
-        await this.#deps.annotationStore.addPlanVersion(this.#deps.taskId, initialVersion);
-        this.#deps.getSendControlMessage()?.({
-          type: "annotation_version_added",
-          taskId: this.#deps.taskId,
-          version: initialVersion
-        });
+      if (markdown.length > 0) {
+        const existingVersions = await this.#deps.annotationStore.getPlanVersions(
+          this.#deps.taskId
+        );
+        const lastVersion = existingVersions.at(-1);
+        if (lastVersion?.markdown !== markdown) {
+          const initialVersion = {
+            markdown,
+            timestamp: Date.now(),
+            source: "agent",
+            toolUseId
+          };
+          await this.#deps.annotationStore.addPlanVersion(this.#deps.taskId, initialVersion);
+          this.#deps.getSendControlMessage()?.({
+            type: "annotation_version_added",
+            taskId: this.#deps.taskId,
+            version: initialVersion
+          });
+        }
       }
+      const isFirstAttach = attachResult.isFirstAttach;
       const pendingDetection = {
         toolUseId,
         filePath,
@@ -90109,7 +90335,7 @@ var RewindCheckpointHandler = class {
 };
 
 // src/services/task/side-thread-registry.ts
-import { mkdir as mkdir17, readFile as readFile30, rename as rename17, writeFile as writeFile23 } from "fs/promises";
+import { mkdir as mkdir17, readFile as readFile31, rename as rename17, writeFile as writeFile23 } from "fs/promises";
 import { dirname as dirname15, join as join40 } from "path";
 var ThreadFileSchema = external_exports.object({
   threads: external_exports.record(external_exports.string(), ThreadMetadataSchema)
@@ -90443,7 +90669,7 @@ var SideThreadRegistry = class {
     const filePath = this.#filePath();
     let raw;
     try {
-      raw = await readFile30(filePath, "utf-8");
+      raw = await readFile31(filePath, "utf-8");
     } catch (err) {
       if (isEnoent(err)) return;
       throw err;
@@ -90882,7 +91108,7 @@ async function resolveResources(ctx, content, history2, excludeUris) {
 
 // src/services/task/cc-task-file-store.ts
 import { watch as watch4 } from "fs";
-import { readdir as readdir9, readFile as readFile31 } from "fs/promises";
+import { readdir as readdir9, readFile as readFile32 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { basename as basename4, dirname as dirname16, join as join41 } from "path";
 var VALID_STATUSES2 = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
@@ -90918,7 +91144,7 @@ function createCCTaskFileWatcher(listId, log) {
   async function readTask(taskId) {
     const filePath = join41(dir, `${taskId}.json`);
     try {
-      const raw = await readFile31(filePath, "utf-8");
+      const raw = await readFile32(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (isCCTaskFile(parsed)) return parsed;
       log?.({
@@ -97178,7 +97404,7 @@ function isPlainObject2(v2) {
 }
 
 // src/services/themes/theme-store.ts
-import { mkdir as mkdir19, readdir as readdir11, readFile as readFile32, rename as rename19, stat as stat8, unlink as unlink9, writeFile as writeFile26 } from "fs/promises";
+import { mkdir as mkdir19, readdir as readdir11, readFile as readFile33, rename as rename19, stat as stat8, unlink as unlink9, writeFile as writeFile26 } from "fs/promises";
 import { join as join47 } from "path";
 function planSeed(input) {
   if (input.configExists) {
@@ -97258,7 +97484,7 @@ function buildThemeStore(dataDir) {
   }
   async function readConfigFile() {
     try {
-      const raw = await readFile32(configPath, "utf-8");
+      const raw = await readFile33(configPath, "utf-8");
       const parsed = ThemeConfigSchema.safeParse(JSON.parse(raw));
       if (!parsed.success) return null;
       return parsed.data;
@@ -97277,7 +97503,7 @@ function buildThemeStore(dataDir) {
     await atomicWrite3(themePath(id), serialized);
   }
   async function readThemeFile(id) {
-    const raw = await readFile32(themePath(id), "utf-8");
+    const raw = await readFile33(themePath(id), "utf-8");
     const parsed = VSCodeThemeSchema.safeParse(JSON.parse(raw));
     if (!parsed.success) {
       throw new Error(
@@ -97429,7 +97655,7 @@ function buildThemeStore(dataDir) {
 }
 
 // src/services/themes/vscode-scanner.ts
-import { readdir as readdir12, readFile as readFile33, stat as stat9 } from "fs/promises";
+import { readdir as readdir12, readFile as readFile34, stat as stat9 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname17, join as join48, normalize as normalize5, resolve } from "path";
 var VSCodeThemeEntrySchema2 = external_exports.object({
@@ -97488,7 +97714,7 @@ var PackageJsonContribSchema = external_exports.object({
 async function tryReadPackageJson(extDir) {
   let pkgRaw;
   try {
-    pkgRaw = await readFile33(join48(extDir, "package.json"), "utf-8");
+    pkgRaw = await readFile34(join48(extDir, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -97558,7 +97784,7 @@ async function readVSCodeThemeWithIncludes(absolutePath) {
     if (!validateScanPath(filePath)) {
       throw new Error(`Include path outside allowed directories: ${filePath}`);
     }
-    const raw = await readFile33(filePath, "utf-8");
+    const raw = await readFile34(filePath, "utf-8");
     const errors2 = [];
     const parsed = parse3(raw, errors2, {
       allowTrailingComma: true,
@@ -102221,7 +102447,7 @@ function createCollabRoomManager(deps) {
 
 // src/services/file-io-handler.ts
 import { execFile as execFile10, spawn as spawn6 } from "child_process";
-import { readdir as readdir14, readFile as readFile34, realpath as realpath2, stat as stat10, unlink as unlink10, writeFile as writeFile28 } from "fs/promises";
+import { readdir as readdir14, readFile as readFile35, realpath as realpath2, stat as stat10, unlink as unlink10, writeFile as writeFile28 } from "fs/promises";
 import { normalize as normalize7, relative as relative3, resolve as resolve2 } from "path";
 import { promisify as promisify7 } from "util";
 
@@ -102689,7 +102915,7 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
         respondError(requestId, "File too large (>10MB)");
         return;
       }
-      const content = await readFile34(absPath, "utf-8");
+      const content = await readFile35(absPath, "utf-8");
       respond({ type: "file_content", requestId, content });
     } catch (err) {
       respondError(requestId, formatError(err));
@@ -102883,7 +103109,7 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
       const originalContent = await readGitObject(`${mergeBase}:${filePath}`) ?? "";
       let modifiedContent;
       try {
-        modifiedContent = await readFile34(resolve2(cwd, filePath), "utf-8");
+        modifiedContent = await readFile35(resolve2(cwd, filePath), "utf-8");
       } catch {
         modifiedContent = "";
       }
@@ -102940,7 +103166,7 @@ function handleFileIOChannel(initialCwd, send, log, deps) {
         const indexContent = await readGitObject(`:${safeRelPath}`);
         originalContent = indexContent ?? await readGitObject(`HEAD:${safeRelPath}`) ?? "";
         try {
-          modifiedContent = await readFile34(absPath, "utf-8");
+          modifiedContent = await readFile35(absPath, "utf-8");
         } catch {
           modifiedContent = "";
         }
@@ -104312,7 +104538,7 @@ import { dirname as dirname21, join as join54 } from "path";
 // src/services/bootstrap/self-update.ts
 import { execFile as execFile11, spawn as spawn8 } from "child_process";
 import { createHash as createHash6 } from "crypto";
-import { chmod as chmod3, mkdir as mkdir22, readFile as readFile35, rename as rename20, unlink as unlink11, writeFile as writeFile29 } from "fs/promises";
+import { chmod as chmod3, mkdir as mkdir22, readFile as readFile36, rename as rename20, unlink as unlink11, writeFile as writeFile29 } from "fs/promises";
 import { join as join53 } from "path";
 
 // src/services/bootstrap/self-update-installer-scripts.ts
@@ -104734,7 +104960,7 @@ async function downloadTarball(url, destPath, fetchFn) {
 }
 async function verifyChecksum(path2, expectedHash) {
   const algo = expectedHash.length === 40 ? "sha1" : "sha256";
-  const raw = await readFile35(path2);
+  const raw = await readFile36(path2);
   const actual = createHash6(algo).update(raw).digest("hex");
   if (actual !== expectedHash) {
     try {
@@ -105485,7 +105711,7 @@ function buildLocalDirectChannelCallbacks(deps) {
 
 // src/services/storage/daemon-settings-store.ts
 import { createHash as createHash7 } from "crypto";
-import { mkdir as mkdir23, readFile as readFile36, rename as rename21, writeFile as writeFile30 } from "fs/promises";
+import { mkdir as mkdir23, readFile as readFile37, rename as rename21, writeFile as writeFile30 } from "fs/promises";
 import { join as join55 } from "path";
 var ProjectSettingsSchema = external_exports.object({
   disabledMcpServers: external_exports.array(external_exports.string()).optional()
@@ -105504,7 +105730,7 @@ function buildDaemonSettingsStore(dataDir) {
   return {
     async load(projectPath) {
       try {
-        const raw = await readFile36(settingsPath(projectPath), "utf-8");
+        const raw = await readFile37(settingsPath(projectPath), "utf-8");
         return ProjectSettingsSchema.parse(JSON.parse(raw));
       } catch (err) {
         if (isEnoent(err)) return {};
@@ -105522,7 +105748,7 @@ function buildDaemonSettingsStore(dataDir) {
 }
 
 // src/services/storage/plugin-config-store.ts
-import { mkdir as mkdir24, readFile as readFile37, rename as rename22, writeFile as writeFile31 } from "fs/promises";
+import { mkdir as mkdir24, readFile as readFile38, rename as rename22, writeFile as writeFile31 } from "fs/promises";
 import { join as join56 } from "path";
 function buildPluginConfigStore(pluginsDir) {
   const cache2 = /* @__PURE__ */ new Map();
@@ -105534,7 +105760,7 @@ function buildPluginConfigStore(pluginsDir) {
     const cached2 = cache2.get(pluginId);
     if (cached2) return cached2;
     try {
-      const raw = await readFile37(configPath(pluginId), "utf-8");
+      const raw = await readFile38(configPath(pluginId), "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         const record = Object.fromEntries(Object.entries(parsed));
@@ -105949,4 +106175,4 @@ export {
   _testing,
   serve
 };
-//# sourceMappingURL=serve-3FTGY4YL.js.map
+//# sourceMappingURL=serve-ZAI7K2HR.js.map