@dreamboard-games/cli 0.1.30-alpha.12 → 0.1.30-alpha.13

package/dist/agent-verifier/{chunk-VLOIZDR6.mjs → chunk-JPN62WDY.mjs}

@@ -3,23 +3,22 @@ import {
   REDUCER_TESTING_TYPES_WRAPPER_CONTENT
 } from "./chunk-F2DIOJJZ.mjs";
 import {
-  IS_PUBLISHED_BUILD
-} from "./chunk-KK47X7RV.mjs";
+  ensureDir
+} from "./chunk-RDYXWXXC.mjs";
 import {
   isDynamicSeedPath,
   materializeManifest
-} from "./chunk-6XRC5PWB.mjs";
+} from "./chunk-H3XNWKJU.mjs";
 import {
-  resolveCliRepoRoot
-} from "./chunk-QBAF7EYR.mjs";
-import {
-  ensureDir,
-  exists,
-  readJsonFile,
-  readTextFile,
-  readTextFileIfExists,
-  writeTextFile
-} from "./chunk-IAYRNVUC.mjs";
+  normalizeOwnedProjectPath,
+  readWorkspaceTextFile,
+  readWorkspaceTextFileIfExists,
+  removeWorkspacePath,
+  resolveWorkspacePath,
+  unlinkWorkspaceFile,
+  workspacePathExists,
+  writeWorkspaceTextFile
+} from "./chunk-WAFBU5U7.mjs";
 import {
   FRAMEWORK_PNPM_OVERRIDES,
   FRAMEWORK_REACT_DEPENDENCIES,
@@ -30,10 +29,52 @@ import {
 } 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";
+
+// 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.13"
+    },
+    "sdk": {
+      "name": "@dreamboard-games/sdk",
+      "version": "0.4.0-alpha.1"
+    },
+    "apiClient": {
+      "name": "@dreamboard-games/api-client",
+      "version": "0.3.0-alpha.4"
+    },
+    "devHost": {
+      "name": "@dreamboard-games/dev-host",
+      "version": "0.1.30-alpha.13"
+    }
+  },
+  "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:e342f47ce36c53d58b4049cc68db5a51f94e940ee1ed39fedd723c837e52822b"
+};
+
+// src/services/project/static-scaffold.ts
 var DREAMBOARD_SYNC_COMMAND = "dreamboard sync";
 var DREAMBOARD_GITIGNORE_BLOCK = [
   "# Dreamboard local state",
@@ -91,14 +132,16 @@ export default defineScenario({
 });
 `;
 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",
@@ -125,50 +168,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}`
@@ -178,14 +209,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;
   }
@@ -205,48 +240,48 @@ async function assertCliStaticScaffoldComplete(projectRoot, deletedPaths = []) {
 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(),
@@ -255,24 +290,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,
+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. 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 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({
@@ -284,44 +321,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);
+  const existing = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    "test/scenarios/smoke-initial-turn.scenario.ts"
+  );
   if (existing === null || existing.trim().length === 0 || existing === INITIAL_SCENARIO_CONTENT) {
-    await writeTextFile(filePath, INITIAL_SCENARIO_CONTENT);
+    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;
@@ -348,25 +410,30 @@ export interface ScenarioDefinition<Runners extends readonly TestRunner[] = read
     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: {
@@ -391,9 +458,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: {
@@ -415,11 +483,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(
@@ -429,7 +498,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);
     }
   }
 }
@@ -443,8 +512,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 {
@@ -491,9 +559,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")
@@ -559,8 +630,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
@@ -571,11 +643,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
@@ -599,7 +673,8 @@ function mergePnpmConfig(existingPnpm) {
     ...existingPnpm ?? {},
     overrides: {
       ...existingOverrides,
-      ...FRAMEWORK_PNPM_OVERRIDES
+      ...FRAMEWORK_PNPM_OVERRIDES,
+      ...DREAMBOARD_PACKAGE_OVERRIDES
     }
   };
 }
@@ -619,83 +694,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;
@@ -708,7 +718,6 @@ export {
   scaffoldStaticWorkspace,
   assertCliStaticScaffoldComplete,
   migrateLegacyScenarioImports,
-  resolveStaticAssetRoot,
-  resolveSdkDependencyRange
+  resolveStaticAssetRoot
 };
-//# sourceMappingURL=chunk-VLOIZDR6.mjs.map
+//# sourceMappingURL=chunk-JPN62WDY.mjs.map