@dreamboard-games/cli 0.1.30-alpha.2 → 0.1.30-alpha.21

package/dist/agent-verifier/chunk-22U6RMWO.mjs

@@ -0,0 +1,722 @@
+#!/usr/bin/env node
+import {
+  REDUCER_TESTING_TYPES_WRAPPER_CONTENT
+} from "./chunk-F2DIOJJZ.mjs";
+import {
+  ensureDir
+} from "./chunk-RDYXWXXC.mjs";
+import {
+  isDynamicSeedPath,
+  materializeManifest
+} from "./chunk-BWBN2TDJ.mjs";
+import {
+  normalizeOwnedProjectPath,
+  readWorkspaceTextFile,
+  readWorkspaceTextFileIfExists,
+  removeWorkspacePath,
+  resolveWorkspacePath,
+  unlinkWorkspaceFile,
+  workspacePathExists,
+  writeWorkspaceTextFile
+} from "./chunk-OJFZVGEL.mjs";
+import {
+  FRAMEWORK_PNPM_OVERRIDES,
+  FRAMEWORK_REACT_DEPENDENCIES,
+  FRAMEWORK_ZOD_VERSION
+} from "./chunk-ZEELHSY3.mjs";
+import {
+  MANIFEST_TYPECHECK_CONFIG_FILE
+} from "./chunk-M7UVBANQ.mjs";
+
+// src/services/project/static-scaffold.ts
+import { existsSync } from "fs";
+import { readdir, readFile, rmdir } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// src/release/authoring-release-set.generated.ts
+var AUTHORING_RELEASE_SET = {
+  "schemaVersion": 1,
+  "channel": "public",
+  "packages": {
+    "cli": {
+      "name": "@dreamboard-games/cli",
+      "version": "0.1.30-alpha.21"
+    },
+    "sdk": {
+      "name": "@dreamboard-games/sdk",
+      "version": "0.4.0-alpha.6"
+    },
+    "apiClient": {
+      "name": "@dreamboard-games/api-client",
+      "version": "0.3.0-alpha.4"
+    },
+    "devHost": {
+      "name": "@dreamboard-games/dev-host",
+      "version": "0.1.30-alpha.19"
+    }
+  },
+  "protocols": {
+    "authoringAdapter": 1,
+    "devHost": 1,
+    "verifier": 1
+  },
+  "schemas": {
+    "scaffold": 2,
+    "manifest": 2,
+    "generatedArtifacts": 1
+  },
+  "registry": {
+    "kind": "public-npm",
+    "portable": true
+  },
+  "packageManager": "pnpm@10.4.1",
+  "releaseSetId": "sha256:9719136d41000ccb72a11154e402a320e5cefd56905b1555b05a05d710d1d7e4"
+};
+
+// src/services/project/static-scaffold.ts
+var DREAMBOARD_SCAFFOLD_REFRESH_COMMAND = "dreamboard project create or dreamboard project clone";
+var DREAMBOARD_GITIGNORE_BLOCK = [
+  "# Dreamboard local state",
+  ".dreamboard/state.json",
+  ".dreamboard/snapshot.json",
+  ".dreamboard/dev/",
+  ".dreamboard/generated/",
+  "node_modules/",
+  "ui/node_modules/",
+  ""
+].join("\n");
+var TESTING_TYPES_STUB = "export function defineScenario(scenario) { return scenario; }\n";
+var GENERATED_TESTING_TYPES_PREFIX = "// Generated by dreamboard";
+var GENERATED_SCENARIO_PREFIX = "// Generated by dreamboard scaffold.";
+var LEGACY_DREAMBOARD_COMPONENT_INDEX_CONTENT = `export {
+  ErrorBoundary,
+  type ErrorBoundaryProps,
+} from "@dreamboard-games/sdk/ui";
+export { PluginRuntime, type PluginRuntimeProps } from "@dreamboard-games/sdk/runtime";
+`;
+var OLD_LEGACY_DREAMBOARD_COMPONENT_INDEX_CONTENT = [
+  "export {",
+  "  ErrorBoundary,",
+  "  PluginRuntime,",
+  "  type ErrorBoundaryProps,",
+  "  type PluginRuntimeProps,",
+  `} from "@dreamboard/ui-${"sdk"}";`,
+  ""
+].join("\n");
+var OLD_PUBLIC_DREAMBOARD_COMPONENT_INDEX_CONTENT = [
+  "export {",
+  "  ErrorBoundary,",
+  "  PluginRuntime,",
+  "  type ErrorBoundaryProps,",
+  "  type PluginRuntimeProps,",
+  `} from "@dreamboard-games/ui-${"sdk"}";`,
+  ""
+].join("\n");
+var INITIAL_SCENARIO_CONTENT = `${GENERATED_SCENARIO_PREFIX}
+import { defineScenario } from "../testing-types";
+
+export default defineScenario({
+  id: "smoke-initial-turn",
+  description:
+    "Sanity check that the scaffolded workspace boots into its initial phase.",
+  from: "initial-turn",
+  when: async () => undefined,
+  then: ({ expect, players, state }) => {
+    const playerIds = players();
+    expect(playerIds).toHaveLength(playerIds.length);
+    expect(playerIds.length).toBeGreaterThanOrEqual(1);
+    expect(state()).toBe("setup");
+  },
+});
+`;
+var STATIC_ASSET_ROOT = resolveStaticAssetRoot();
+var SDK_DEPENDENCY_RANGES = {
+  "@dreamboard-games/sdk": AUTHORING_RELEASE_SET.packages.sdk.version
+};
+var DEV_HOST_DEPENDENCY_RANGES = {
+  "@dreamboard-games/dev-host": AUTHORING_RELEASE_SET.packages.devHost.version
+};
+var DREAMBOARD_PACKAGE_OVERRIDES = {
+  "@dreamboard-games/api-client": AUTHORING_RELEASE_SET.packages.apiClient.version,
+  "@dreamboard-games/dev-host": AUTHORING_RELEASE_SET.packages.devHost.version,
+  "@dreamboard-games/sdk": AUTHORING_RELEASE_SET.packages.sdk.version
+};
+var FRAMEWORK_SCRIPTS = {
+  dev: "dreamboard dev",
+  "test:ui": "tsx --tsconfig test/tsconfig.tsx-runtime.json --test test/ui/**/*.test.tsx",
+  typecheck: `tsc --noEmit -p ${MANIFEST_TYPECHECK_CONFIG_FILE} && tsc --noEmit -p app/tsconfig.json && tsc --noEmit -p ui/tsconfig.json`,
+  "typecheck:manifest": `tsc --noEmit -p ${MANIFEST_TYPECHECK_CONFIG_FILE}`,
+  "typecheck:app": "tsc --noEmit -p app/tsconfig.json",
+  "typecheck:ui": "tsc --noEmit -p ui/tsconfig.json"
+};
+var SHARED_DEPENDENCIES = {
+  ...FRAMEWORK_REACT_DEPENDENCIES
+};
+var ROOT_APP_DEPENDENCIES = {
+  zod: FRAMEWORK_ZOD_VERSION
+};
+var SHARED_DEV_DEPENDENCIES = {
+  typescript: "^5.9.2",
+  "@types/node": "^24.5.2",
+  "@types/react": "^19.0.0",
+  "@types/react-dom": "^19.0.0",
+  csstype: "^3.1.3",
+  tsx: "^4.20.5"
+};
+async function scaffoldStaticWorkspace(projectRoot, mode, options = {}) {
+  await writeFrameworkStaticFiles(projectRoot, mode, options);
+  await ensureDreamboardGitignore(projectRoot);
+  await writeManifestTypecheckTsconfig(projectRoot);
+  await removeLegacyVendoredSdkPaths(projectRoot);
+  await removeLegacyDreamboardComponentPath(projectRoot);
+  await ensureDir(resolveWorkspacePath(projectRoot, "test/bases"));
+  await ensureDir(resolveWorkspacePath(projectRoot, "test/scenarios"));
+  await ensureDir(resolveWorkspacePath(projectRoot, "test/generated"));
+  await writeTestReadme(projectRoot);
+  await writeGeneratedTestingStubs(projectRoot, mode);
+  const initialTestPlayerCount = await inferInitialTestPlayerCount(projectRoot);
+  await writeInitialBase(projectRoot, mode, initialTestPlayerCount);
+  await writeInitialScenario(projectRoot, mode);
+  await writeTestingTypes(projectRoot, mode);
+  await writeTestTsconfig(projectRoot);
+  if (await workspacePathExists(projectRoot, "test/testing-types.d.ts")) {
+    await unlinkWorkspaceFile(projectRoot, "test/testing-types.d.ts");
+  }
+  if (await workspacePathExists(projectRoot, "test/base-scenarios.json")) {
+    await unlinkWorkspaceFile(projectRoot, "test/base-scenarios.json");
+  }
+  await migrateLegacyScenarioImports(projectRoot);
+}
+async function ensureDreamboardGitignore(projectRoot) {
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    ".gitignore"
+  );
+  if (existing?.includes(".dreamboard/state.json")) {
+    return;
+  }
+  await writeWorkspaceTextFile(
+    projectRoot,
+    ".gitignore",
+    `${existing ? `${existing.trimEnd()}
+
+` : ""}${DREAMBOARD_GITIGNORE_BLOCK}`
+  );
+}
+async function assertCliStaticScaffoldComplete(projectRoot, deletedPaths = []) {
+  const expectedEntries = await getExpectedStaticEntries(projectRoot);
+  const missingOrBlankPaths = [];
+  for (const entry of expectedEntries) {
+    const content = await readWorkspaceTextFileIfExists(
+      projectRoot,
+      entry.targetPath
+    );
+    if (content === null || content.trim().length === 0) {
+      missingOrBlankPaths.push(entry.targetPath);
+    }
+  }
+  const staticPaths = new Set(expectedEntries.map((entry) => entry.targetPath));
+  const deletedStaticPaths = deletedPaths.map(normalizeOwnedProjectPath).filter(
+    (filePath) => filePath !== null && staticPaths.has(filePath)
+  ).sort();
+  if (missingOrBlankPaths.length === 0 && deletedStaticPaths.length === 0) {
+    return;
+  }
+  const problems = [];
+  if (missingOrBlankPaths.length > 0) {
+    problems.push(
+      `missing or blank: ${summarizePaths(missingOrBlankPaths.sort())}`
+    );
+  }
+  if (deletedStaticPaths.length > 0) {
+    problems.push(`deleted: ${summarizePaths(deletedStaticPaths)}`);
+  }
+  throw new Error(
+    `CLI static scaffold is incomplete (${problems.join("; ")}). Refresh the project scaffold with ${DREAMBOARD_SCAFFOLD_REFRESH_COMMAND} before building or testing.`
+  );
+}
+async function writeFrameworkStaticFiles(projectRoot, mode, options) {
+  const assetEntries = await getStaticAssetEntries();
+  for (const entry of assetEntries) {
+    if (mode === "update" && isDynamicSeedPath(entry.targetPath)) {
+      const existing = await readWorkspaceTextFileIfExists(
+        projectRoot,
+        entry.targetPath
+      );
+      if (existing !== null && existing.trim().length > 0) {
+        continue;
+      }
+    }
+    await writeWorkspaceTextFile(projectRoot, entry.targetPath, entry.content);
+  }
+  for (const entry of await getDynamicStaticEntries(
+    projectRoot,
+    mode,
+    options
+  )) {
+    await writeWorkspaceTextFile(projectRoot, entry.targetPath, entry.content);
+  }
+  if (!options.localMaintainerRegistry) {
+    await removeWorkspacePath(projectRoot, ".npmrc", { force: true });
+  }
+}
+async function removeLegacyVendoredSdkPaths(projectRoot) {
+  await removeWorkspacePath(projectRoot, "app/sdk", {
+    recursive: true,
+    force: true
+  });
+  await removeWorkspacePath(projectRoot, "ui/sdk", {
+    recursive: true,
+    force: true
+  });
+}
+async function removeLegacyDreamboardComponentPath(projectRoot) {
+  const legacyIndexProjectPath = "ui/components/dreamboard/index.ts";
+  const legacyDirPath = resolveWorkspacePath(
+    projectRoot,
+    "ui/components/dreamboard"
+  );
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    legacyIndexProjectPath
+  );
+  const removableLegacyContents = /* @__PURE__ */ new Set([
+    LEGACY_DREAMBOARD_COMPONENT_INDEX_CONTENT.trim(),
+    OLD_LEGACY_DREAMBOARD_COMPONENT_INDEX_CONTENT.trim(),
+    OLD_PUBLIC_DREAMBOARD_COMPONENT_INDEX_CONTENT.trim()
+  ]);
+  if (existing === null || !removableLegacyContents.has(existing.trim())) {
+    return;
+  }
+  await unlinkWorkspaceFile(projectRoot, legacyIndexProjectPath);
+  const remainingEntries = await readdir(legacyDirPath).catch(() => []);
+  if (remainingEntries.length === 0) {
+    await rmdir(legacyDirPath);
+  }
+}
+async function writeTestReadme(projectRoot) {
+  await writeWorkspaceTextFile(
+    projectRoot,
+    "test/README.md",
+    "# Dreamboard Test Workspace\n\nTypeScript bases live in `test/bases/*.base.ts` and scenarios live in `test/scenarios/*.scenario.ts`.\n\n1. Define reusable seeded bases with `defineBase({ id, seed, players, setupProfileId?, setup })`.\n2. Define scenarios with `defineScenario({ id, from, when, then })`.\n3. Scenario assertions can read `players()`, `state()`, `view(playerId)`, and `interactions(playerId)`.\n4. Run deterministic scenario tests: `dreamboard test`.\n5. Run a single scenario when needed: `dreamboard test --scenario <scenario-id>`.\n\nImport test helpers from `../testing-types`.\n\nGenerated artifacts are written to `test/generated/*` and should not be edited manually.\n"
+  );
+}
+async function writeInitialBase(projectRoot, mode, players) {
+  if (mode === "update") {
+    return;
+  }
+  await writeWorkspaceTextFile(
+    projectRoot,
+    "test/bases/initial-turn.base.ts",
+    `import { defineBase } from "../testing-types";
+
+export default defineBase({
+  id: "initial-turn",
+  seed: 1337,
+  players: ${players},
+  setup: async () => undefined,
+});
+`
+  );
+}
+async function writeInitialScenario(projectRoot, mode) {
+  if (mode === "new") {
+    await writeWorkspaceTextFile(
+      projectRoot,
+      "test/scenarios/smoke-initial-turn.scenario.ts",
+      INITIAL_SCENARIO_CONTENT
+    );
+    return;
+  }
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    "test/scenarios/smoke-initial-turn.scenario.ts"
+  );
+  if (existing === null || existing.trim().length === 0 || existing.startsWith(GENERATED_SCENARIO_PREFIX)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
+      "test/scenarios/smoke-initial-turn.scenario.ts",
+      INITIAL_SCENARIO_CONTENT
+    );
+  }
+}
+async function writeTestingTypes(projectRoot, mode) {
+  if (mode === "new") {
+    await writeWorkspaceTextFile(
+      projectRoot,
+      "test/testing-types.ts",
+      REDUCER_TESTING_TYPES_WRAPPER_CONTENT
+    );
+    return;
+  }
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    "test/testing-types.ts"
+  );
+  if (shouldRefreshGeneratedTestingTypes(existing)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
+      "test/testing-types.ts",
+      REDUCER_TESTING_TYPES_WRAPPER_CONTENT
+    );
+  }
+}
+async function writeGeneratedTestingStubs(projectRoot, mode) {
+  const header = "// Generated by dreamboard scaffold. Do not edit by hand.\n";
+  await writeGeneratedTestingStubFile(
+    projectRoot,
+    "test/generated/base-states.generated.ts",
+    `${header}export const BASE_STATES = {} as const;
+export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
+`,
+    mode
+  );
+  await writeGeneratedTestingStubFile(
+    projectRoot,
+    "test/generated/base-states.generated.d.ts",
+    `${header}export declare const BASE_STATES: Record<string, unknown>;
+export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
+`,
+    mode
+  );
+  await writeGeneratedTestingStubFile(
+    projectRoot,
+    "test/generated/testing-contract.ts",
+    `${header}export type BaseId = string;
+export type GameView = unknown;
+export type InteractionId = string;
+export type InteractionParamsOf<_Id extends string> = Record<string, unknown>;
+export type PhaseName = string;
+export type PlayerId = string;
+export type RejectionCode = string;
+export type StateName = string;
+export type TestRunner = "reducer" | "remote" | "browser";
+export type ViewByPhase = Record<string, GameView>;
+export type WorkspaceStageName<_Phase extends string = string> = string;
+export type Expectation = { [matcher: string]: (...args: unknown[]) => unknown; not: Expectation };
+export type ExpectFn = (actual: unknown) => Expectation;
+export type InteractionExplanation = { interactionId: string; phase: string; step: string | null; availability: "available" | "notYourTurn" | "wrongPhase" | "wrongStep" | "blocked"; rules: readonly { ruleId: string; outcome: "passed" | "failed" | "notEvaluated"; errorCode?: string; message?: string; }[]; actor: { required: readonly string[]; playerIsActor: boolean }; inputs: readonly { key: string; kind: string; eligibleCount: number | "lazy"; }[]; };
+export interface InteractionDescriptorFor<Id extends string = string> { interactionId: Id; [key: string]: unknown; }
+export interface ScenarioGameApi { start(): Promise<void>; submit<Id extends InteractionId>(playerId: PlayerId, interactionId: Id, params?: InteractionParamsOf<Id>): Promise<void>; }
+export interface BaseContext { game: ScenarioGameApi; players(): readonly PlayerId[]; seat(index: number): PlayerId; }
+export interface SharedScenarioContext { game: ScenarioGameApi; players(): readonly PlayerId[]; seat(index: number): PlayerId; state(): StateName; view(playerId: PlayerId): GameView; interactions(playerId: PlayerId): readonly InteractionDescriptorFor[]; explain(playerId: PlayerId, interactionId: InteractionId): InteractionExplanation; expect: ExpectFn; }
+export type ScenarioContext<Phase extends PhaseName | undefined = undefined> = Omit<SharedScenarioContext, "state" | "view"> & { state(): Phase extends PhaseName ? Phase : StateName; view(playerId: PlayerId): Phase extends PhaseName ? ViewByPhase[Phase] : GameView; };
+export type ScenarioThenContext<_Runners extends readonly TestRunner[] = readonly ["reducer"], Phase extends PhaseName | undefined = undefined> = ScenarioContext<Phase>;
+export interface BaseDefinition { id: string; seed?: number; players?: number; setupProfileId?: string; extends?: BaseId | string; setup: (ctx: BaseContext) => void | Promise<void>; }
+export interface ScenarioDefinition<Runners extends readonly TestRunner[] = readonly ["reducer"], Phase extends PhaseName | undefined = undefined> { id: string; description?: string; from: BaseId | string; runners?: Runners; phase?: Phase; stage?: Phase extends PhaseName ? WorkspaceStageName<Phase> : never; when: (ctx: ScenarioContext<Phase>) => void | Promise<void>; then: (ctx: ScenarioThenContext<Runners, Phase>) => void | Promise<void>; }
+`,
+    mode
+  );
+  await writeGeneratedTestingStubFile(
+    projectRoot,
+    "test/generated/scenario-manifest.generated.ts",
+    `${header}export const SCENARIO_MANIFEST = [] as const;
+`,
+    mode
+  );
+}
+async function writeGeneratedTestingStubFile(projectRoot, projectPath, content, mode) {
+  if (mode === "new") {
+    await writeWorkspaceTextFile(projectRoot, projectPath, content);
+    return;
+  }
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    projectPath
+  );
+  if (existing === null || existing.trim().length === 0 || existing.startsWith(GENERATED_SCENARIO_PREFIX)) {
+    await writeWorkspaceTextFile(projectRoot, projectPath, content);
+  }
+}
+async function writeTestTsconfig(projectRoot) {
+  await writeWorkspaceTextFile(
+    projectRoot,
+    "test/tsconfig.json",
+    `${JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          noEmit: true
+        },
+        include: [
+          "./**/*.ts",
+          "./**/*.d.ts",
+          "../shared/**/*.ts",
+          "../shared/**/*.d.ts"
+        ]
+      },
+      null,
+      2
+    )}
+`
+  );
+}
+async function writeManifestTypecheckTsconfig(projectRoot) {
+  await writeWorkspaceTextFile(
+    projectRoot,
+    MANIFEST_TYPECHECK_CONFIG_FILE,
+    `${JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          noEmit: true,
+          allowImportingTsExtensions: true
+        },
+        include: ["./manifest.ts"]
+      },
+      null,
+      2
+    )}
+`
+  );
+}
+async function migrateLegacyScenarioImports(projectRoot) {
+  if (!await workspacePathExists(projectRoot, "test/scenarios")) return;
+  const scenariosRoot = resolveWorkspacePath(projectRoot, "test/scenarios");
+  const scenarioFiles = await collectScenarioFiles(scenariosRoot);
+  for (const filePath of scenarioFiles) {
+    const projectPath = toWorkspaceProjectPath(projectRoot, filePath);
+    const content = await readWorkspaceTextFile(projectRoot, projectPath);
+    if (!content.includes("@dreamboard/cli/testing")) continue;
+    const relativeToTestingTypes = normalizeImportPath(
+      path.relative(
+        path.dirname(filePath),
+        path.join(projectRoot, "test", "testing-types")
+      )
+    );
+    const migrated = content.replaceAll('"@dreamboard/cli/testing"', `"${relativeToTestingTypes}"`).replaceAll("'@dreamboard/cli/testing'", `'${relativeToTestingTypes}'`);
+    if (migrated !== content) {
+      await writeWorkspaceTextFile(projectRoot, projectPath, migrated);
+    }
+  }
+}
+function shouldRefreshGeneratedTestingTypes(existingContent) {
+  if (existingContent === null || existingContent.trim().length === 0) {
+    return true;
+  }
+  if (existingContent === TESTING_TYPES_STUB) {
+    return true;
+  }
+  return existingContent.startsWith(GENERATED_TESTING_TYPES_PREFIX);
+}
+async function inferInitialTestPlayerCount(projectRoot) {
+  if (!await workspacePathExists(projectRoot, "manifest.ts")) {
+    return 4;
+  }
+  try {
+    const manifest = await materializeManifest(projectRoot);
+    return manifest.players.optimalPlayers ?? manifest.players.minPlayers ?? 4;
+  } catch {
+    return 4;
+  }
+}
+async function collectScenarioFiles(rootDir) {
+  const files = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (!dir) continue;
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function resolveStaticAssetRoot(importUrl = import.meta.url) {
+  const candidates = [
+    fileURLToPath(new URL("../../scaffold/assets/static/", importUrl)),
+    fileURLToPath(new URL("./scaffold/assets/static/", importUrl)),
+    fileURLToPath(new URL("../scaffold/assets/static/", importUrl))
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Unable to locate CLI static scaffold assets. Checked: ${candidates.join(", ")}`
+  );
+}
+async function getStaticAssetEntries() {
+  const files = await walkFiles(STATIC_ASSET_ROOT);
+  const entries = [];
+  for (const filePath of files) {
+    const targetPath = normalizeOwnedProjectPath(
+      path.relative(STATIC_ASSET_ROOT, filePath).replaceAll(path.sep, "/")
+    );
+    if (targetPath === null) {
+      throw new Error(`Unsafe static scaffold asset path: ${filePath}`);
+    }
+    entries.push({
+      targetPath,
+      content: await readFile(filePath, "utf8")
+    });
+  }
+  entries.sort(
+    (left, right) => left.targetPath.localeCompare(right.targetPath)
+  );
+  return entries;
+}
+async function getDynamicStaticEntries(projectRoot, mode, options = {}) {
+  const entries = [
+    {
+      targetPath: "package.json",
+      content: await buildRootPackageJson(projectRoot, mode, options)
+    },
+    {
+      targetPath: "ui/package.json",
+      content: buildUiPackageJson()
+    }
+  ];
+  if (options.localMaintainerRegistry) {
+    entries.push({
+      targetPath: ".npmrc",
+      content: buildWorkspaceNpmrc(options.localMaintainerRegistry.registryUrl)
+    });
+  }
+  return entries;
+}
+async function getExpectedStaticEntries(projectRoot) {
+  const entries = [
+    ...(await getStaticAssetEntries()).filter(
+      (entry) => entry.targetPath !== ".npmrc"
+    ),
+    ...await getDynamicStaticEntries(projectRoot, "update")
+  ];
+  entries.sort(
+    (left, right) => left.targetPath.localeCompare(right.targetPath)
+  );
+  return entries;
+}
+async function walkFiles(rootDir) {
+  const files = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    if (!currentDir) continue;
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  }
+  files.sort((left, right) => left.localeCompare(right));
+  return files;
+}
+async function buildRootPackageJson(projectRoot, mode, options) {
+  const sdkPackageRanges = {
+    ...SDK_DEPENDENCY_RANGES,
+    ...options.localMaintainerRegistry?.packages ?? {}
+  };
+  const existingPackageJson = mode === "update" && await workspacePathExists(projectRoot, "package.json") ? JSON.parse(
+    await readWorkspaceTextFile(projectRoot, "package.json")
+  ) : null;
+  const {
+    dreamboardFrameworkVersion: _legacyFrameworkVersion,
+    ...existingPackageJsonWithoutLegacyVersion
+  } = existingPackageJson ?? {};
+  const frameworkDependencies = {
+    "@dreamboard-games/sdk": sdkPackageRanges["@dreamboard-games/sdk"] ?? SDK_DEPENDENCY_RANGES["@dreamboard-games/sdk"],
+    ...SHARED_DEPENDENCIES,
+    ...ROOT_APP_DEPENDENCIES
+  };
+  const frameworkDevDependencies = {
+    ...SHARED_DEV_DEPENDENCIES,
+    ...DEV_HOST_DEPENDENCY_RANGES
+  };
+  const nextPackageJson = {
+    ...existingPackageJsonWithoutLegacyVersion,
+    private: true,
+    packageManager: AUTHORING_RELEASE_SET.packageManager,
+    scripts: {
+      ...existingPackageJson?.scripts ?? {},
+      ...FRAMEWORK_SCRIPTS
+    },
+    dependencies: {
+      ...existingPackageJson?.dependencies ?? {},
+      ...frameworkDependencies
+    },
+    devDependencies: {
+      ...existingPackageJson?.devDependencies ?? {},
+      ...frameworkDevDependencies
+    },
+    pnpm: mergePnpmConfig(existingPackageJson?.pnpm)
+  };
+  return `${JSON.stringify(nextPackageJson, null, 2)}
+`;
+}
+function mergePnpmConfig(existingPnpm) {
+  const existingOverrides = existingPnpm?.overrides && typeof existingPnpm.overrides === "object" && !Array.isArray(existingPnpm.overrides) ? existingPnpm.overrides : {};
+  return {
+    ...existingPnpm ?? {},
+    overrides: {
+      ...existingOverrides,
+      ...FRAMEWORK_PNPM_OVERRIDES,
+      ...DREAMBOARD_PACKAGE_OVERRIDES
+    }
+  };
+}
+function buildWorkspaceNpmrc(registryUrl) {
+  return `@dreamboard-games:registry=${registryUrl}
+`;
+}
+function buildUiPackageJson() {
+  return `${JSON.stringify(
+    {
+      private: true,
+      dependencies: SHARED_DEPENDENCIES,
+      devDependencies: SHARED_DEV_DEPENDENCIES
+    },
+    null,
+    2
+  )}
+`;
+}
+function normalizeImportPath(relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/");
+  if (normalized.startsWith(".")) return normalized;
+  return `./${normalized}`;
+}
+function toWorkspaceProjectPath(projectRoot, filePath) {
+  const relativePath = path.relative(path.resolve(projectRoot), path.resolve(filePath)).replaceAll(path.sep, "/");
+  const projectPath = normalizeOwnedProjectPath(relativePath);
+  if (projectPath === null) {
+    throw new Error(`Unsafe project path: ${relativePath}`);
+  }
+  return projectPath;
+}
+function summarizePaths(paths) {
+  const maxShown = 5;
+  const shown = paths.slice(0, maxShown).join(", ");
+  if (paths.length <= maxShown) return shown;
+  return `${shown}, and ${paths.length - maxShown} more`;
+}
+
+export {
+  scaffoldStaticWorkspace,
+  assertCliStaticScaffoldComplete,
+  migrateLegacyScenarioImports,
+  resolveStaticAssetRoot
+};
+//# sourceMappingURL=chunk-22U6RMWO.mjs.map