dreamboard 0.1.4 → 0.1.6

package/dist/index.js

@@ -529,6 +529,11 @@ var createCompiledResult = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
+var getCompiledResult = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/games/{gameId}/compiled-results/{compiledResultId}",
+  ...options
+});
 var getGameSources = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/api/games/{gameId}/sources",
@@ -609,6 +614,11 @@ var submitAction = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
+var getJob = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api/jobs/{jobId}",
+  ...options
+});
 
 // src/config/global-config.ts
 import os from "os";
@@ -1513,10 +1523,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path14) {
-  if (!path14)
+function getElementAtPath(obj, path15) {
+  if (!path15)
     return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+  return path15.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1899,11 +1909,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path14, issues) {
+function prefixIssues(path15, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path15);
     return iss;
   });
 }
@@ -2086,7 +2096,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path14 = []) => {
+  const processError = (error49, path15 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -2096,7 +2106,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path15, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2128,8 +2138,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path15) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14106,13 +14116,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path15 = ref.slice(1).split("/").filter(Boolean);
+  if (path15.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path15[0] === defsKey) {
+    const key = path15[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14543,7 +14553,8 @@ var pullCommandArgsSchema = configFlagsSchema.extend({
 });
 var pushCommandArgsSchema = configFlagsSchema.extend({
   force: external_exports.boolean().default(false),
-  debug: external_exports.boolean().default(false)
+  debug: external_exports.boolean().default(false),
+  "skip-local-check": external_exports.boolean().default(false)
 });
 var statusCommandArgsSchema = configFlagsSchema.extend({
   json: external_exports.boolean().default(false)
@@ -14702,6 +14713,61 @@ async function findLatestSuccessfulCompiledResult(gameId) {
   });
   return data ?? null;
 }
+async function getCompiledResultSdk(gameId, compiledResultId) {
+  const { data, error: error48, response } = await getCompiledResult({
+    path: {
+      gameId,
+      compiledResultId
+    }
+  });
+  if (error48 || !data) {
+    throw new Error(
+      formatApiError(error48, response, "Failed to fetch compiled result")
+    );
+  }
+  return data;
+}
+async function waitForCompiledResultJobSdk(options) {
+  const { gameId, jobId, onProgress } = options;
+  let previousTransitionKey = null;
+  for (let attempt = 0; attempt < 180; attempt += 1) {
+    const {
+      data: job,
+      error: error48,
+      response
+    } = await getJob({
+      path: { jobId }
+    });
+    if (error48 || !job) {
+      throw new Error(formatApiError(error48, response, "Failed to get job"));
+    }
+    const transitionKey = `${job.status}:${job.phase ?? ""}`;
+    if (transitionKey !== previousTransitionKey) {
+      previousTransitionKey = transitionKey;
+      onProgress?.(job);
+    }
+    if (job.status === "COMPLETED" || job.status === "FAILED") {
+      const compiledResultId = job.createdCompiledResultId ?? job.createdAppScriptId;
+      if (!compiledResultId) {
+        throw new Error(
+          job.errorMessage ?? `Compile job ${jobId} finished without a result.`
+        );
+      }
+      const compiledResult = await getCompiledResultSdk(
+        gameId,
+        compiledResultId
+      );
+      return { job, compiledResult };
+    }
+    if (job.status === "CANCELLED" || job.status === "INTERRUPTED") {
+      throw new Error(
+        job.errorMessage ?? `Compile job ${jobId} ${job.status.toLowerCase()}.`
+      );
+    }
+    await sleep(1e3);
+  }
+  throw new Error(`Compile job ${jobId} did not complete in time.`);
+}
 
 // src/services/api/game-api.ts
 async function tryGetGameBySlug(slug, opts) {
@@ -14849,7 +14915,7 @@ async function createCompiledResultSdk(options) {
   });
   if (error48 || !data) {
     throw new Error(
-      formatApiError(error48, response, "Failed to create compiled result")
+      formatApiError(error48, response, "Failed to create compile job")
     );
   }
   return data;
@@ -22313,6 +22379,149 @@ var clone_default = defineCommand({
   }
 });
 
+// src/services/project/local-typecheck.ts
+import { spawn } from "child_process";
+import { lstat, mkdir, symlink } from "fs/promises";
+import path8 from "path";
+import { fileURLToPath } from "url";
+var MODULE_DIR = path8.dirname(fileURLToPath(import.meta.url));
+var REPO_ROOT = path8.resolve(MODULE_DIR, "../../../../..");
+var WORKSPACE_NODE_MODULES = path8.join(REPO_ROOT, "node_modules");
+var UI_SDK_NODE_MODULES = path8.join(
+  REPO_ROOT,
+  "packages",
+  "ui-sdk",
+  "node_modules"
+);
+var TYPESCRIPT_CLI = path8.join(
+  WORKSPACE_NODE_MODULES,
+  "typescript",
+  "bin",
+  "tsc"
+);
+async function pathExists(targetPath) {
+  try {
+    await lstat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureSymlink(targetPath, linkPath) {
+  if (await pathExists(linkPath)) {
+    return;
+  }
+  await mkdir(path8.dirname(linkPath), { recursive: true });
+  await symlink(
+    targetPath,
+    linkPath,
+    process.platform === "win32" ? "junction" : "dir"
+  );
+}
+async function ensureTypecheckDependencies(projectRoot) {
+  if (!await pathExists(WORKSPACE_NODE_MODULES)) {
+    return `Skipping local typecheck: workspace dependencies are not installed at ${WORKSPACE_NODE_MODULES}.`;
+  }
+  if (!await pathExists(UI_SDK_NODE_MODULES)) {
+    return `Skipping local typecheck: ui-sdk dependencies are not installed at ${UI_SDK_NODE_MODULES}.`;
+  }
+  await ensureSymlink(
+    WORKSPACE_NODE_MODULES,
+    path8.join(projectRoot, "node_modules")
+  );
+  await ensureSymlink(
+    UI_SDK_NODE_MODULES,
+    path8.join(projectRoot, "ui", "node_modules")
+  );
+  return null;
+}
+async function resolveTypecheckRunner() {
+  if (await pathExists(TYPESCRIPT_CLI)) {
+    return {
+      command: process.execPath,
+      argsPrefix: [TYPESCRIPT_CLI]
+    };
+  }
+  const globalTscAvailable = await new Promise((resolve) => {
+    const child = spawn("tsc", ["--version"], {
+      env: process.env,
+      stdio: "ignore"
+    });
+    child.on("error", () => {
+      resolve(false);
+    });
+    child.on("close", (code) => {
+      resolve(code === 0);
+    });
+  });
+  if (!globalTscAvailable) {
+    return null;
+  }
+  return {
+    command: "tsc",
+    argsPrefix: []
+  };
+}
+async function runTypecheckProject(runner, projectRoot, projectPath) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      runner.command,
+      [...runner.argsPrefix, "--noEmit", "-p", projectPath],
+      {
+        cwd: projectRoot,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error48) => {
+      reject(new Error(`Failed to start local typecheck. ${error48.message}`));
+    });
+    child.on("close", (code) => {
+      const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+      resolve({
+        success: code === 0,
+        output
+      });
+    });
+  });
+}
+async function runLocalTypecheck(projectRoot) {
+  const dependencySkipReason = await ensureTypecheckDependencies(projectRoot);
+  if (dependencySkipReason) {
+    return {
+      success: true,
+      skipped: true,
+      output: dependencySkipReason
+    };
+  }
+  const runner = await resolveTypecheckRunner();
+  if (!runner) {
+    return {
+      success: true,
+      skipped: true,
+      output: "Skipping local typecheck: TypeScript CLI was not found in workspace dependencies or on PATH."
+    };
+  }
+  for (const projectPath of ["app/tsconfig.json", "ui/tsconfig.json"]) {
+    const result = await runTypecheckProject(runner, projectRoot, projectPath);
+    if (!result.success) {
+      return result;
+    }
+  }
+  return {
+    success: true,
+    output: ""
+  };
+}
+
 // src/commands/push.ts
 function isSourcePath(filePath) {
   return filePath !== MANIFEST_FILE && filePath !== RULE_FILE && isAllowedGamePath2(filePath);
@@ -22320,33 +22529,48 @@ function isSourcePath(filePath) {
 function buildSourceChanges(options) {
   const { mode, localFiles, diff } = options;
   if (mode === "replace") {
-    return Object.entries(localFiles).filter(([filePath]) => isSourcePath(filePath)).sort(([left], [right]) => left.localeCompare(right)).map(([path14, content]) => ({
+    return Object.entries(localFiles).filter(([filePath]) => isSourcePath(filePath)).sort(([left], [right]) => left.localeCompare(right)).map(([path15, content]) => ({
       kind: "upsert",
-      path: path14,
+      path: path15,
       content
     }));
   }
   const changes = [];
   const upsertPaths = [...diff.modified, ...diff.added].filter(isSourcePath).sort((left, right) => left.localeCompare(right));
-  for (const path14 of upsertPaths) {
-    const content = localFiles[path14];
+  for (const path15 of upsertPaths) {
+    const content = localFiles[path15];
     if (content === void 0) {
       continue;
     }
     changes.push({
       kind: "upsert",
-      path: path14,
+      path: path15,
       content
     });
   }
-  for (const path14 of diff.deleted.filter(isSourcePath).sort()) {
+  for (const path15 of diff.deleted.filter(isSourcePath).sort()) {
     changes.push({
       kind: "delete",
-      path: path14
+      path: path15
     });
   }
   return changes;
 }
+function formatCompileJobProgressMessage(job) {
+  const phase = job.phase ? ` [${job.phase}]` : "";
+  const detail = job.message ? ` ${job.message}` : "";
+  if (job.status === "PENDING") {
+    const queue = typeof job.queuePosition === "number" ? ` (queue ${job.queuePosition + 1})` : "";
+    return `Compile queued${queue}${phase}${detail}`.trim();
+  }
+  if (job.status === "RUNNING") {
+    return `Compile running${phase}${detail}`.trim();
+  }
+  if (job.status === "FAILED") {
+    return `Compile failed${phase}${detail}`.trim();
+  }
+  return `Compile ${job.status.toLowerCase()}${phase}${detail}`.trim();
+}
 var push_default = defineCommand({
   meta: {
     name: "push",
@@ -22363,6 +22587,11 @@ var push_default = defineCommand({
       description: "Print debug details including source revision payloads",
       default: false
     },
+    "skip-local-check": {
+      type: "boolean",
+      description: "Skip the best-effort local typecheck before remote mutations",
+      default: false
+    },
     ...CONFIG_FLAG_ARGS
   },
   async run({ args }) {
@@ -22406,6 +22635,24 @@ var push_default = defineCommand({
         `Remote drift detected. Local base=${knownBaseResultId}, remote latest=${latest.id}. Run 'dreamboard update --pull' to reconcile before pushing.`
       );
     }
+    if (!parsedArgs["skip-local-check"]) {
+      consola.start("Running local typecheck...");
+      const typecheckResult = await runLocalTypecheck(projectRoot);
+      if (typecheckResult.skipped) {
+        if (typecheckResult.output) {
+          consola.warn(typecheckResult.output);
+        }
+      } else if (!typecheckResult.success) {
+        if (typecheckResult.output) {
+          consola.error(typecheckResult.output);
+        }
+        throw new Error(
+          "Local typecheck failed. Fix the diagnostics or re-run with --skip-local-check."
+        );
+      } else {
+        consola.success("Local typecheck passed.");
+      }
+    }
     const ruleChanged = diff.modified.includes(RULE_FILE) || diff.added.includes(RULE_FILE);
     const manifestChanged = diff.modified.includes(MANIFEST_FILE) || diff.added.includes(MANIFEST_FILE);
     let manifestId = currentProjectConfig.manifestId;
@@ -22494,12 +22741,22 @@ ${sourceChanges.map((change) => `  - ${change.kind} ${change.path}`).join("\n")}
     if (shouldCheckpointPrecompileState) {
       await persistProjectProgress();
     }
-    const compiledResult = await createCompiledResultSdk({
+    const compileJob = await createCompiledResultSdk({
       gameId: currentProjectConfig.gameId,
       sourceRevisionId,
       manifestId,
       ruleId
     });
+    if (debug) {
+      consola.info(`[push --debug] compile job=${compileJob.jobId}`);
+    }
+    const { compiledResult } = await waitForCompiledResultJobSdk({
+      gameId: currentProjectConfig.gameId,
+      jobId: compileJob.jobId,
+      onProgress: (job) => {
+        consola.info(formatCompileJobProgressMessage(job));
+      }
+    });
     await persistProjectProgress({
       resultId: compiledResult.id,
       sourceRevisionId: compiledResult.sourceRevisionId
@@ -22637,7 +22894,7 @@ var status_default = defineCommand({
 });
 
 // src/commands/update.ts
-import path8 from "path";
+import path9 from "path";
 
 // src/utils/prompts.ts
 import { createInterface } from "readline/promises";
@@ -22805,14 +23062,14 @@ function findStalePhaseFiles(localFiles, expectedPhasePaths) {
 async function mergeUiArgsFileIfNeeded(projectRoot, files) {
   const incomingUiArgs = files[UI_ARGS_PATH];
   if (incomingUiArgs === null || incomingUiArgs === void 0) return;
-  const localPath = path8.join(projectRoot, UI_ARGS_PATH);
+  const localPath = path9.join(projectRoot, UI_ARGS_PATH);
   const localUiArgs = await readTextFileIfExists(localPath);
   if (localUiArgs === null) return;
   if (localUiArgs.trim().length === 0) return;
   if (localUiArgs === incomingUiArgs) return;
   const mergeResult = mergeUiArgsContent(localUiArgs, incomingUiArgs);
   files[UI_ARGS_PATH] = mergeResult.content;
-  await ensureDir(path8.dirname(localPath));
+  await ensureDir(path9.dirname(localPath));
   await writeTextFile(localPath, mergeResult.content);
   if (mergeResult.conflicted) {
     throw new Error(
@@ -23104,7 +23361,7 @@ var update_default = defineCommand({
 });
 
 // src/commands/run.ts
-import path10 from "path";
+import path11 from "path";
 import { appendFile } from "fs/promises";
 
 // src/services/workflows/resolve-run-result.ts
@@ -23132,7 +23389,7 @@ async function resolveCompiledResultForRun(projectRoot, projectConfig) {
 }
 
 // src/ui/playwright-runner.ts
-import path9 from "path";
+import path10 from "path";
 async function runUiSteps(page, steps, outputDir, turnTracker) {
   let stepIndex = 0;
   for (const step of steps) {
@@ -23168,7 +23425,7 @@ async function runUiSteps(page, steps, outputDir, turnTracker) {
     const turns = typeof step.turns === "number" ? step.turns : 1;
     await turnTracker.waitForTurns(Math.max(0, Math.floor(turns)));
     await page.screenshot({
-      path: path9.join(outputDir, `step-${stepIndex}.png`)
+      path: path10.join(outputDir, `step-${stepIndex}.png`)
     });
     stepIndex++;
   }
@@ -23398,12 +23655,12 @@ var run_default = defineCommand({
       webBaseUrl: config2.webBaseUrl,
       parsedArgs
     });
-    const runDir = path10.join(projectRoot, PROJECT_DIR_NAME, "run");
+    const runDir = path11.join(projectRoot, PROJECT_DIR_NAME, "run");
     await ensureDir(runDir);
-    const sessionFilePath = path10.join(runDir, "session.json");
-    const eventsFilePath = path10.join(runDir, "events.ndjson");
-    const yourTurnFilePath = path10.join(runDir, "latest-your-turn.json");
-    const summaryFilePath = path10.join(runDir, "last-run-summary.json");
+    const sessionFilePath = path11.join(runDir, "session.json");
+    const eventsFilePath = path11.join(runDir, "events.ndjson");
+    const yourTurnFilePath = path11.join(runDir, "latest-your-turn.json");
+    const summaryFilePath = path11.join(runDir, "last-run-summary.json");
     const shouldResume = !runtime.isEmbeddedHarness && parsedArgs.resume && !parsedArgs["new-session"];
     const until = parsedArgs.until;
     const observeEvents = parsedArgs["observe-events"];
@@ -23510,7 +23767,7 @@ var run_default = defineCommand({
                   "UI scenario execution requires Playwright page context, but browser was not initialized."
                 );
               }
-              const outputDir = path10.join(
+              const outputDir = path11.join(
                 projectRoot,
                 PROJECT_DIR_NAME,
                 "screenshots"
@@ -23593,13 +23850,13 @@ var run_default = defineCommand({
               "Screenshot capture requires Playwright page context, but browser was not initialized."
             );
           }
-          const outputDir = path10.join(
+          const outputDir = path11.join(
             projectRoot,
             PROJECT_DIR_NAME,
             "screenshots"
           );
           await ensureDir(outputDir);
-          const screenshotPath = parsedArgs.output ?? path10.join(outputDir, `run-${Date.now()}.png`);
+          const screenshotPath = parsedArgs.output ?? path11.join(outputDir, `run-${Date.now()}.png`);
           if (screenshotDelayMs && screenshotDelayMs > 0) {
             await sleep(screenshotDelayMs);
           }
@@ -24501,13 +24758,13 @@ function extractGameStatePhase(event) {
 }
 
 // src/commands/start.ts
-import path11 from "path";
+import path12 from "path";
 
 // src/auth/auth-server.ts
 import {
   createServer
 } from "http";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 async function startCliAuthServer(state, timeoutMs) {
   let resolveToken;
   let rejectToken;
@@ -24622,7 +24879,7 @@ function openBrowser(url2) {
   } else {
     command = ["xdg-open", url2];
   }
-  const child = spawn(command[0], command.slice(1), {
+  const child = spawn2(command[0], command.slice(1), {
     stdio: "ignore",
     detached: true
   });
@@ -24691,8 +24948,8 @@ var start_default = defineCommand({
         formatApiError(startError, startResponse, "Failed to start game")
       );
     }
-    const runDir = path11.join(projectRoot, PROJECT_DIR_NAME, "run");
-    const sessionFilePath = path11.join(runDir, "session.json");
+    const runDir = path12.join(projectRoot, PROJECT_DIR_NAME, "run");
+    const sessionFilePath = path12.join(runDir, "session.json");
     await ensureDir(runDir);
     const persistedSession = createPersistedRunSession({
       sessionId: session.sessionId,
@@ -25061,7 +25318,7 @@ var config_default = defineCommand({
 });
 
 // src/commands/test.ts
-import path13 from "path";
+import path14 from "path";
 import { readdir as readdir2, unlink as unlink3 } from "fs/promises";
 import { isDeepStrictEqual } from "util";
 
@@ -25076,7 +25333,7 @@ function shouldUseRemoteTestRuntime(environment) {
 // src/utils/ts-module-loader.ts
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
-import path12 from "path";
+import path13 from "path";
 import { pathToFileURL } from "url";
 import { build } from "esbuild";
 var ESBUILD_EXTERNALS = [
@@ -25086,10 +25343,10 @@ var ESBUILD_EXTERNALS = [
   "electron"
 ];
 async function importTypeScriptModule(entryPath) {
-  const tempDir = await mkdtemp(path12.join(tmpdir(), "dreamboard-ts-module-"));
-  const outfile = path12.join(
+  const tempDir = await mkdtemp(path13.join(tmpdir(), "dreamboard-ts-module-"));
+  const outfile = path13.join(
     tempDir,
-    `${path12.basename(entryPath).replace(/\.[^.]+$/u, "")}.mjs`
+    `${path13.basename(entryPath).replace(/\.[^.]+$/u, "")}.mjs`
   );
   try {
     await build({
@@ -25215,7 +25472,7 @@ var generateCommand = defineCommand({
           }
         };
       }
-      const generatedDir = path13.join(projectRoot, "test", "generated");
+      const generatedDir = path14.join(projectRoot, "test", "generated");
       await ensureDir(generatedDir);
       await writeGeneratedFiles({
         generatedDir,
@@ -25415,7 +25672,7 @@ async function runSingleScenario(options) {
   });
 }
 async function loadGeneratedBaseStates(projectRoot) {
-  const filePath = path13.join(
+  const filePath = path14.join(
     projectRoot,
     "test",
     "generated",
@@ -25434,7 +25691,7 @@ async function loadGeneratedBaseStates(projectRoot) {
   return baseStates;
 }
 async function loadScenarios(projectRoot, options) {
-  const scenarioFiles = options.scenarioPath ? [path13.resolve(projectRoot, options.scenarioPath)] : await discoverScenarioFiles(path13.join(projectRoot, "test", "scenarios"));
+  const scenarioFiles = options.scenarioPath ? [path14.resolve(projectRoot, options.scenarioPath)] : await discoverScenarioFiles(path14.join(projectRoot, "test", "scenarios"));
   const loaded = [];
   for (const scenarioFile of scenarioFiles) {
     const module = await importTypeScriptModule(scenarioFile);
@@ -25463,7 +25720,7 @@ async function discoverScenarioFiles(root) {
   const entries = await readdir2(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path13.join(root, entry.name);
+    const entryPath = path14.join(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await discoverScenarioFiles(entryPath));
       continue;
@@ -25549,8 +25806,8 @@ async function writeGeneratedFiles(options) {
 `;
   const manifest = options.scenarios.map((scenario) => ({
     id: scenario.scenario.meta.id,
-    filePath: path13.relative(
-      path13.dirname(options.generatedDir),
+    filePath: path14.relative(
+      path14.dirname(options.generatedDir),
       scenario.filePath
     ),
     base: scenario.scenario.given.base
@@ -25558,19 +25815,19 @@ async function writeGeneratedFiles(options) {
   const scenarioManifestContent = `${generatedHeader}export const SCENARIO_MANIFEST = ${JSON.stringify(manifest, null, 2)} as const;
 `;
   await writeTextFile(
-    path13.join(options.generatedDir, "base-states.generated.ts"),
+    path14.join(options.generatedDir, "base-states.generated.ts"),
     baseStatesContent
   );
   await writeTextFile(
-    path13.join(options.generatedDir, "base-states.generated.d.ts"),
+    path14.join(options.generatedDir, "base-states.generated.d.ts"),
     baseStatesDtsContent
   );
   await writeTextFile(
-    path13.join(options.generatedDir, "scenario-manifest.generated.ts"),
+    path14.join(options.generatedDir, "scenario-manifest.generated.ts"),
     scenarioManifestContent
   );
   await writeJsonFile(
-    path13.join(options.generatedDir, ".generation-meta.json"),
+    path14.join(options.generatedDir, ".generation-meta.json"),
     {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       scenarioCount: options.scenarios.length,
@@ -25579,7 +25836,7 @@ async function writeGeneratedFiles(options) {
   );
 }
 async function ensureScenarioImportShim(projectRoot) {
-  const testingTypesRuntimePath = path13.join(
+  const testingTypesRuntimePath = path14.join(
     projectRoot,
     "test",
     "testing-types.ts"
@@ -25588,11 +25845,11 @@ async function ensureScenarioImportShim(projectRoot) {
     testingTypesRuntimePath
   );
   if (shouldRefreshGeneratedTestingTypes2(existingTestingTypes)) {
-    await ensureDir(path13.dirname(testingTypesRuntimePath));
+    await ensureDir(path14.dirname(testingTypesRuntimePath));
     await writeTextFile(testingTypesRuntimePath, TESTING_TYPES_CONTENT);
   }
   await migrateLegacyScenarioImports(projectRoot);
-  const staleDtsPath = path13.join(projectRoot, "test", "testing-types.d.ts");
+  const staleDtsPath = path14.join(projectRoot, "test", "testing-types.d.ts");
   if (await exists(staleDtsPath)) {
     await unlink3(staleDtsPath);
   }
@@ -25837,7 +26094,7 @@ function validateFingerprint(options) {
   }
 }
 async function loadBaseScenarioDefinitions(projectRoot) {
-  const filePath = path13.join(projectRoot, "test", "base-scenarios.json");
+  const filePath = path14.join(projectRoot, "test", "base-scenarios.json");
   if (!await exists(filePath)) {
     throw new Error(
       "Missing test/base-scenarios.json. Define base checkpoints there, including 'initial-turn'."
@@ -25871,7 +26128,7 @@ async function loadBaseScenarioDefinitions(projectRoot) {
 function validateScenarioBases(scenarios, baseScenarios) {
   const available = new Set(Object.keys(baseScenarios));
   const invalid = scenarios.filter((scenario) => !available.has(scenario.scenario.given.base)).map(
-    (scenario) => path13.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.scenario.given.base}'`
+    (scenario) => path14.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.scenario.given.base}'`
   );
   if (invalid.length === 0) {
     return;
@@ -25956,7 +26213,7 @@ var subCommands = {
 var main = defineCommand({
   meta: {
     name: "dreamboard",
-    version: "0.1.4",
+    version: "0.1.6",
     description: "Dreamboard CLI \u2014 game development platform"
   },
   subCommands