@dreamboard-games/cli 0.1.30-alpha.1 → 0.1.30-alpha.10

package/dist/index.js

@@ -13,13 +13,14 @@ import {
   collectLocalFiles,
   computeManifestHash,
   configureClient,
-  createGameRevisionSdk,
+  createGameRevision,
   createPkcePair,
-  createProjectSessionSdk,
+  createProjectSession,
+  createProjectSourceBlobUploadSession,
   createSessionFromScenario,
   didLocalMaintainerSnapshotChange,
-  ensureProjectDevCompileSdk,
-  ensureProjectSdk,
+  ensureProject,
+  ensureProjectDevCompile,
   exchangeClerkOAuthCode,
   external_exports,
   findProjectCompiledResultsForRevision,
@@ -29,36 +30,32 @@ import {
   getApiVersion,
   getAuthTokenExpiry,
   getCliErrorExitCode,
+  getCurrentAuthUser,
   getLocalDiff,
   getProjectAuthoringState,
-  getProjectBySlugSdk,
+  getProjectBySlug,
   getProjectCompileState,
   getProjectCompiledResultSdk,
   getProjectLocalMaintainerRegistry,
   getProjectPendingAuthoringSync,
-  getProjectRevisionSourcesSdk,
-  getProjectSourcesSdk,
+  getProjectRevisionSources,
+  getProjectSources,
   getSessionEventBatch,
   getSessionSnapshot,
   importTypeScriptModule,
   isAllowedGamePath,
-  isAuthoritativeGeneratedPath,
   isDreamboardApiError,
+  isDynamicGeneratedPath,
   isDynamicSeedPath,
   isLibraryPath,
   isLocalMaintainerRegistryEnabled,
-  isPerPlayer,
   isReducerNativeTestingWorkspace,
   isStaleContractArtifactError,
   isStaleContractArtifactMessage,
   loadManifest,
   loadProjectConfig,
-  loadRemoteProjectIdentity,
   loadRule,
-  mapUpsertBlobContentsByContentHash,
   materializeManifest,
-  materializeManifestTable,
-  materializeSourceChangeOperations,
   normalizeSlug,
   parseAuthCommandArgs,
   parseCloneCommandArgs,
@@ -75,7 +72,6 @@ import {
   parseQueryCommandArgs,
   parseStatusCommandArgs,
   parseSyncCommandArgs,
-  perPlayerSchema,
   projectIdFromSessionGameSource,
   queryWorkshopRulebook,
   queueProjectRevisionCompileSdk,
@@ -91,13 +87,13 @@ import {
   setLatestCompileAttempt,
   shortHash,
   submitGameplayAuthorityAction,
+  titleFromSlug,
   toApiProblem,
   toDreamboardApiError,
   updateProjectAuthoringState,
   updateProjectLocalMaintainerRegistry,
   updateProjectState,
-  uploadInitialProjectionSdk,
-  uploadProjectSourceBlobsSdk,
+  uploadInitialProjection,
   valueOrUndefined,
   waitForCompiledResultJobSdk,
   writeManifest,
@@ -105,13 +101,12 @@ import {
   writeSnapshot,
   writeSnapshotFromFiles,
   writeSourceFiles
-} from "./chunk-RS7UXJZV.js";
+} from "./chunk-P5TITCD3.js";
 import {
   DEFAULT_LOGIN_TIMEOUT_MS,
   DEFAULT_WEB_BASE_URL,
   MANIFEST_FILE,
   MANIFEST_TYPECHECK_CONFIG_FILE,
-  PROJECT_CONFIG_FILE,
   PROJECT_DIR_NAME,
   RULE_FILE,
   clearCredentials,
@@ -130,12 +125,11 @@ import {
   setCredentials,
   writeJsonFile,
   writeTextFile
-} from "./chunk-C6UAT6EH.js";
-import "./chunk-7FOO4AJI.js";
+} from "./chunk-GXM7RRZJ.js";
 import "./chunk-2H7UOFLK.js";
 
 // src/commands/auth.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 
 // ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/_chunks/libs/scule.mjs
 var NUMBER_CHAR_RE = /\d/;
@@ -1867,7 +1861,7 @@ function openBrowser(url) {
 
 // src/commands/auth.ts
 async function loginWithBrowser(config, quiet) {
-  const state = crypto.randomUUID();
+  const state = crypto2.randomUUID();
   const pkce = createPkcePair();
   const server = await startOAuthCallbackServer(
     state,
@@ -2207,6 +2201,360 @@ var query_default = defineCommand({
 // src/commands/clone.ts
 import path5 from "path";
 
+// src/services/api/project-api.ts
+async function loadRemoteProjectIdentity() {
+  const [versionResponse, userResponse] = await Promise.all([
+    getApiVersion(),
+    getCurrentAuthUser()
+  ]);
+  if (versionResponse.error || !versionResponse.data) {
+    throw toDreamboardApiError(
+      versionResponse.error,
+      versionResponse.response,
+      "Failed to resolve backend deployment identity"
+    );
+  }
+  if (userResponse.error || !userResponse.data) {
+    throw toDreamboardApiError(
+      userResponse.error,
+      userResponse.response,
+      "Failed to resolve authenticated owner scope"
+    );
+  }
+  const deploymentId = versionResponse.data.deploymentId;
+  const ownerScopeId = userResponse.data.ownerScopeId;
+  return {
+    deploymentId,
+    ownerScopeId,
+    bindingKey: `${deploymentId}:${ownerScopeId}`
+  };
+}
+async function ensureProjectSdk(options) {
+  const { data, error, response } = await ensureProject({
+    path: { projectId: options.projectId },
+    body: {
+      slug: options.slug,
+      name: titleFromSlug(options.slug),
+      description: options.description ?? `Dreamboard workspace for ${options.slug}.`,
+      ...options.updateAlias ? { updateAlias: true } : {}
+    }
+  });
+  if (error || !data) {
+    throw toDreamboardApiError(error, response, "Failed to ensure project");
+  }
+  return data;
+}
+async function getProjectBySlugSdk(slug) {
+  const { data, error, response } = await getProjectBySlug({
+    path: { slug }
+  });
+  if (error || !data) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      `Project '${slug}' not found`
+    );
+  }
+  return data;
+}
+async function createGameRevisionSdk(options) {
+  const { data, error, response } = await createGameRevision({
+    path: { projectId: options.projectId },
+    body: options.request
+  });
+  if (error || !data) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      "Failed to create game revision"
+    );
+  }
+  return data;
+}
+async function getProjectSourcesSdk(projectId) {
+  const { data, error, response } = await getProjectSources({
+    path: { projectId }
+  });
+  if (response?.status === 404) {
+    return null;
+  }
+  if (error || !data) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      "Failed to fetch project sources"
+    );
+  }
+  return data;
+}
+async function getProjectRevisionSourcesSdk(options) {
+  const { data, error, response } = await getProjectRevisionSources({
+    path: {
+      projectId: options.projectId,
+      revisionDigest: options.revisionDigest
+    }
+  });
+  if (error || !data) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      "Failed to fetch project revision sources"
+    );
+  }
+  return data;
+}
+async function ensureProjectDevCompileSdk(options) {
+  const { data, error, response } = await ensureProjectDevCompile({
+    path: { projectId: options.projectId },
+    body: options.request
+  });
+  if (error || !data) {
+    throw toDreamboardApiError(error, response, "Failed to ensure dev compile");
+  }
+  return data;
+}
+async function createProjectSessionSdk(options) {
+  const { data, error, response } = await createProjectSession({
+    path: { projectId: options.projectId },
+    body: options.request
+  });
+  if (error || !data) {
+    throw toDreamboardApiError(error, response, "Failed to create session");
+  }
+  return data;
+}
+
+// src/services/api/preview-api.ts
+async function uploadInitialProjectionSdk(gameId, projectionJson) {
+  const { error, response } = await uploadInitialProjection({
+    path: { gameId },
+    body: { projectionJson }
+  });
+  if (error) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      "Failed to upload initial preview projection"
+    );
+  }
+}
+
+// ../../packages/api-client/dist/source-revisions.js
+var textEncoder = new TextEncoder();
+var SOURCE_BLOB_UPLOAD_SESSION_BATCH_SIZE = 20;
+function bytesToHex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Hex(bytes) {
+  const normalizedBytes = new Uint8Array(bytes.byteLength);
+  normalizedBytes.set(bytes);
+  const digest = await crypto.subtle.digest("SHA-256", normalizedBytes.buffer);
+  return bytesToHex(new Uint8Array(digest));
+}
+function getUtf8ByteSize(content) {
+  return textEncoder.encode(content).byteLength;
+}
+async function computeSourceContentHash(content) {
+  return sha256Hex(textEncoder.encode(content));
+}
+async function describeSourceBlob(content) {
+  return {
+    contentHash: await computeSourceContentHash(content),
+    byteSize: getUtf8ByteSize(content)
+  };
+}
+async function materializeSourceChangeOperations(changes) {
+  const blobsByHash = /* @__PURE__ */ new Map();
+  const materialized = await Promise.all(Array.from(changes, async (change) => {
+    if (change.kind === "delete") {
+      return change;
+    }
+    const blob = await describeSourceBlob(change.content);
+    const existing = blobsByHash.get(blob.contentHash);
+    if (!existing) {
+      blobsByHash.set(blob.contentHash, blob);
+    }
+    return {
+      kind: "upsert",
+      path: change.path,
+      contentHash: blob.contentHash,
+      byteSize: blob.byteSize
+    };
+  }));
+  return {
+    blobs: Array.from(blobsByHash.values()).sort((left, right) => left.contentHash.localeCompare(right.contentHash)),
+    changes: materialized
+  };
+}
+function mapUpsertBlobContentsByContentHash(localChanges, materializedChanges) {
+  const uploadBlobs = /* @__PURE__ */ new Map();
+  const length = Math.min(localChanges.length, materializedChanges.length);
+  for (let index = 0; index < length; index += 1) {
+    const localChange = localChanges[index];
+    const materializedChange = materializedChanges[index];
+    if (localChange?.kind !== "upsert" || materializedChange?.kind !== "upsert") {
+      continue;
+    }
+    uploadBlobs.set(materializedChange.contentHash, {
+      contentHash: materializedChange.contentHash,
+      byteSize: materializedChange.byteSize,
+      content: localChange.content
+    });
+  }
+  return uploadBlobs;
+}
+var SourceBlobUploadError = class extends Error {
+  constructor(status, details) {
+    const suffix = details.trim().length > 0 ? `: ${details.trim()}` : "";
+    super(`Failed to upload source blob (HTTP ${status}${suffix})`);
+    this.name = "SourceBlobUploadError";
+    this.status = status;
+    this.details = details;
+  }
+};
+function isDuplicateDirectUploadError(error) {
+  if (!(error instanceof SourceBlobUploadError)) {
+    return false;
+  }
+  if (error.status === 409) {
+    return true;
+  }
+  const normalizedDetails = error.details.toLowerCase();
+  return normalizedDetails.includes("duplicate") || normalizedDetails.includes("already exists") || normalizedDetails.includes("resource already exists");
+}
+async function uploadSourceBlob(uploadTarget, content) {
+  const response = await fetch(uploadTarget.url, {
+    method: uploadTarget.method,
+    headers: uploadTarget.headers,
+    body: textEncoder.encode(content)
+  });
+  if (response.ok) {
+    return;
+  }
+  const details = await response.text().catch(() => "");
+  throw new SourceBlobUploadError(response.status, details);
+}
+var SourceBlobSessionRequestError = class extends Error {
+  constructor(message, apiError, response) {
+    super(message);
+    this.name = "SourceBlobSessionRequestError";
+    this.apiError = apiError;
+    this.response = response;
+  }
+};
+function assertSourceBlobUploadSession(data, response) {
+  if (!data || typeof data !== "object" || !Array.isArray(data.uploads)) {
+    throw new SourceBlobSessionRequestError("Source blob upload session response did not include an uploads array", data, response);
+  }
+}
+async function confirmSourceBlobAlreadyExists(options) {
+  const { requestUploadSession, blob } = options;
+  const { data, error, response } = await requestUploadSession([
+    {
+      contentHash: blob.contentHash,
+      byteSize: blob.byteSize
+    }
+  ]);
+  if (error || !data) {
+    throw new SourceBlobSessionRequestError("Failed to create source blob upload session", error, response);
+  }
+  assertSourceBlobUploadSession(data, response);
+  return data.uploads[0]?.status === "exists";
+}
+async function uploadSourceBlobs(options) {
+  const { blobs, requestUploadSession } = options;
+  const uniqueBlobs = /* @__PURE__ */ new Map();
+  for (const blob of blobs) {
+    const existing = uniqueBlobs.get(blob.contentHash);
+    if (!existing) {
+      uniqueBlobs.set(blob.contentHash, blob);
+      continue;
+    }
+    if (existing.byteSize !== blob.byteSize) {
+      throw new Error(`Source blob ${blob.contentHash} has conflicting byte sizes.`);
+    }
+  }
+  if (uniqueBlobs.size === 0) {
+    return;
+  }
+  for (const uploadBatch of chunkSourceBlobs(Array.from(uniqueBlobs.values()), SOURCE_BLOB_UPLOAD_SESSION_BATCH_SIZE)) {
+    const { data, error, response } = await requestUploadSession(uploadBatch.map(({ contentHash, byteSize }) => ({
+      contentHash,
+      byteSize
+    })));
+    if (error || !data) {
+      throw new SourceBlobSessionRequestError("Failed to create source blob upload session", error, response);
+    }
+    assertSourceBlobUploadSession(data, response);
+    for (const upload of data.uploads) {
+      if (upload.status !== "upload_required") {
+        continue;
+      }
+      const blob = uniqueBlobs.get(upload.contentHash);
+      if (!blob) {
+        throw new Error(`Upload session referenced unknown source blob ${upload.contentHash}.`);
+      }
+      if (!upload.uploadTarget) {
+        throw new Error(`Upload target missing for source blob ${upload.contentHash}.`);
+      }
+      try {
+        await uploadSourceBlob(upload.uploadTarget, blob.content);
+        if (!await confirmSourceBlobAlreadyExists({ requestUploadSession, blob })) {
+          throw new Error(`Source blob ${blob.contentHash} was uploaded but not registered.`);
+        }
+      } catch (error2) {
+        if (isDuplicateDirectUploadError(error2) && await confirmSourceBlobAlreadyExists({ requestUploadSession, blob })) {
+          continue;
+        }
+        throw error2;
+      }
+    }
+  }
+}
+function chunkSourceBlobs(blobs, batchSize) {
+  const chunks = [];
+  for (let index = 0; index < blobs.length; index += batchSize) {
+    chunks.push(blobs.slice(index, index + batchSize));
+  }
+  return chunks;
+}
+async function uploadProjectSourceBlobs(options) {
+  const { projectId, blobs } = options;
+  return uploadSourceBlobs({
+    blobs,
+    requestUploadSession: (uploadBlobs) => createProjectSourceBlobUploadSession({
+      path: { projectId },
+      body: { blobs: uploadBlobs }
+    })
+  });
+}
+
+// src/services/api/source-revisions-api.ts
+var SOURCE_BLOB_UPLOAD_BATCH_SIZE = 20;
+async function uploadProjectSourceBlobsSdk(projectId, blobs) {
+  try {
+    for (const batch of chunkSourceBlobs2(blobs)) {
+      await uploadProjectSourceBlobs({ projectId, blobs: batch });
+    }
+  } catch (error) {
+    if (error instanceof SourceBlobSessionRequestError) {
+      throw toDreamboardApiError(
+        error.apiError,
+        error.response,
+        error.message
+      );
+    }
+    throw error;
+  }
+}
+function chunkSourceBlobs2(blobs) {
+  const chunks = [];
+  for (let index = 0; index < blobs.length; index += SOURCE_BLOB_UPLOAD_BATCH_SIZE) {
+    chunks.push(blobs.slice(index, index + SOURCE_BLOB_UPLOAD_BATCH_SIZE));
+  }
+  return chunks;
+}
+
 // src/services/project/static-scaffold.ts
 import { existsSync, readFileSync } from "fs";
 import { readdir, readFile, rm, rmdir, unlink } from "fs/promises";
@@ -2715,24 +3063,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)
@@ -2913,7 +3249,7 @@ import { unlink as unlink2 } from "fs/promises";
 import path3 from "path";
 
 // src/services/project/workspace-dependencies.ts
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 import { spawn as spawn2 } from "child_process";
 import "events";
 import { existsSync as existsSync2 } from "fs";
@@ -3173,7 +3509,7 @@ async function readRepoPackageManager() {
   return hasExactPnpmVersion(packageManager) ? packageManager : DEFAULT_PACKAGE_MANAGER;
 }
 function fingerprintContent(parts) {
-  return crypto2.createHash("sha256").update(parts.join("\n---\n")).digest("hex");
+  return crypto3.createHash("sha256").update(parts.join("\n---\n")).digest("hex");
 }
 function resolvePnpmInstallInvocation(installArgs) {
   const corepackPath = path2.join(path2.dirname(process.execPath), "corepack");
@@ -3840,6 +4176,10 @@ async function buildSourceDependencyProfile(options) {
 }
 async function assertCompilerPortableDependencies(options) {
   const packageJson = await readProjectPackageJson(options.projectRoot);
+  const legacyProblems = collectLegacyDreamboardSpecifiers(packageJson);
+  if (legacyProblems.length > 0) {
+    throwLegacyDreamboardPackageError(legacyProblems);
+  }
   const problems = collectUnportableDreamboardSpecifiers(packageJson);
   if (problems.length > 0) {
     const details = problems.map(
@@ -3849,7 +4189,7 @@ async function assertCompilerPortableDependencies(options) {
       [
         "Compiler-bound workspaces must install Dreamboard packages from a registry.",
         `Found unportable Dreamboard dependency specifier(s): ${details}.`,
-        "Run `dreamboard sync` from a workspace that uses registry-pinned @dreamboard/* and dreamboard versions before compiling."
+        "Run `dreamboard sync` from a workspace that uses registry-pinned @dreamboard-games/* and dreamboard versions before compiling."
       ].join(" ")
     );
   }
@@ -3865,6 +4205,11 @@ async function assertCompilerPortableDependencies(options) {
   return profile;
 }
 async function assertReleaseEnvironmentPortableDependencies(options) {
+  const packageJson = await readProjectPackageJson(options.projectRoot);
+  const legacyProblems = collectLegacyDreamboardSpecifiers(packageJson);
+  if (legacyProblems.length > 0) {
+    throwLegacyDreamboardPackageError(legacyProblems);
+  }
   const profile = await buildSourceDependencyProfile(options);
   if (!isReleaseEnvironment(options.environment)) {
     return profile;
@@ -3898,7 +4243,7 @@ function collectDreamboardPackageSpecifiers(packageJson) {
     const dependencies = packageJson[field];
     if (!dependencies) continue;
     for (const [packageName, specifier] of Object.entries(dependencies)) {
-      if (isDreamboardPackage(packageName)) {
+      if (isPortableDreamboardPackage(packageName)) {
         packages[packageName] = specifier;
       }
     }
@@ -3906,7 +4251,7 @@ function collectDreamboardPackageSpecifiers(packageJson) {
   const overrides = packageJson.pnpm?.overrides;
   if (overrides) {
     for (const [packageName, specifier] of Object.entries(overrides)) {
-      if (isDreamboardPackage(packageName) && typeof specifier === "string" && packages[packageName] === void 0) {
+      if (isPortableDreamboardPackage(packageName) && typeof specifier === "string" && packages[packageName] === void 0) {
         packages[packageName] = specifier;
       }
     }
@@ -3919,7 +4264,7 @@ function collectUnportableDreamboardSpecifiers(packageJson) {
     const dependencies = packageJson[field];
     if (!dependencies) continue;
     for (const [packageName, specifier] of Object.entries(dependencies)) {
-      if (isDreamboardPackage(packageName) && UNPORTABLE_SPECIFIER_PATTERN.test(specifier)) {
+      if (isPortableDreamboardPackage(packageName) && UNPORTABLE_SPECIFIER_PATTERN.test(specifier)) {
         problems.push({ location: field, packageName, specifier });
       }
     }
@@ -3927,7 +4272,7 @@ function collectUnportableDreamboardSpecifiers(packageJson) {
   const overrides = packageJson.pnpm?.overrides;
   if (overrides) {
     for (const [packageName, specifier] of Object.entries(overrides)) {
-      if (isDreamboardPackage(packageName) && typeof specifier === "string" && UNPORTABLE_SPECIFIER_PATTERN.test(specifier)) {
+      if (isPortableDreamboardPackage(packageName) && typeof specifier === "string" && UNPORTABLE_SPECIFIER_PATTERN.test(specifier)) {
         problems.push({
           location: "pnpm.overrides",
           packageName,
@@ -3938,8 +4283,42 @@ function collectUnportableDreamboardSpecifiers(packageJson) {
   }
   return problems;
 }
-function isDreamboardPackage(packageName) {
-  return packageName === "dreamboard" || packageName.startsWith("@dreamboard/") || packageName.startsWith("@dreamboard-games/");
+function collectLegacyDreamboardSpecifiers(packageJson) {
+  const problems = [];
+  for (const field of DEPENDENCY_FIELDS) {
+    const dependencies = packageJson[field];
+    if (!dependencies) continue;
+    for (const packageName of Object.keys(dependencies)) {
+      if (isLegacyDreamboardPackage(packageName)) {
+        problems.push({ location: field, packageName });
+      }
+    }
+  }
+  const overrides = packageJson.pnpm?.overrides;
+  if (overrides) {
+    for (const packageName of Object.keys(overrides)) {
+      if (isLegacyDreamboardPackage(packageName)) {
+        problems.push({ location: "pnpm.overrides", packageName });
+      }
+    }
+  }
+  return problems;
+}
+function throwLegacyDreamboardPackageError(problems) {
+  const details = problems.map((problem) => `${problem.location} ${problem.packageName}`).join("; ");
+  throw new Error(
+    [
+      "Legacy @dreamboard/* package dependencies are no longer supported in compiler-bound workspaces.",
+      `Found ${details}.`,
+      "Repin to the public @dreamboard-games/* packages and rerun the command."
+    ].join(" ")
+  );
+}
+function isPortableDreamboardPackage(packageName) {
+  return packageName === "dreamboard" || packageName.startsWith("@dreamboard-games/");
+}
+function isLegacyDreamboardPackage(packageName) {
+  return packageName.startsWith("@dreamboard/");
 }
 function isReleaseEnvironment(environment) {
   return environment === "staging" || environment === "prod";
@@ -5676,6 +6055,9 @@ async function assertReducerContractPreflight(projectRoot) {
 
 // src/services/project/reducer-bundle-preflight.ts
 import path13 from "path";
+import { isPerPlayer, perPlayerSchema } from "@dreamboard-games/sdk/reducer";
+import "@dreamboard-games/sdk/reducer-contract";
+import { materializeManifestTable } from "@dreamboard-games/sdk/codegen";
 globalThis.__DREAMBOARD_AUTHORING_WARNINGS__ = true;
 var REDUCER_BUNDLE_ENTRY_PATH = path13.join("app", "index.ts");
 var PREFLIGHT_RNG_SEED = 1337;
@@ -5921,7 +6303,7 @@ function isSourceRevisionPath(filePath) {
   return filePath !== RULE_FILE && isAllowedGamePath(filePath);
 }
 function shouldAlwaysUpsertSourcePath(filePath) {
-  return filePath === ".npmrc" || isAuthoritativeGeneratedPath(filePath);
+  return filePath === ".npmrc" || isDynamicGeneratedPath(filePath);
 }
 
 // src/commands/dev.ts
@@ -6496,12 +6878,12 @@ async function readWorkspacePackageJson(projectRoot) {
     return {
       dependencies: Object.fromEntries(
         Object.entries(parsed.dependencies ?? {}).filter(
-          ([name]) => name.startsWith("@dreamboard/")
+          ([name]) => isDreamboardPublicPackage(name)
         )
       ),
       devDependencies: Object.fromEntries(
         Object.entries(parsed.devDependencies ?? {}).filter(
-          ([name]) => name.startsWith("@dreamboard/")
+          ([name]) => isDreamboardPublicPackage(name)
         )
       )
     };
@@ -6509,6 +6891,9 @@ async function readWorkspacePackageJson(projectRoot) {
     return null;
   }
 }
+function isDreamboardPublicPackage(packageName) {
+  return packageName === "dreamboard" || packageName.startsWith("@dreamboard-games/");
+}
 function stableJson(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
@@ -7638,7 +8023,7 @@ async function assertKnownPlayerId(sessionId, playerId) {
 }
 
 // src/commands/login.ts
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 var login_default = defineCommand({
   meta: {
     name: "login",
@@ -7664,7 +8049,7 @@ var login_default = defineCommand({
       void 0,
       storedSession
     );
-    const state = crypto3.randomUUID();
+    const state = crypto4.randomUUID();
     const pkce = createPkcePair();
     const server = await startOAuthCallbackServer(
       state,