@madarco/agentbox 0.4.1 → 0.6.0

package/dist/{chunk-WR5FFGE5.js → chunk-KJNZP6I3.js}

@@ -3,64 +3,132 @@ import {
   ConfigError,
   VNC_CONTAINER_PORT,
   WEB_CONTAINER_PORT,
+  bindWorktrees,
   buildClaudeMounts,
   buildIdeMounts,
-  createBoxWorktree,
+  chownGitBindParents,
+  collectRepoCarryOver,
   createSnapshot,
   cursorServerVolumeName,
   detectGitRepos,
   dockerVolumeName,
   ensureClaudeVolume,
+  ensureHomeOwnedByVscode,
   ensureIdeVolumes,
   ensureRelay,
   generateRelayToken,
   generateVncPassword,
+  gitWorktreePathFor,
   launchCtlDaemon,
   launchDockerdDaemon,
   launchVncDaemon,
   loadConfig,
-  mountOverlay,
+  pickFreshBranch,
   registerBoxWithRelay,
   rehydrateRelayRegistry,
   repairIdeOwnership,
   resolveClaudeVolume,
+  seedSetupSkillIntoVolume,
+  seedWorkspace,
+  seedWorkspaceFromDir,
   snapshotPathFor,
-  verifyOverlay,
   vscodeServerVolumeName
-} from "./chunk-NSIECUCS.js";
+} from "./chunk-HTTKML3C.js";
 import {
+  STATE_DIR,
   allocateProjectIndex,
   readState,
   recordBox
-} from "./chunk-IDR4HVIC.js";
+} from "./chunk-HPZMD5DE.js";
 import {
-  CHECKPOINT_MOUNT,
   CONTAINER_EXPORT_MERGED,
-  CONTAINER_EXPORT_UPPER,
   DEFAULT_BOX_IMAGE,
   DEFAULT_ENV_PATTERNS,
   boxRunDirFor,
   containerExists,
   copyHostEnvFilesToBox,
+  copyHostFilesToBox,
   dockerInfo,
   dockerStorageDriver,
   ensureImage,
   ensureVolume,
   publishedHostPort,
-  resolveCheckpointLower,
+  resolveCheckpoint,
   runBox
-} from "./chunk-SOMIKEN2.js";
+} from "./chunk-HHMWQNLF.js";
 
-// ../../packages/sandbox-docker/dist/chunk-OHAASUGY.js
+// ../../packages/sandbox-docker/dist/chunk-A4F6SVSK.js
 import { randomBytes } from "crypto";
-import { mkdir, stat } from "fs/promises";
+import { mkdir as mkdir2, stat } from "fs/promises";
 import { homedir } from "os";
-import { basename, join, resolve } from "path";
-import { execa as execa2 } from "execa";
+import { basename, join as join2, resolve } from "path";
+import { execa as execa3 } from "execa";
+import { chmod, mkdir, readFile } from "fs/promises";
+import { join } from "path";
 import { execa } from "execa";
+import { execa as execa2 } from "execa";
+var CREDENTIALS_BACKUP_FILE = join(STATE_DIR, "claude-credentials.json");
+async function hostBackupHasCredentials(path = CREDENTIALS_BACKUP_FILE) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    const rt = parsed?.claudeAiOauth?.refreshToken;
+    return typeof rt === "string" && rt.length > 0;
+  } catch {
+    return false;
+  }
+}
+function parseSyncResult(stdout) {
+  const volumeHasCredentials = /\bVOLREAL=yes\b/.test(stdout);
+  if (/\bEXTRACTED=yes\b/.test(stdout)) return { direction: "extracted", volumeHasCredentials };
+  if (/\bSEEDED=yes\b/.test(stdout)) return { direction: "seeded", volumeHasCredentials };
+  return { direction: "noop", volumeHasCredentials };
+}
+var SYNC_SCRIPT = `
+EXTRACTED=no
+SEEDED=no
+VOL=/dst/.credentials.json
+HOST=/host-state/claude-credentials.json
+if [ -f "$VOL" ] && jq -e '(.claudeAiOauth.refreshToken // "") | length > 0' "$VOL" >/dev/null 2>&1; then VOL_REAL=yes; else VOL_REAL=no; fi
+if [ -f "$HOST" ] && jq -e '(.claudeAiOauth.refreshToken // "") | length > 0' "$HOST" >/dev/null 2>&1; then HOST_REAL=yes; else HOST_REAL=no; fi
+if [ "$VOL_REAL" = yes ] && [ "$ISOLATE" != yes ]; then
+  cp -a "$VOL" "$HOST" && chmod 600 "$HOST" && EXTRACTED=yes
+elif [ "$VOL_REAL" = no ] && [ "$HOST_REAL" = yes ]; then
+  cp -a "$HOST" "$VOL" && chown 1000:1000 "$VOL" && chmod 600 "$VOL" && SEEDED=yes && VOL_REAL=yes
+fi
+echo "EXTRACTED=$EXTRACTED SEEDED=$SEEDED VOLREAL=$VOL_REAL"
+`;
+async function syncClaudeCredentials(spec, opts) {
+  try {
+    await mkdir(STATE_DIR, { recursive: true });
+    const { stdout } = await execa("docker", [
+      "run",
+      "--rm",
+      "--user",
+      "0",
+      "-v",
+      `${spec.volume}:/dst`,
+      "-v",
+      `${STATE_DIR}:/host-state`,
+      "-e",
+      `ISOLATE=${opts.isolate ? "yes" : "no"}`,
+      opts.image,
+      "sh",
+      "-c",
+      SYNC_SCRIPT
+    ]);
+    const result = parseSyncResult(stdout);
+    if (result.direction === "extracted") {
+      await chmod(CREDENTIALS_BACKUP_FILE, 384).catch(() => {
+      });
+    }
+    return result;
+  } catch {
+    return { direction: "noop", volumeHasCredentials: false };
+  }
+}
 async function writeBoxEnvFile(container, env) {
   const body = formatBoxEnvBody(env);
-  const result = await execa(
+  const result = await execa2(
     "docker",
     ["exec", "--user", "root", "-i", container, "sh", "-c", "umask 022 && cat > /etc/agentbox/box.env"],
     { input: body, reject: false }
@@ -114,8 +182,8 @@ async function pathExists(p) {
 async function buildIdentityMounts() {
   const home = homedir();
   const candidates = [
-    { src: join(home, ".codex"), dst: "/home/vscode/.codex", readOnly: false },
-    { src: join(home, ".gitconfig"), dst: "/home/vscode/.gitconfig", readOnly: true }
+    { src: join2(home, ".codex"), dst: "/home/vscode/.codex", readOnly: false },
+    { src: join2(home, ".gitconfig"), dst: "/home/vscode/.gitconfig", readOnly: true }
   ];
   const out = [];
   for (const c of candidates) {
@@ -132,7 +200,7 @@ async function createBox(opts) {
   if (!await pathExists(workspace)) {
     throw new Error(`workspace does not exist: ${workspace}`);
   }
-  const cfgPath = join(workspace, "agentbox.yaml");
+  const cfgPath = join2(workspace, "agentbox.yaml");
   if (await pathExists(cfgPath)) {
     try {
       const cfg = await loadConfig(cfgPath);
@@ -147,11 +215,29 @@ async function createBox(opts) {
   }
   await dockerInfo();
   log("docker daemon reachable");
-  const imageRef = opts.image ?? DEFAULT_BOX_IMAGE;
-  const { built } = await ensureImage(imageRef, {
+  let checkpointImage;
+  let checkpointSource;
+  let restoredWorktrees;
+  if (opts.checkpointRef) {
+    const projectRootForCkpt = opts.projectRoot ?? workspace;
+    const head = await resolveCheckpoint(projectRootForCkpt, opts.checkpointRef);
+    if (!head) {
+      throw new Error(`checkpoint not found: ${opts.checkpointRef}`);
+    }
+    checkpointImage = head.manifest.image;
+    const chain = [head.name, ...head.manifest.parents];
+    checkpointSource = { ref: opts.checkpointRef, type: head.manifest.type, chain };
+    restoredWorktrees = head.manifest.worktrees;
+    log(
+      `starting from checkpoint ${opts.checkpointRef} (${head.manifest.type}, ${String(chain.length)} layer(s), image ${head.manifest.image})`
+    );
+  }
+  const imageRef = checkpointImage ?? opts.image ?? DEFAULT_BOX_IMAGE;
+  const ensureRef = checkpointImage ? opts.image ?? DEFAULT_BOX_IMAGE : imageRef;
+  const { built } = await ensureImage(ensureRef, {
     onProgress: (line) => log(`[image] ${line}`)
   });
-  log(built ? `built image ${imageRef}` : `using cached image ${imageRef}`);
+  log(built ? `built image ${ensureRef}` : `using cached image ${imageRef}`);
   let relayUp = false;
   try {
     await ensureRelay({ onLog: log });
@@ -168,78 +254,54 @@ async function createBox(opts) {
   if (await containerExists(containerName)) {
     throw new Error(`container ${containerName} already exists; remove it first`);
   }
-  const worktreesRoot = join(boxRunDirFor(id), "worktrees");
-  await mkdir(worktreesRoot, { recursive: true });
+  let projectIndex;
+  if (opts.projectRoot) {
+    projectIndex = allocateProjectIndex(await readState(), opts.projectRoot);
+  }
+  const repoCarryOvers = [];
   const gitWorktreeRecords = [];
-  const nestedWorktreeBinds = [];
-  const repos = await detectGitRepos(workspace);
-  if (repos.length > 0) {
-    log(
-      `detected ${String(repos.length)} git repo(s): ` + repos.map((r) => `${r.kind}${r.relPathFromWorkspace ? "@" + r.relPathFromWorkspace : ""}`).join(", ")
-    );
+  if (checkpointImage && restoredWorktrees && restoredWorktrees.length > 0) {
+    gitWorktreeRecords.push(...restoredWorktrees);
   }
-  for (const r of repos) {
-    const worktreeDir = join(worktreesRoot, r.relPathFromWorkspace || "root");
-    const branchBase = r.kind === "root" ? `agentbox/${name}` : `agentbox/${name}--${r.relPathFromWorkspace.replace(/[^A-Za-z0-9._-]+/g, "_")}`;
-    const result = await createBoxWorktree({
-      hostMainRepo: r.hostMainRepo,
-      branchName: branchBase,
-      worktreeDir,
-      onLog: log
-    });
-    const containerPath = r.kind === "root" ? "/workspace" : `/workspace/${r.relPathFromWorkspace}`;
-    gitWorktreeRecords.push({
-      kind: r.kind,
-      hostMainRepo: r.hostMainRepo,
-      hostWorktreeDir: worktreeDir,
-      containerPath,
-      branch: result.branchName,
-      relPathFromWorkspace: r.relPathFromWorkspace
-    });
-    if (r.kind === "nested") {
-      nestedWorktreeBinds.push({
+  if (!checkpointImage) {
+    const repos = await detectGitRepos(workspace);
+    if (repos.length > 0) {
+      log(
+        `detected ${String(repos.length)} git repo(s): ` + repos.map((r) => `${r.kind}${r.relPathFromWorkspace ? "@" + r.relPathFromWorkspace : ""}`).join(", ")
+      );
+    }
+    for (const r of repos) {
+      const branchBase = r.kind === "root" ? `agentbox/${name}` : `agentbox/${name}--${r.relPathFromWorkspace.replace(/[^A-Za-z0-9._-]+/g, "_")}`;
+      const branch = await pickFreshBranch(r.hostMainRepo, branchBase);
+      const containerPath = r.kind === "root" ? "/workspace" : `/workspace/${r.relPathFromWorkspace}`;
+      const gitWorktreePath = gitWorktreePathFor(branch);
+      const carry = await collectRepoCarryOver(r, branch, containerPath, gitWorktreePath);
+      repoCarryOvers.push(carry);
+      gitWorktreeRecords.push({
+        kind: r.kind,
+        hostMainRepo: r.hostMainRepo,
         containerPath,
-        mountFromPath: `/agentbox-worktrees/${r.relPathFromWorkspace}`
+        gitWorktreePath,
+        branch,
+        relPathFromWorkspace: r.relPathFromWorkspace
       });
     }
   }
-  let lowerPath = workspace;
-  const rootWorktree = gitWorktreeRecords.find((w) => w.kind === "root");
-  if (rootWorktree) {
-    lowerPath = rootWorktree.hostWorktreeDir;
-    log(`using worktree as overlay lower: ${lowerPath}`);
-  }
   let snapshotDir = null;
-  if (opts.useSnapshot) {
-    snapshotDir = snapshotPathFor(id);
+  const snapshotIsUseful = !checkpointImage && repoCarryOvers.length === 0;
+  if (opts.useSnapshot && snapshotIsUseful) {
+    snapshotDir = snapshotPathFor({ id, name, projectIndex });
     log(`cloning workspace to ${snapshotDir} (APFS clone where available)`);
-    const snap = await createSnapshot({ source: lowerPath, destination: snapshotDir });
+    const snap = await createSnapshot({ source: workspace, destination: snapshotDir });
     log(`pruned ${snap.prunedPaths.length} platform-dependent dirs from snapshot`);
-    lowerPath = snapshotDir;
+  } else if (opts.useSnapshot && !checkpointImage) {
+    log("skipping --host-snapshot: git worktree path reads content from .git, not from a workspace clone");
   }
-  let lowerDirs;
-  let checkpointVolume;
-  let checkpointSource;
-  if (opts.checkpointRef) {
-    const projectRootForCkpt = opts.projectRoot ?? workspace;
-    const spec = await resolveCheckpointLower(projectRootForCkpt, opts.checkpointRef);
-    checkpointVolume = spec.volume;
-    const layerDirs = spec.subpaths.map((s) => `${CHECKPOINT_MOUNT}/${s}`);
-    lowerDirs = spec.type === "merged" ? layerDirs : [...layerDirs, "/host-src"];
-    checkpointSource = { ref: opts.checkpointRef, type: spec.type, chain: spec.chain };
-    log(
-      `starting from checkpoint ${opts.checkpointRef} (${spec.type}, ${String(spec.subpaths.length)} layer(s), volume ${spec.volume})`
-    );
-  }
-  const upperVolume = `agentbox-upper-${id}`;
-  await ensureVolume(upperVolume);
   await ensureIdeVolumes(id);
   const dockerCacheShared = opts.docker?.sharedCache === true;
   const dockerVolume = dockerVolumeName(id, dockerCacheShared);
   await ensureVolume(dockerVolume);
-  log(
-    `prepared volumes ${upperVolume}, ${vscodeServerVolumeName(id)}, ${cursorServerVolumeName(id)}, ${dockerVolume}`
-  );
+  log(`prepared volumes ${vscodeServerVolumeName(id)}, ${cursorServerVolumeName(id)}, ${dockerVolume}`);
   const ide = buildIdeMounts(id);
   const claudeSpec = resolveClaudeVolume({
     isolate: opts.claudeConfig?.isolate ?? false,
@@ -247,7 +309,7 @@ async function createBox(opts) {
   });
   const claudeEnsured = await ensureClaudeVolume(claudeSpec, {
     syncFromHost: true,
-    image: imageRef,
+    image: ensureRef,
     hostWorkspace: workspace
   });
   if (claudeEnsured.synced) {
@@ -257,44 +319,47 @@ async function createBox(opts) {
         `filtered ${String(claudeEnsured.filteredHookCount)} host-path hook(s) (paths under ~/)`
       );
     }
-    if (claudeEnsured.clearedInstallMethod) {
-      log("cleared host's installMethod from synced .claude.json (box uses the native installer)");
+    if (claudeEnsured.installMethodFixed) {
+      log("set installMethod=native in synced .claude.json (matches box native install)");
     }
     if (claudeEnsured.aliasedProjectKey) {
       log(`aliased project state for ${workspace} -> /workspace in synced .claude.json`);
     }
+    if (claudeEnsured.workspaceTrusted) {
+      log("pre-trusted /workspace in synced .claude.json (skips the trust dialog)");
+    }
   } else if (claudeEnsured.created) {
     log(`created empty volume ${claudeSpec.volume} (no host ~/.claude to sync)`);
   } else {
     log(`reusing volume ${claudeSpec.volume} (no host ~/.claude to sync)`);
   }
+  const seeded = await seedSetupSkillIntoVolume(claudeSpec.volume, ensureRef);
+  if (seeded.seeded) log(`refreshed /agentbox-setup skill into ${claudeSpec.volume}`);
+  const credSync = await syncClaudeCredentials(claudeSpec, {
+    image: ensureRef,
+    isolate: opts.claudeConfig?.isolate ?? false
+  });
+  if (credSync.direction === "extracted") {
+    log("extracted box claude credentials to host backup");
+  } else if (credSync.direction === "seeded") {
+    log(`seeded claude credentials into ${claudeSpec.volume} from host backup`);
+  }
   const claudeMounts = buildClaudeMounts(claudeSpec, process.env);
-  const boxDir = boxRunDirFor(id);
-  const socketDir = join(boxDir, "run");
-  const socketPath = join(socketDir, "ctl.sock");
-  const mergedExportDir = join(boxDir, "workspace");
-  const upperExportDir = join(boxDir, "upper");
-  await mkdir(socketDir, { recursive: true });
-  await mkdir(mergedExportDir, { recursive: true });
-  await mkdir(upperExportDir, { recursive: true });
+  const boxDir = boxRunDirFor({ id, name, projectIndex });
+  const socketDir = join2(boxDir, "run");
+  const socketPath = join2(socketDir, "ctl.sock");
+  const mergedExportDir = join2(boxDir, "workspace");
+  await mkdir2(socketDir, { recursive: true });
+  await mkdir2(mergedExportDir, { recursive: true });
   const extraVolumes = await buildIdentityMounts();
   extraVolumes.push(...claudeMounts.extraVolumes);
   extraVolumes.push(...ide.extraVolumes);
   extraVolumes.push(`${socketDir}:/run/agentbox`);
   extraVolumes.push(`${mergedExportDir}:${CONTAINER_EXPORT_MERGED}`);
-  extraVolumes.push(`${upperExportDir}:${CONTAINER_EXPORT_UPPER}`);
   extraVolumes.push(`${dockerVolume}:/var/lib/docker`);
   for (const w of gitWorktreeRecords) {
     extraVolumes.push(`${w.hostMainRepo}/.git:${w.hostMainRepo}/.git`);
   }
-  for (const w of gitWorktreeRecords) {
-    if (w.kind === "nested") {
-      extraVolumes.push(`${w.hostWorktreeDir}:/agentbox-worktrees/${w.relPathFromWorkspace}`);
-    }
-  }
-  if (checkpointVolume) {
-    extraVolumes.push(`${checkpointVolume}:${CHECKPOINT_MOUNT}:ro`);
-  }
   for (const v of extraVolumes) log(`mounting agent dir: ${v}`);
   const relayToken = generateRelayToken();
   if (relayUp) {
@@ -305,6 +370,7 @@ async function createBox(opts) {
         name,
         containerName,
         createdAt,
+        projectIndex,
         worktrees: gitWorktreeRecords
       });
       log(`registered box token with relay`);
@@ -326,10 +392,6 @@ async function createBox(opts) {
   const webPortMappings = [
     { hostPort: 0, containerPort: WEB_CONTAINER_PORT, hostIp: "127.0.0.1" }
   ];
-  let projectIndex;
-  if (opts.projectRoot) {
-    projectIndex = allocateProjectIndex(await readState(), opts.projectRoot);
-  }
   const agentboxEnv = {
     AGENTBOX: "1",
     AGENTBOX_BOX_NAME: name,
@@ -355,8 +417,6 @@ async function createBox(opts) {
   await runBox({
     name: containerName,
     image: imageRef,
-    lowerPath,
-    upperVolume,
     extraVolumes,
     limits: effectiveLimits,
     portMappings: [...vncPortMappings, ...webPortMappings],
@@ -370,27 +430,46 @@ async function createBox(opts) {
     }
   });
   log(`container ${containerName} started`);
+  if (gitWorktreeRecords.length > 0) {
+    await chownGitBindParents({
+      container: containerName,
+      hostMainRepos: gitWorktreeRecords.map((w) => w.hostMainRepo),
+      onLog: log
+    });
+  }
   const boxEnv = await writeBoxEnvFile(containerName, boxEnvForFile);
   if (boxEnv.ok) log("wrote /etc/agentbox/box.env");
   else log(`writing /etc/agentbox/box.env failed: ${boxEnv.reason}`);
-  try {
-    await mountOverlay(containerName, { lowerDirs, nestedWorktrees: nestedWorktreeBinds });
-    log("fuse-overlayfs mounted at /workspace");
-    if (nestedWorktreeBinds.length > 0) {
-      log(`bind-mounted ${String(nestedWorktreeBinds.length)} nested worktree(s) over /workspace`);
+  await ensureHomeOwnedByVscode(containerName);
+  if (!checkpointImage) {
+    if (repoCarryOvers.length > 0) {
+      try {
+        await seedWorkspace({ container: containerName, repos: repoCarryOvers, onLog: log });
+        log("seeded /workspace from in-container git worktree(s)");
+      } catch (err) {
+        log(
+          `seedWorkspace failed; leaving ${containerName} running so you can inspect it`
+        );
+        throw err;
+      }
+    } else {
+      const source = snapshotDir ?? workspace;
+      await seedWorkspaceFromDir({ container: containerName, hostSource: source, onLog: log });
     }
-  } catch (err) {
-    log(`overlay mount failed; leaving container ${containerName} running so you can inspect it`);
-    throw err;
-  }
-  const overlayChecks = await verifyOverlay(containerName, lowerDirs ?? ["/host-src"]);
-  const failed = overlayChecks.filter((c) => !c.ok);
-  if (failed.length > 0) {
-    const detail = failed.map((c) => `  - ${c.name}: ${c.detail}`).join("\n");
-    throw new Error(`overlay verification failed:
-${detail}`);
+  } else if (restoredWorktrees && restoredWorktrees.length > 0) {
+    await bindWorktrees(
+      containerName,
+      restoredWorktrees.map((w) => ({
+        kind: w.kind,
+        containerPath: w.containerPath,
+        gitWorktreePath: w.gitWorktreePath
+      })),
+      log
+    );
+    log("re-bound /workspace from checkpoint image");
+  } else {
+    log("using /workspace from checkpoint image (no worktrees recorded; no rebind)");
   }
-  log("overlay verified");
   await repairIdeOwnership(containerName);
   log(".vscode-server + .cursor-server ownership verified");
   const ctl = await launchCtlDaemon(containerName, socketPath);
@@ -398,13 +477,13 @@ ${detail}`);
   else log(`agentbox-ctl daemon did not become reachable: ${ctl.reason}`);
   const dockerd = await launchDockerdDaemon(containerName);
   if (dockerd.up) {
-    log(`dockerd up (storage-driver=fuse-overlayfs, data root=${dockerVolume})`);
+    log(`dockerd up (data root=${dockerVolume})`);
   } else {
     log(`dockerd did not become ready: ${dockerd.reason}`);
   }
   if (opts.withPlaywright) {
     log("installing @playwright/cli@latest (--with-playwright)");
-    const result = await execa2(
+    const result = await execa3(
       "docker",
       [
         "exec",
@@ -437,6 +516,18 @@ ${detail}`);
     });
     log(copied > 0 ? `copied ${String(copied)} env/config file(s)` : "no env/config files found");
   }
+  if (opts.envFilesToImport && opts.envFilesToImport.length > 0) {
+    log(`copying ${String(opts.envFilesToImport.length)} selected env/config file(s) into /workspace`);
+    const { copied } = await copyHostFilesToBox({
+      container: containerName,
+      workspaceDir: workspace,
+      files: opts.envFilesToImport,
+      onLog: log
+    });
+    if (copied !== opts.envFilesToImport.length) {
+      log(`copied ${String(copied)}/${String(opts.envFilesToImport.length)} selected env/config file(s)`);
+    }
+  }
   let vncHostPort = null;
   if (vncEnabled) {
     const vnc = await launchVncDaemon(containerName);
@@ -457,8 +548,6 @@ ${detail}`);
     container: containerName,
     image: imageRef,
     workspacePath: workspace,
-    lowerPath,
-    upperVolume,
     snapshotDir,
     socketPath,
     claudeConfigVolume: claudeSpec.volume,
@@ -478,19 +567,20 @@ ${detail}`);
     dockerCacheShared: dockerCacheShared || void 0,
     projectRoot: opts.projectRoot,
     projectIndex,
-    lowerDirs,
-    checkpointVolume,
+    checkpointImage,
     checkpointSource,
     resourceLimits: persistableLimits(effectiveLimits),
     createdAt
   };
   await recordBox(record);
-  return { record, overlayChecks, imageBuilt: built };
+  return { record, imageBuilt: built };
 }
 
 export {
+  hostBackupHasCredentials,
+  syncClaudeCredentials,
   sanitizeBasename,
   defaultBoxName,
   createBox
 };
-//# sourceMappingURL=chunk-WR5FFGE5.js.map
+//# sourceMappingURL=chunk-KJNZP6I3.js.map