@dreamboard-games/cli 0.1.30-alpha.3 → 0.1.30-alpha.31

package/dist/agent-verifier/{chunk-7WWGFAAU.mjs → chunk-NBRUEJUK.mjs}

@@ -1,49 +1,89 @@
 #!/usr/bin/env node
 import {
   REDUCER_TESTING_TYPES_WRAPPER_CONTENT
-} from "./chunk-F2DIOJJZ.mjs";
+} from "./chunk-XCQQIPCO.mjs";
 import {
-  IS_PUBLISHED_BUILD,
-  loadProjectConfig
-} from "./chunk-776W3UGV.mjs";
+  ensureDir
+} from "./chunk-LMW66VBH.mjs";
 import {
   isDynamicSeedPath,
   materializeManifest
-} from "./chunk-O4YCPU7C.mjs";
+} from "./chunk-BWBN2TDJ.mjs";
 import {
-  resolveCliRepoRoot
-} from "./chunk-UIZNWRM6.mjs";
-import {
-  ensureDir,
-  exists,
-  readJsonFile,
-  readTextFile,
-  readTextFileIfExists,
-  writeTextFile
-} from "./chunk-IAYRNVUC.mjs";
+  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,
-  PROJECT_CONFIG_FILE,
-  PROJECT_DIR_NAME
-} from "./chunk-H76MT5UR.mjs";
+  MANIFEST_TYPECHECK_CONFIG_FILE
+} from "./chunk-M7UVBANQ.mjs";
 
 // src/services/project/static-scaffold.ts
-import { existsSync, readFileSync } from "fs";
-import { readdir, readFile, rm, rmdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { readdir, readFile, rmdir } from "fs/promises";
 import path from "path";
 import { fileURLToPath } from "url";
-var DREAMBOARD_SYNC_COMMAND = "dreamboard sync";
+
+// 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.31"
+    },
+    "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:d4c979aab04c28c64e3b2f069051eecd00b968ec67fcbe5a7b133ca370e24462"
+};
+
+// 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";
@@ -82,26 +122,25 @@ export default defineScenario({
     "Sanity check that the scaffolded workspace boots into its initial phase.",
   from: "initial-turn",
   when: async () => undefined,
-  then: ({ expect, interactions, players, state }) => {
+  then: ({ expect, players, state }) => {
     const playerIds = players();
     expect(playerIds).toHaveLength(playerIds.length);
     expect(playerIds.length).toBeGreaterThanOrEqual(1);
     expect(state()).toBe("setup");
-    for (const playerId of playerIds) {
-      expect(interactions(playerId)).toEqual([]);
-    }
   },
 });
 `;
 var STATIC_ASSET_ROOT = resolveStaticAssetRoot();
-var SDK_PACKAGE_PATHS = {
-  "@dreamboard-games/sdk": ["packages", "sdk", "package.json"]
+var SDK_DEPENDENCY_RANGES = {
+  "@dreamboard-games/sdk": AUTHORING_RELEASE_SET.packages.sdk.version
 };
-var DEFAULT_SDK_DEPENDENCY_RANGES = {
-  "@dreamboard-games/sdk": "0.4.0-alpha.0"
+var DEV_HOST_DEPENDENCY_RANGES = {
+  "@dreamboard-games/dev-host": AUTHORING_RELEASE_SET.packages.devHost.version
 };
-var SDK_DEPENDENCY_RANGES = {
-  "@dreamboard-games/sdk": resolveSdkDependencyRange("@dreamboard-games/sdk")
+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",
@@ -128,50 +167,38 @@ var SHARED_DEV_DEPENDENCIES = {
 async function scaffoldStaticWorkspace(projectRoot, mode, options = {}) {
   await writeFrameworkStaticFiles(projectRoot, mode, options);
   await ensureDreamboardGitignore(projectRoot);
-  await writeManifestTypecheckTsconfig(
-    path.join(projectRoot, MANIFEST_TYPECHECK_CONFIG_FILE)
-  );
+  await writeManifestTypecheckTsconfig(projectRoot);
   await removeLegacyVendoredSdkPaths(projectRoot);
   await removeLegacyDreamboardComponentPath(projectRoot);
-  const testDir = path.join(projectRoot, "test");
-  const basesDir = path.join(testDir, "bases");
-  const scenariosDir = path.join(testDir, "scenarios");
-  const generatedDir = path.join(testDir, "generated");
-  await ensureDir(basesDir);
-  await ensureDir(scenariosDir);
-  await ensureDir(generatedDir);
-  await writeTestReadme(path.join(testDir, "README.md"));
-  await writeGeneratedTestingStubs(generatedDir, mode);
+  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(
-    path.join(basesDir, "initial-turn.base.ts"),
-    mode,
-    initialTestPlayerCount
-  );
-  await writeInitialScenario(
-    path.join(scenariosDir, "smoke-initial-turn.scenario.ts"),
-    mode
-  );
-  await writeTestingTypes(path.join(testDir, "testing-types.ts"), mode);
-  await writeTestTsconfig(path.join(testDir, "tsconfig.json"));
-  const staleDtsPath = path.join(testDir, "testing-types.d.ts");
-  if (await exists(staleDtsPath)) {
-    await unlink(staleDtsPath);
+  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");
   }
-  const staleBaseScenariosPath = path.join(testDir, "base-scenarios.json");
-  if (await exists(staleBaseScenariosPath)) {
-    await unlink(staleBaseScenariosPath);
+  if (await workspacePathExists(projectRoot, "test/base-scenarios.json")) {
+    await unlinkWorkspaceFile(projectRoot, "test/base-scenarios.json");
   }
   await migrateLegacyScenarioImports(projectRoot);
 }
 async function ensureDreamboardGitignore(projectRoot) {
-  const gitignorePath = path.join(projectRoot, ".gitignore");
-  const existing = await readTextFileIfExists(gitignorePath);
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    ".gitignore"
+  );
   if (existing?.includes(".dreamboard/state.json")) {
     return;
   }
-  await writeTextFile(
-    gitignorePath,
+  await writeWorkspaceTextFile(
+    projectRoot,
+    ".gitignore",
     `${existing ? `${existing.trimEnd()}
 
 ` : ""}${DREAMBOARD_GITIGNORE_BLOCK}`
@@ -181,14 +208,18 @@ async function assertCliStaticScaffoldComplete(projectRoot, deletedPaths = []) {
   const expectedEntries = await getExpectedStaticEntries(projectRoot);
   const missingOrBlankPaths = [];
   for (const entry of expectedEntries) {
-    const fullPath = path.join(projectRoot, entry.targetPath);
-    const content = await readTextFileIfExists(fullPath);
+    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(normalizeProjectPath).filter((filePath) => staticPaths.has(filePath)).sort();
+  const deletedStaticPaths = deletedPaths.map(normalizeOwnedProjectPath).filter(
+    (filePath) => filePath !== null && staticPaths.has(filePath)
+  ).sort();
   if (missingOrBlankPaths.length === 0 && deletedStaticPaths.length === 0) {
     return;
   }
@@ -202,54 +233,54 @@ async function assertCliStaticScaffoldComplete(projectRoot, deletedPaths = []) {
     problems.push(`deleted: ${summarizePaths(deletedStaticPaths)}`);
   }
   throw new Error(
-    `CLI static scaffold is incomplete (${problems.join("; ")}). Run \`${DREAMBOARD_SYNC_COMMAND}\` to refresh the scaffold before compiling.`
+    `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) {
-    const fullPath = path.join(projectRoot, entry.targetPath);
     if (mode === "update" && isDynamicSeedPath(entry.targetPath)) {
-      const existing = await readTextFileIfExists(fullPath);
+      const existing = await readWorkspaceTextFileIfExists(
+        projectRoot,
+        entry.targetPath
+      );
       if (existing !== null && existing.trim().length > 0) {
         continue;
       }
     }
-    await writeTextFile(fullPath, entry.content);
+    await writeWorkspaceTextFile(projectRoot, entry.targetPath, entry.content);
   }
   for (const entry of await getDynamicStaticEntries(
     projectRoot,
     mode,
     options
   )) {
-    await writeTextFile(
-      path.join(projectRoot, entry.targetPath),
-      entry.content
-    );
+    await writeWorkspaceTextFile(projectRoot, entry.targetPath, entry.content);
   }
   if (!options.localMaintainerRegistry) {
-    await rm(path.join(projectRoot, ".npmrc"), { force: true });
+    await removeWorkspacePath(projectRoot, ".npmrc", { force: true });
   }
 }
 async function removeLegacyVendoredSdkPaths(projectRoot) {
-  await rm(path.join(projectRoot, "app", "sdk"), {
+  await removeWorkspacePath(projectRoot, "app/sdk", {
     recursive: true,
     force: true
   });
-  await rm(path.join(projectRoot, "ui", "sdk"), {
+  await removeWorkspacePath(projectRoot, "ui/sdk", {
     recursive: true,
     force: true
   });
 }
 async function removeLegacyDreamboardComponentPath(projectRoot) {
-  const legacyDirPath = path.join(
+  const legacyIndexProjectPath = "ui/components/dreamboard/index.ts";
+  const legacyDirPath = resolveWorkspacePath(
+    projectRoot,
+    "ui/components/dreamboard"
+  );
+  const existing = await readWorkspaceTextFileIfExists(
     projectRoot,
-    "ui",
-    "components",
-    "dreamboard"
+    legacyIndexProjectPath
   );
-  const legacyIndexPath = path.join(legacyDirPath, "index.ts");
-  const existing = await readTextFileIfExists(legacyIndexPath);
   const removableLegacyContents = /* @__PURE__ */ new Set([
     LEGACY_DREAMBOARD_COMPONENT_INDEX_CONTENT.trim(),
     OLD_LEGACY_DREAMBOARD_COMPONENT_INDEX_CONTENT.trim(),
@@ -258,24 +289,26 @@ async function removeLegacyDreamboardComponentPath(projectRoot) {
   if (existing === null || !removableLegacyContents.has(existing.trim())) {
     return;
   }
-  await unlink(legacyIndexPath);
+  await unlinkWorkspaceFile(projectRoot, legacyIndexProjectPath);
   const remainingEntries = await readdir(legacyDirPath).catch(() => []);
   if (remainingEntries.length === 0) {
     await rmdir(legacyDirPath);
   }
 }
-async function writeTestReadme(filePath) {
-  await writeTextFile(
-    filePath,
-    "# 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. Generate deterministic base snapshots: `dreamboard test generate`.\n5. Run tests: `dreamboard test run`.\n\nImport test helpers from `../testing-types`.\n\nGenerated artifacts are written to `test/generated/*` and should not be edited manually.\n"
+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(filePath, mode, players) {
+async function writeInitialBase(projectRoot, mode, players) {
   if (mode === "update") {
     return;
   }
-  await writeTextFile(
-    filePath,
+  await writeWorkspaceTextFile(
+    projectRoot,
+    "test/bases/initial-turn.base.ts",
     `import { defineBase } from "../testing-types";
 
 export default defineBase({
@@ -287,44 +320,69 @@ export default defineBase({
 `
   );
 }
-async function writeInitialScenario(filePath, mode) {
+async function writeInitialScenario(projectRoot, mode) {
   if (mode === "new") {
-    await writeTextFile(filePath, INITIAL_SCENARIO_CONTENT);
+    await writeWorkspaceTextFile(
+      projectRoot,
+      "test/scenarios/smoke-initial-turn.scenario.ts",
+      INITIAL_SCENARIO_CONTENT
+    );
     return;
   }
-  const existing = await readTextFileIfExists(filePath);
-  if (existing === null || existing.trim().length === 0 || existing === INITIAL_SCENARIO_CONTENT) {
-    await writeTextFile(filePath, INITIAL_SCENARIO_CONTENT);
+  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(filePath, mode) {
+async function writeTestingTypes(projectRoot, mode) {
   if (mode === "new") {
-    await writeTextFile(filePath, REDUCER_TESTING_TYPES_WRAPPER_CONTENT);
+    await writeWorkspaceTextFile(
+      projectRoot,
+      "test/testing-types.ts",
+      REDUCER_TESTING_TYPES_WRAPPER_CONTENT
+    );
     return;
   }
-  const existing = await readTextFileIfExists(filePath);
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    "test/testing-types.ts"
+  );
   if (shouldRefreshGeneratedTestingTypes(existing)) {
-    await writeTextFile(filePath, REDUCER_TESTING_TYPES_WRAPPER_CONTENT);
+    await writeWorkspaceTextFile(
+      projectRoot,
+      "test/testing-types.ts",
+      REDUCER_TESTING_TYPES_WRAPPER_CONTENT
+    );
   }
 }
-async function writeGeneratedTestingStubs(generatedDir, mode) {
+async function writeGeneratedTestingStubs(projectRoot, mode) {
   const header = "// Generated by dreamboard scaffold. Do not edit by hand.\n";
   await writeGeneratedTestingStubFile(
-    path.join(generatedDir, "base-states.generated.ts"),
+    projectRoot,
+    "test/generated/base-states.generated.ts",
     `${header}export const BASE_STATES = {} as const;
 export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
 `,
     mode
   );
   await writeGeneratedTestingStubFile(
-    path.join(generatedDir, "base-states.generated.d.ts"),
+    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(
-    path.join(generatedDir, "testing-contract.ts"),
+    projectRoot,
+    "test/generated/testing-contract.ts",
     `${header}export type BaseId = string;
 export type GameView = unknown;
 export type InteractionId = string;
@@ -333,7 +391,6 @@ 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 };
@@ -344,32 +401,37 @@ export interface ScenarioGameApi { start(): Promise<void>; submit<Id extends Int
 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 type ScenarioThenContext<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>; }
+export interface ScenarioDefinition<Phase extends PhaseName | undefined = undefined> { id: string; description?: string; from: BaseId | string; phase?: Phase; stage?: Phase extends PhaseName ? WorkspaceStageName<Phase> : never; when: (ctx: ScenarioContext<Phase>) => void | Promise<void>; then: (ctx: ScenarioThenContext<Phase>) => void | Promise<void>; }
 `,
     mode
   );
   await writeGeneratedTestingStubFile(
-    path.join(generatedDir, "scenario-manifest.generated.ts"),
+    projectRoot,
+    "test/generated/scenario-manifest.generated.ts",
     `${header}export const SCENARIO_MANIFEST = [] as const;
 `,
     mode
   );
 }
-async function writeGeneratedTestingStubFile(filePath, content, mode) {
+async function writeGeneratedTestingStubFile(projectRoot, projectPath, content, mode) {
   if (mode === "new") {
-    await writeTextFile(filePath, content);
+    await writeWorkspaceTextFile(projectRoot, projectPath, content);
     return;
   }
-  const existing = await readTextFileIfExists(filePath);
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    projectPath
+  );
   if (existing === null || existing.trim().length === 0 || existing.startsWith(GENERATED_SCENARIO_PREFIX)) {
-    await writeTextFile(filePath, content);
+    await writeWorkspaceTextFile(projectRoot, projectPath, content);
   }
 }
-async function writeTestTsconfig(filePath) {
-  await writeTextFile(
-    filePath,
+async function writeTestTsconfig(projectRoot) {
+  await writeWorkspaceTextFile(
+    projectRoot,
+    "test/tsconfig.json",
     `${JSON.stringify(
       {
         compilerOptions: {
@@ -394,9 +456,10 @@ async function writeTestTsconfig(filePath) {
 `
   );
 }
-async function writeManifestTypecheckTsconfig(filePath) {
-  await writeTextFile(
-    filePath,
+async function writeManifestTypecheckTsconfig(projectRoot) {
+  await writeWorkspaceTextFile(
+    projectRoot,
+    MANIFEST_TYPECHECK_CONFIG_FILE,
     `${JSON.stringify(
       {
         compilerOptions: {
@@ -418,11 +481,12 @@ async function writeManifestTypecheckTsconfig(filePath) {
   );
 }
 async function migrateLegacyScenarioImports(projectRoot) {
-  const scenariosRoot = path.join(projectRoot, "test", "scenarios");
-  if (!await exists(scenariosRoot)) return;
+  if (!await workspacePathExists(projectRoot, "test/scenarios")) return;
+  const scenariosRoot = resolveWorkspacePath(projectRoot, "test/scenarios");
   const scenarioFiles = await collectScenarioFiles(scenariosRoot);
   for (const filePath of scenarioFiles) {
-    const content = await readTextFile(filePath);
+    const projectPath = toWorkspaceProjectPath(projectRoot, filePath);
+    const content = await readWorkspaceTextFile(projectRoot, projectPath);
     if (!content.includes("@dreamboard/cli/testing")) continue;
     const relativeToTestingTypes = normalizeImportPath(
       path.relative(
@@ -432,7 +496,7 @@ async function migrateLegacyScenarioImports(projectRoot) {
     );
     const migrated = content.replaceAll('"@dreamboard/cli/testing"', `"${relativeToTestingTypes}"`).replaceAll("'@dreamboard/cli/testing'", `'${relativeToTestingTypes}'`);
     if (migrated !== content) {
-      await writeTextFile(filePath, migrated);
+      await writeWorkspaceTextFile(projectRoot, projectPath, migrated);
     }
   }
 }
@@ -446,8 +510,7 @@ function shouldRefreshGeneratedTestingTypes(existingContent) {
   return existingContent.startsWith(GENERATED_TESTING_TYPES_PREFIX);
 }
 async function inferInitialTestPlayerCount(projectRoot) {
-  const manifestPath = path.join(projectRoot, "manifest.ts");
-  if (!await exists(manifestPath)) {
+  if (!await workspacePathExists(projectRoot, "manifest.ts")) {
     return 4;
   }
   try {
@@ -494,9 +557,12 @@ async function getStaticAssetEntries() {
   const files = await walkFiles(STATIC_ASSET_ROOT);
   const entries = [];
   for (const filePath of files) {
-    const targetPath = normalizeProjectPath(
-      path.relative(STATIC_ASSET_ROOT, filePath)
+    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")
@@ -526,24 +592,12 @@ async function getDynamicStaticEntries(projectRoot, mode, options = {}) {
   }
   return entries;
 }
-async function readProjectLocalMaintainerRegistry(projectRoot) {
-  const projectConfigPath = path.join(
-    projectRoot,
-    PROJECT_DIR_NAME,
-    PROJECT_CONFIG_FILE
-  );
-  if (!await exists(projectConfigPath)) {
-    return null;
-  }
-  const projectConfig = await loadProjectConfig(projectRoot);
-  return projectConfig.localMaintainerRegistry ?? null;
-}
 async function getExpectedStaticEntries(projectRoot) {
   const entries = [
-    ...await getStaticAssetEntries(),
-    ...await getDynamicStaticEntries(projectRoot, "update", {
-      localMaintainerRegistry: await readProjectLocalMaintainerRegistry(projectRoot)
-    })
+    ...(await getStaticAssetEntries()).filter(
+      (entry) => entry.targetPath !== ".npmrc"
+    ),
+    ...await getDynamicStaticEntries(projectRoot, "update")
   ];
   entries.sort(
     (left, right) => left.targetPath.localeCompare(right.targetPath)
@@ -574,8 +628,9 @@ async function buildRootPackageJson(projectRoot, mode, options) {
     ...SDK_DEPENDENCY_RANGES,
     ...options.localMaintainerRegistry?.packages ?? {}
   };
-  const packageJsonPath = path.join(projectRoot, "package.json");
-  const existingPackageJson = mode === "update" && await exists(packageJsonPath) ? await readJsonFile(packageJsonPath) : null;
+  const existingPackageJson = mode === "update" && await workspacePathExists(projectRoot, "package.json") ? JSON.parse(
+    await readWorkspaceTextFile(projectRoot, "package.json")
+  ) : null;
   const {
     dreamboardFrameworkVersion: _legacyFrameworkVersion,
     ...existingPackageJsonWithoutLegacyVersion
@@ -586,11 +641,13 @@ async function buildRootPackageJson(projectRoot, mode, options) {
     ...ROOT_APP_DEPENDENCIES
   };
   const frameworkDevDependencies = {
-    ...SHARED_DEV_DEPENDENCIES
+    ...SHARED_DEV_DEPENDENCIES,
+    ...DEV_HOST_DEPENDENCY_RANGES
   };
   const nextPackageJson = {
     ...existingPackageJsonWithoutLegacyVersion,
     private: true,
+    packageManager: AUTHORING_RELEASE_SET.packageManager,
     scripts: {
       ...existingPackageJson?.scripts ?? {},
       ...FRAMEWORK_SCRIPTS
@@ -614,7 +671,8 @@ function mergePnpmConfig(existingPnpm) {
     ...existingPnpm ?? {},
     overrides: {
       ...existingOverrides,
-      ...FRAMEWORK_PNPM_OVERRIDES
+      ...FRAMEWORK_PNPM_OVERRIDES,
+      ...DREAMBOARD_PACKAGE_OVERRIDES
     }
   };
 }
@@ -634,83 +692,18 @@ function buildUiPackageJson() {
   )}
 `;
 }
-function readPackageVersion(packageJsonPath, packageName) {
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  if (typeof packageJson.version !== "string" || packageJson.version.trim().length === 0) {
-    return null;
-  }
-  return `^${packageJson.version.trim()}`;
-}
-function findNearestPackageJsonPath(importMetaUrl = import.meta.url) {
-  let current = path.dirname(fileURLToPath(importMetaUrl));
-  while (true) {
-    const candidate = path.join(current, "package.json");
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function isSourceCheckoutCliPackageJsonPath(packageJsonPath, importMetaUrl = import.meta.url) {
-  try {
-    return path.resolve(packageJsonPath) === path.join(
-      resolveCliRepoRoot(importMetaUrl),
-      "apps",
-      "dreamboard-cli",
-      "package.json"
-    );
-  } catch {
-    return false;
-  }
-}
-function readPackagedSdkDependencyRange(packageName, importMetaUrl = import.meta.url) {
-  const packageJsonPath = findNearestPackageJsonPath(importMetaUrl);
-  if (!packageJsonPath) {
-    return null;
-  }
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  const packagedRange = packageJson.dependencies?.[packageName];
-  if (typeof packagedRange !== "string" || packagedRange.trim().length === 0 || packagedRange.startsWith("workspace:") || packagedRange.startsWith("link:") || packagedRange.startsWith("file:") && !IS_PUBLISHED_BUILD && isSourceCheckoutCliPackageJsonPath(packageJsonPath, importMetaUrl)) {
-    return null;
-  }
-  return packagedRange.trim();
-}
-function stripLocalSnapshotSuffix(range) {
-  return range.replace(/-local\..*$/, "");
-}
-function resolveSdkDependencyRange(packageName, importMetaUrl = import.meta.url) {
-  const packagedRange = readPackagedSdkDependencyRange(
-    packageName,
-    importMetaUrl
-  );
-  if (packagedRange) {
-    return stripLocalSnapshotSuffix(packagedRange);
-  }
-  try {
-    const repoRoot = resolveCliRepoRoot(importMetaUrl);
-    const packageJsonPath = path.join(
-      repoRoot,
-      ...SDK_PACKAGE_PATHS[packageName]
-    );
-    const repoRange = readPackageVersion(packageJsonPath, packageName);
-    if (repoRange) {
-      return stripLocalSnapshotSuffix(repoRange);
-    }
-  } catch {
-  }
-  return DEFAULT_SDK_DEPENDENCY_RANGES[packageName];
-}
 function normalizeImportPath(relativePath) {
   const normalized = relativePath.replaceAll("\\", "/");
   if (normalized.startsWith(".")) return normalized;
   return `./${normalized}`;
 }
-function normalizeProjectPath(filePath) {
-  return filePath.replace(/^\.\//, "").replace(/^\/+/, "").replace(/\\/g, "/");
+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;
@@ -723,7 +716,6 @@ export {
   scaffoldStaticWorkspace,
   assertCliStaticScaffoldComplete,
   migrateLegacyScenarioImports,
-  resolveStaticAssetRoot,
-  resolveSdkDependencyRange
+  resolveStaticAssetRoot
 };
-//# sourceMappingURL=chunk-7WWGFAAU.mjs.map
+//# sourceMappingURL=chunk-NBRUEJUK.mjs.map