@dreamboard-games/cli 0.1.30-alpha.4 → 0.1.30-alpha.40

package/dist/chunk-5IYJOVUA.js

@@ -0,0 +1,3902 @@
+#!/usr/bin/env node
+import {
+  CLIENT_PROBLEM_TYPES,
+  REDUCER_TESTING_TYPES_WRAPPER_CONTENT,
+  SERVER_PROBLEM_TYPES,
+  buildReducerTestingContractContent,
+  client,
+  createGameplayCapability,
+  createProjectSessionFromReducerSnapshot,
+  createRepoLocalPackageResolutionPlugin,
+  external_exports,
+  findProjectRoot,
+  getJob,
+  getProjectCompiledResult,
+  getSessionSnapshot,
+  hashContent,
+  listProjectCompiledResults,
+  loadManifest,
+  loadProjectConfig,
+  readWorkspaceTextFileIfExists,
+  resolveCliRepoRoot,
+  resolveWorkspacePath,
+  workspacePathExists,
+  writeWorkspaceJsonFile,
+  writeWorkspaceTextFile,
+  zProblemDetails
+} from "./chunk-USZAPMQ4.js";
+import {
+  getStoredSession,
+  loadGlobalConfig,
+  withCredentialLock
+} from "./chunk-6NYVJYN4.js";
+import {
+  DEFAULT_API_BASE_URL,
+  DEFAULT_WEB_BASE_URL,
+  ENVIRONMENT_CONFIGS,
+  PROJECT_DIR_NAME,
+  ensureDir,
+  exists
+} from "./chunk-EQNBQVIW.js";
+
+// src/build-target.ts
+var injectedBuildChannel = true ? "published" : void 0;
+var injectedPackageVersion = true ? "0.1.30-alpha.40" : void 0;
+var BUILD_CHANNEL = injectedBuildChannel === "published" ? "published" : "development";
+var PACKAGE_VERSION = injectedPackageVersion ?? "0.0.0-development";
+function isAlphaReleaseVersion(version) {
+  return /(?:^|-|\.)alpha(?:$|-|\.)/.test(version);
+}
+var IS_PUBLISHED_BUILD = BUILD_CHANNEL === "published";
+var IS_ALPHA_RELEASE = isAlphaReleaseVersion(PACKAGE_VERSION);
+var CAN_SELECT_ENVIRONMENT = !IS_PUBLISHED_BUILD || IS_ALPHA_RELEASE;
+var PUBLISHED_ENVIRONMENT = "prod";
+
+// src/auth/refresh-error.ts
+function classifyRefreshError(error) {
+  const message = error.message?.toLowerCase() ?? "";
+  if (error.status === 400 || error.status === 401 || message.includes("invalid_grant") || message.includes("refresh token") || message.includes("expired") || message.includes("revoked")) {
+    return { kind: "permanent_invalid", reason: error.message };
+  }
+  if (error.status === 408 || error.status === 429 || typeof error.status === "number" && error.status >= 500 || message.includes("timeout") || message.includes("network") || message.includes("fetch failed")) {
+    return { kind: "transient", reason: error.message };
+  }
+  return { kind: "unknown", reason: error.message };
+}
+
+// src/auth/clerk-oauth.ts
+import crypto from "crypto";
+function createPkcePair() {
+  const verifier = base64Url(crypto.randomBytes(32));
+  const challenge = base64Url(
+    crypto.createHash("sha256").update(verifier).digest()
+  );
+  return { verifier, challenge };
+}
+function buildClerkAuthorizationUrl(input) {
+  const { issuer, clientId, scope } = assertConfigured(input.config);
+  const url = new URL("/oauth/authorize", issuer);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", clientId);
+  url.searchParams.set("redirect_uri", input.redirectUri);
+  url.searchParams.set("state", input.state);
+  url.searchParams.set("code_challenge", input.codeChallenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("scope", scope ?? "openid profile email offline_access");
+  return url;
+}
+async function exchangeClerkOAuthCode(input) {
+  const { clientId, tokenUrl } = assertConfigured(input.config);
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: clientId,
+    code: input.code,
+    redirect_uri: input.redirectUri,
+    code_verifier: input.codeVerifier
+  });
+  return requestClerkToken(tokenUrl, body);
+}
+async function refreshClerkOAuthToken(input) {
+  const { clientId, tokenUrl } = assertConfigured(input.config);
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: clientId,
+    refresh_token: input.refreshToken
+  });
+  return requestClerkToken(tokenUrl, body);
+}
+function assertConfigured(config) {
+  const issuer = config.issuer?.trim().replace(/\/$/, "");
+  const clientId = config.clientId?.trim();
+  if (!issuer || !clientId) {
+    throw new Error(
+      [
+        "Clerk OAuth CLI is not configured for this environment.",
+        "The CLI expects first-party environments to be configured in its built-in registry.",
+        "If this environment has no registered public Clerk OAuth client, create one and release a CLI with its client id.",
+        "For emergency overrides, set the environment-specific DREAMBOARD_<ENV>_CLERK_OAUTH_* variables or DREAMBOARD_CLERK_OAUTH_*.",
+        "For local harness auth, use `pnpm auth:local` or the auto-bootstrapped local harness flows instead."
+      ].join(" ")
+    );
+  }
+  return {
+    issuer,
+    clientId,
+    tokenUrl: config.tokenUrl?.trim() || new URL("/oauth/token", issuer).toString(),
+    scope: config.scope?.trim() || void 0
+  };
+}
+async function requestClerkToken(tokenUrl, body) {
+  const response = await fetch(tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body
+  });
+  if (!response.ok) {
+    const detail = await response.text();
+    throw new Error(
+      `Clerk OAuth token request failed (${response.status}): ${detail}`
+    );
+  }
+  const payload = await response.json();
+  if (typeof payload.access_token !== "string") {
+    throw new Error("Clerk OAuth token response did not include access_token.");
+  }
+  if (typeof payload.refresh_token !== "string") {
+    throw new Error(
+      "Clerk OAuth token response did not include refresh_token."
+    );
+  }
+  const expiresAt = typeof payload.expires_in === "number" ? new Date(Date.now() + payload.expires_in * 1e3).toISOString() : void 0;
+  return {
+    accessToken: payload.access_token,
+    refreshToken: payload.refresh_token,
+    expiresAt,
+    tokenUrl
+  };
+}
+function base64Url(bytes) {
+  return bytes.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+
+// src/auth/token-exchange.ts
+async function exchangeDreamboardUserToken(input) {
+  const fetchImpl = input.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  const response = await fetchImpl(
+    new URL("/api/auth/token-exchange", input.apiBaseUrl),
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${input.clerkAccessToken}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({ audience: input.audience })
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Dreamboard token exchange failed (${response.status}). Run \`dreamboard auth login\` to authenticate again.`
+    );
+  }
+  const payload = await response.json();
+  if (typeof payload.accessToken !== "string" || payload.accessToken === "") {
+    throw new Error("Dreamboard token exchange response omitted accessToken.");
+  }
+  if (payload.tokenType !== "Bearer") {
+    throw new Error(
+      "Dreamboard token exchange response had invalid tokenType."
+    );
+  }
+  if (payload.audience !== input.audience) {
+    throw new Error("Dreamboard token exchange response had wrong audience.");
+  }
+  const expiresIn = typeof payload.expiresIn === "number" && Number.isFinite(payload.expiresIn) ? payload.expiresIn : void 0;
+  return {
+    accessToken: payload.accessToken,
+    tokenType: "Bearer",
+    audience: input.audience,
+    expiresIn,
+    expiresAt: expiresIn === void 0 ? void 0 : new Date(Date.now() + expiresIn * 1e3).toISOString()
+  };
+}
+
+// src/auth/user-session-manager.ts
+var DEFAULT_TOKEN_MIN_VALIDITY_MS = 60 * 1e3;
+function createUserSessionManager(config) {
+  return {
+    async establishRefreshableSession(session) {
+      return withCredentialLock(async (ops) => {
+        const credentials = credentialsFromRefreshableSession(session);
+        await ops.writeFull(credentials);
+        const exchanged = await exchangeDreamboardUserToken({
+          apiBaseUrl: config.apiBaseUrl,
+          clerkAccessToken: credentials.accessToken,
+          audience: "dreamboard-api"
+        });
+        const apiToken = toAccessToken(exchanged);
+        await ops.writeFull(withApiToken(credentials, apiToken));
+        return apiToken;
+      });
+    },
+    async establishAccessOnlySession(accessToken) {
+      await withCredentialLock((ops) => ops.writeAccessOnly(accessToken));
+    },
+    async resolveApiToken(options) {
+      const localOrInjected = resolveNonStoredToken(config, "dreamboard-api");
+      if (localOrInjected) return localOrInjected;
+      if (!usesStoredSession(config)) return null;
+      const minValidityMs = options?.minValiditySeconds === void 0 ? DEFAULT_TOKEN_MIN_VALIDITY_MS : Math.max(0, options.minValiditySeconds * 1e3);
+      return withCredentialLock(async (ops) => {
+        const stored = await ops.read();
+        return resolveStoredApiToken(ops, config, stored, minValidityMs);
+      });
+    },
+    async resolveGitToken() {
+      const localOrInjected = resolveNonStoredToken(config, "dreamboard-git");
+      if (localOrInjected) return localOrInjected;
+      if (!usesStoredSession(config)) {
+        throw missingSessionError();
+      }
+      return withCredentialLock(async (ops) => {
+        const stored = await ops.read();
+        const clerk = await resolveFreshClerkSession(ops, config, stored);
+        return toAccessToken(
+          await exchangeDreamboardUserToken({
+            apiBaseUrl: config.apiBaseUrl,
+            clerkAccessToken: clerk.accessToken,
+            audience: "dreamboard-git"
+          })
+        );
+      });
+    },
+    async inspectSession() {
+      const localOrInjected = resolveNonStoredToken(config, "dreamboard-api");
+      if (localOrInjected) {
+        return inspectAccessOnlyToken(localOrInjected);
+      }
+      if (!usesStoredSession(config)) {
+        return { kind: "none" };
+      }
+      return withCredentialLock(async (ops) => {
+        const stored = await ops.read();
+        if (!stored) return { kind: "none" };
+        const cached = freshStoredApiToken(
+          stored,
+          DEFAULT_TOKEN_MIN_VALIDITY_MS
+        );
+        if (cached) {
+          return activeStatus("refreshable", cached, false);
+        }
+        try {
+          const token = await resolveStoredApiToken(
+            ops,
+            config,
+            stored,
+            DEFAULT_TOKEN_MIN_VALIDITY_MS
+          );
+          return activeStatus("refreshable", token, true);
+        } catch (error) {
+          return failedRefreshableStatus(error);
+        }
+      });
+    },
+    async logout() {
+      await withCredentialLock((ops) => ops.clear("logout_command"));
+    }
+  };
+}
+async function resolveStoredApiToken(ops, config, stored, minValidityMs) {
+  const cached = freshStoredApiToken(stored, minValidityMs);
+  if (cached) return cached;
+  const clerk = await resolveFreshClerkSession(ops, config, stored);
+  const exchanged = await exchangeDreamboardUserToken({
+    apiBaseUrl: config.apiBaseUrl,
+    clerkAccessToken: clerk.accessToken,
+    audience: "dreamboard-api"
+  });
+  const apiToken = toAccessToken(exchanged);
+  await ops.writeFull(withApiToken(clerk, apiToken));
+  return apiToken;
+}
+async function resolveFreshClerkSession(ops, config, stored) {
+  if (!stored) {
+    throw missingSessionError();
+  }
+  if (!stored.refreshToken) {
+    throw new Error(
+      "Stored Dreamboard session is missing its refresh token. Run `dreamboard auth login` to authenticate again."
+    );
+  }
+  if (stored.accessToken && isFresh(
+    stored.tokenExpiresAt,
+    stored.accessToken,
+    DEFAULT_TOKEN_MIN_VALIDITY_MS
+  )) {
+    return credentialsFromStored(config, stored);
+  }
+  const payload = await refreshClerkOAuthToken({
+    config: {
+      issuer: stored.clerkOAuthIssuer ?? config.clerkOAuthIssuer,
+      clientId: stored.clerkOAuthClientId ?? config.clerkOAuthClientId,
+      tokenUrl: stored.clerkOAuthTokenUrl ?? config.clerkOAuthTokenUrl
+    },
+    refreshToken: stored.refreshToken
+  });
+  const refreshed = {
+    accessToken: payload.accessToken,
+    refreshToken: payload.refreshToken,
+    tokenExpiresAt: payload.expiresAt,
+    dreamboardApiToken: stored.dreamboardApiToken,
+    dreamboardApiExpiresAt: stored.dreamboardApiExpiresAt,
+    clerkOAuthIssuer: stored.clerkOAuthIssuer ?? config.clerkOAuthIssuer,
+    clerkOAuthClientId: stored.clerkOAuthClientId ?? config.clerkOAuthClientId,
+    clerkOAuthTokenUrl: payload.tokenUrl,
+    environment: stored.environment ?? config.environment
+  };
+  await ops.writeFull(refreshed);
+  return refreshed;
+}
+function credentialsFromStored(config, stored) {
+  if (!stored.accessToken || !stored.refreshToken) {
+    throw missingSessionError();
+  }
+  return {
+    accessToken: stored.accessToken,
+    refreshToken: stored.refreshToken,
+    tokenExpiresAt: stored.tokenExpiresAt,
+    dreamboardApiToken: stored.dreamboardApiToken,
+    dreamboardApiExpiresAt: stored.dreamboardApiExpiresAt,
+    clerkOAuthIssuer: stored.clerkOAuthIssuer ?? config.clerkOAuthIssuer,
+    clerkOAuthClientId: stored.clerkOAuthClientId ?? config.clerkOAuthClientId,
+    clerkOAuthTokenUrl: stored.clerkOAuthTokenUrl ?? config.clerkOAuthTokenUrl,
+    environment: stored.environment ?? config.environment
+  };
+}
+function credentialsFromRefreshableSession(session) {
+  return {
+    accessToken: session.clerkAccessToken,
+    refreshToken: session.refreshToken,
+    tokenExpiresAt: session.clerkAccessExpiresAt,
+    clerkOAuthIssuer: session.clerkOAuthIssuer,
+    clerkOAuthClientId: session.clerkOAuthClientId,
+    clerkOAuthTokenUrl: session.clerkOAuthTokenUrl,
+    environment: session.environment
+  };
+}
+function withApiToken(credentials, token) {
+  return {
+    ...credentials,
+    dreamboardApiToken: token.token,
+    dreamboardApiExpiresAt: token.expiresAt
+  };
+}
+function toAccessToken(token) {
+  return {
+    token: token.accessToken,
+    expiresAt: token.expiresAt,
+    audience: token.audience
+  };
+}
+function resolveNonStoredToken(config, audience) {
+  if (usesStoredSession(config)) return null;
+  if (!config.authToken) return null;
+  return {
+    token: config.authToken,
+    expiresAt: config.tokenExpiresAt,
+    audience
+  };
+}
+function freshStoredApiToken(stored, minValidityMs) {
+  if (!stored?.dreamboardApiToken) return null;
+  if (isFresh(
+    stored.dreamboardApiExpiresAt,
+    stored.dreamboardApiToken,
+    minValidityMs
+  )) {
+    return {
+      token: stored.dreamboardApiToken,
+      expiresAt: stored.dreamboardApiExpiresAt,
+      audience: "dreamboard-api"
+    };
+  }
+  return null;
+}
+function inspectAccessOnlyToken(token) {
+  const expiry = resolveExpiry(token.expiresAt, token.token);
+  if (expiry && expiry.getTime() <= Date.now()) {
+    return {
+      kind: "invalid",
+      sessionKind: "access-only",
+      message: "Stored Dreamboard access token is expired. Run `dreamboard auth login` to authenticate again."
+    };
+  }
+  return activeStatus("access-only", token, false);
+}
+function failedRefreshableStatus(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const errorStatus = typeof error === "object" && error !== null && "status" in error ? error.status : void 0;
+  const classification = classifyRefreshError({
+    message,
+    status: typeof errorStatus === "number" ? errorStatus : void 0
+  });
+  if (classification.kind === "permanent_invalid") {
+    return {
+      kind: "invalid",
+      sessionKind: "refreshable",
+      message
+    };
+  }
+  return {
+    kind: "degraded",
+    sessionKind: "refreshable",
+    message
+  };
+}
+function activeStatus(sessionKind, apiToken, repaired) {
+  return {
+    kind: "active",
+    sessionKind,
+    apiToken,
+    repaired
+  };
+}
+function missingSessionError() {
+  return new Error(
+    "Missing Dreamboard session. Run `dreamboard auth login` to authenticate."
+  );
+}
+function isFresh(expiresAt, token, minValidityMs) {
+  const expiry = resolveExpiry(expiresAt, token);
+  return expiry !== null && Number.isFinite(expiry.getTime()) && expiry.getTime() > Date.now() + minValidityMs;
+}
+function resolveExpiry(expiresAt, token) {
+  if (expiresAt) {
+    const parsed = new Date(expiresAt);
+    return Number.isFinite(parsed.getTime()) ? parsed : null;
+  }
+  return getJwtExpiry(token);
+}
+function getJwtExpiry(accessToken) {
+  if (!accessToken) return null;
+  const parts = accessToken.split(".");
+  if (parts.length !== 3) return null;
+  try {
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf8")
+    );
+    if (typeof payload.exp !== "number" || !Number.isFinite(payload.exp)) {
+      return null;
+    }
+    return new Date(payload.exp * 1e3);
+  } catch {
+    return null;
+  }
+}
+function usesStoredSession(config) {
+  return config.refreshTokenSource === "global";
+}
+
+// src/config/local-harness-auth.ts
+import { createHmac, randomUUID } from "crypto";
+var DEFAULT_SUBJECT = "harness-smoke-local@dreamboard.local";
+var DEFAULT_ISSUER = "dreamboard-local-harness";
+var DEFAULT_SECRET = "dreamboard-local-harness-token-secret";
+var LOCAL_AWS_ISSUER = "dreamboard-local-aws-harness";
+var LOCAL_AWS_SECRET = "dreamboard-local-aws-harness-token-secret";
+var DEFAULT_TTL_SECONDS = 8 * 60 * 60;
+var mintedTokens = /* @__PURE__ */ new Map();
+function resolveLocalHarnessAccessToken(config) {
+  if (IS_PUBLISHED_BUILD || config.environment !== "local") {
+    return void 0;
+  }
+  const profile = inferLocalHarnessProfile(config);
+  if (config.authToken && (profile !== "local-aws" || isExplicitTokenSource(config.authTokenSource))) {
+    return void 0;
+  }
+  const cacheKey = [
+    profile,
+    process.env.LOCAL_HARNESS_TOKEN_ISSUER ?? "",
+    process.env.LOCAL_HARNESS_TOKEN_SECRET ?? "",
+    process.env.LOCAL_HARNESS_SUBJECT ?? "",
+    process.env.HARNESS_USER_EMAIL ?? "",
+    process.env.LOCAL_HARNESS_EMAIL ?? "",
+    process.env.LOCAL_HARNESS_TOKEN_TTL_SECONDS ?? ""
+  ].join("\0");
+  const cached = mintedTokens.get(cacheKey);
+  if (cached) return cached;
+  const token = mintLocalHarnessToken(profile);
+  mintedTokens.set(cacheKey, token);
+  return token;
+}
+function isExplicitTokenSource(source) {
+  return source === "flag" || source === "env" || source === "agent-env";
+}
+function inferLocalHarnessProfile(config) {
+  return isLocalAwsUrl(config.apiBaseUrl) || isLocalAwsUrl(config.webBaseUrl) ? "local-aws" : "local";
+}
+function mintLocalHarnessToken(profile) {
+  const subject = envValue(process.env.LOCAL_HARNESS_SUBJECT) ?? envValue(process.env.HARNESS_USER_EMAIL) ?? DEFAULT_SUBJECT;
+  const email = envValue(process.env.LOCAL_HARNESS_EMAIL) ?? (subject.includes("@") ? subject : void 0);
+  const issuer = envValue(process.env.LOCAL_HARNESS_TOKEN_ISSUER) ?? (profile === "local-aws" ? LOCAL_AWS_ISSUER : DEFAULT_ISSUER);
+  const secret = envValue(process.env.LOCAL_HARNESS_TOKEN_SECRET) ?? (profile === "local-aws" ? LOCAL_AWS_SECRET : DEFAULT_SECRET);
+  const ttlSeconds = Number(
+    envValue(process.env.LOCAL_HARNESS_TOKEN_TTL_SECONDS) ?? String(DEFAULT_TTL_SECONDS)
+  );
+  if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) {
+    throw new Error(
+      "LOCAL_HARNESS_TOKEN_TTL_SECONDS must be a positive number."
+    );
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  const payload = {
+    typ: "local_harness_access",
+    dreamboard_provider: "local-harness",
+    dreamboard_provider_subject: subject,
+    ...email ? { email } : {},
+    iss: issuer,
+    sub: subject,
+    iat: now,
+    exp: now + Math.floor(ttlSeconds),
+    jti: randomUUID()
+  };
+  const headerPart = base64UrlJson({ alg: "HS256", typ: "JWT" });
+  const payloadPart = base64UrlJson(payload);
+  const signature = createHmac("sha256", secret).update(`${headerPart}.${payloadPart}`).digest("base64url");
+  return `${headerPart}.${payloadPart}.${signature}`;
+}
+function base64UrlJson(value) {
+  return Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+}
+function envValue(raw) {
+  return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : void 0;
+}
+function isLocalAwsUrl(rawUrl) {
+  if (!rawUrl) return false;
+  try {
+    const url = new URL(rawUrl);
+    return (url.hostname === "localhost" || url.hostname === "127.0.0.1") && (url.port === "18080" || url.port === "8088");
+  } catch {
+    return false;
+  }
+}
+
+// src/config/resolve.ts
+var TRANSIENT_READ_RETRY_DELAYS_MS = [100, 300];
+function resolveConfig(globalConfig, flags, project, credentials) {
+  if (IS_PUBLISHED_BUILD) {
+    assertPublicRuntimeFlags(flags);
+  }
+  const envEnvironment = CAN_SELECT_ENVIRONMENT ? environmentFromProcess() : void 0;
+  const projectEnvironment = CAN_SELECT_ENVIRONMENT ? project?.environment : void 0;
+  const environment = CAN_SELECT_ENVIRONMENT ? flags.env || envEnvironment || projectEnvironment || globalConfig.environment || (IS_PUBLISHED_BUILD ? PUBLISHED_ENVIRONMENT : "staging") : PUBLISHED_ENVIRONMENT;
+  const envConfig = ENVIRONMENT_CONFIGS[environment];
+  const publishedEnvConfig = ENVIRONMENT_CONFIGS[PUBLISHED_ENVIRONMENT];
+  const hasExplicitEnvironmentOverride = CAN_SELECT_ENVIRONMENT && Boolean(flags.env || envEnvironment || projectEnvironment);
+  const resolvedApiBaseUrl = IS_PUBLISHED_BUILD && !CAN_SELECT_ENVIRONMENT ? publishedEnvConfig?.apiBaseUrl ?? DEFAULT_API_BASE_URL : hasExplicitEnvironmentOverride ? projectLocalBaseUrl(project?.apiBaseUrl, environment) || envConfig?.apiBaseUrl || DEFAULT_API_BASE_URL : project?.apiBaseUrl || envConfig?.apiBaseUrl || DEFAULT_API_BASE_URL;
+  const apiBaseUrl = valueOrUndefined(process.env.DREAMBOARD_API_BASE_URL) ?? resolvedApiBaseUrl;
+  const resolvedWebBaseUrl = IS_PUBLISHED_BUILD && !CAN_SELECT_ENVIRONMENT ? publishedEnvConfig?.webBaseUrl ?? DEFAULT_WEB_BASE_URL : hasExplicitEnvironmentOverride ? projectLocalBaseUrl(project?.webBaseUrl, environment) || envConfig?.webBaseUrl || DEFAULT_WEB_BASE_URL : project?.webBaseUrl || envConfig?.webBaseUrl || DEFAULT_WEB_BASE_URL;
+  const webBaseUrl = valueOrUndefined(process.env.DREAMBOARD_WEB_BASE_URL) ?? resolvedWebBaseUrl;
+  const snapshot = buildCredentialSnapshot(flags, credentials, environment);
+  const oauthConfig = resolveEnvironmentOAuthConfig(environment, envConfig);
+  return {
+    environment,
+    apiBaseUrl,
+    webBaseUrl,
+    authToken: snapshot.dreamboardApiToken ?? (snapshot.refreshToken ? void 0 : snapshot.accessToken),
+    refreshToken: snapshot.refreshToken,
+    tokenExpiresAt: snapshot.dreamboardApiExpiresAt ?? (snapshot.refreshToken ? void 0 : snapshot.tokenExpiresAt),
+    clerkAccessToken: snapshot.accessToken,
+    clerkAccessExpiresAt: snapshot.tokenExpiresAt,
+    dreamboardApiToken: snapshot.dreamboardApiToken,
+    dreamboardApiExpiresAt: snapshot.dreamboardApiExpiresAt,
+    clerkOAuthIssuer: snapshot.clerkOAuthIssuer ?? oauthConfig.issuer,
+    clerkOAuthClientId: snapshot.clerkOAuthClientId ?? oauthConfig.clientId,
+    clerkOAuthTokenUrl: snapshot.clerkOAuthTokenUrl ?? oauthConfig.tokenUrl,
+    clerkOAuthScope: oauthConfig.scope,
+    authTokenSource: snapshot.authTokenSource,
+    refreshTokenSource: snapshot.refreshTokenSource
+  };
+}
+function resolveEnvironmentOAuthConfig(environment, envConfig) {
+  const prefix = environment.toUpperCase();
+  return {
+    issuer: valueOrUndefined(
+      process.env[`DREAMBOARD_${prefix}_CLERK_OAUTH_ISSUER`]
+    ) ?? valueOrUndefined(process.env.DREAMBOARD_CLERK_OAUTH_ISSUER) ?? envConfig?.clerkOAuthIssuer,
+    clientId: valueOrUndefined(
+      process.env[`DREAMBOARD_${prefix}_CLERK_OAUTH_CLIENT_ID`]
+    ) ?? valueOrUndefined(process.env.DREAMBOARD_CLERK_OAUTH_CLIENT_ID) ?? envConfig?.clerkOAuthClientId,
+    tokenUrl: valueOrUndefined(
+      process.env[`DREAMBOARD_${prefix}_CLERK_OAUTH_TOKEN_URL`]
+    ) ?? valueOrUndefined(process.env.DREAMBOARD_CLERK_OAUTH_TOKEN_URL) ?? envConfig?.clerkOAuthTokenUrl,
+    scope: valueOrUndefined(process.env[`DREAMBOARD_${prefix}_CLERK_OAUTH_SCOPE`]) ?? valueOrUndefined(process.env.DREAMBOARD_CLERK_OAUTH_SCOPE) ?? envConfig?.clerkOAuthScope
+  };
+}
+function buildCredentialSnapshot(flags, storedCredentials, environment) {
+  const flagToken = valueOrUndefined(flags.token);
+  const agentEnvToken = valueOrUndefined(process.env.DREAMBOARD_AGENT_TOKEN);
+  const envToken = valueOrUndefined(process.env.DREAMBOARD_TOKEN);
+  const environmentScopedStoredCredentials = storedCredentials?.environment && environment && storedCredentials.environment !== environment ? null : storedCredentials ?? null;
+  if (IS_PUBLISHED_BUILD) {
+    const stored = environmentScopedStoredCredentials;
+    if (agentEnvToken) {
+      return {
+        accessToken: agentEnvToken,
+        refreshToken: void 0,
+        tokenExpiresAt: void 0,
+        authTokenSource: "agent-env",
+        refreshTokenSource: "none"
+      };
+    }
+    return {
+      accessToken: stored?.accessToken,
+      refreshToken: stored?.refreshToken,
+      tokenExpiresAt: stored?.tokenExpiresAt,
+      dreamboardApiToken: stored?.dreamboardApiToken,
+      dreamboardApiExpiresAt: stored?.dreamboardApiExpiresAt,
+      clerkOAuthIssuer: stored?.clerkOAuthIssuer,
+      clerkOAuthClientId: stored?.clerkOAuthClientId,
+      clerkOAuthTokenUrl: stored?.clerkOAuthTokenUrl,
+      environment: stored?.environment,
+      authTokenSource: stored?.dreamboardApiToken || stored?.accessToken && !stored.refreshToken ? "global" : "none",
+      refreshTokenSource: stored?.refreshToken ? "global" : "none"
+    };
+  }
+  const accessToken = flagToken || agentEnvToken || envToken || environmentScopedStoredCredentials?.accessToken;
+  const refreshToken = environmentScopedStoredCredentials?.refreshToken;
+  const authTokenSource = flagToken ? "flag" : agentEnvToken ? "agent-env" : envToken ? "env" : environmentScopedStoredCredentials?.accessToken ? "global" : "none";
+  const refreshTokenSource = environmentScopedStoredCredentials?.refreshToken ? "global" : "none";
+  return {
+    accessToken,
+    refreshToken,
+    tokenExpiresAt: environmentScopedStoredCredentials?.tokenExpiresAt,
+    dreamboardApiToken: environmentScopedStoredCredentials?.dreamboardApiToken,
+    dreamboardApiExpiresAt: environmentScopedStoredCredentials?.dreamboardApiExpiresAt,
+    clerkOAuthIssuer: environmentScopedStoredCredentials?.clerkOAuthIssuer,
+    clerkOAuthClientId: environmentScopedStoredCredentials?.clerkOAuthClientId,
+    clerkOAuthTokenUrl: environmentScopedStoredCredentials?.clerkOAuthTokenUrl,
+    environment: environmentScopedStoredCredentials?.environment,
+    authTokenSource,
+    refreshTokenSource
+  };
+}
+function environmentFromProcess() {
+  const value = valueOrUndefined(process.env.DREAMBOARD_ENV);
+  if (!value) return void 0;
+  if (value === "local" || value === "staging" || value === "prod") {
+    return value;
+  }
+  throw new Error(
+    `Invalid DREAMBOARD_ENV '${value}'. Valid options: local, staging, prod`
+  );
+}
+function projectLocalBaseUrl(rawUrl, environment) {
+  if (environment !== "local" || !rawUrl) return void 0;
+  try {
+    const url = new URL(rawUrl);
+    return url.hostname === "localhost" || url.hostname === "127.0.0.1" ? rawUrl : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function assertPublicRuntimeFlags(flags, options = {}) {
+  const canSelectEnvironment = options.canSelectEnvironment ?? CAN_SELECT_ENVIRONMENT;
+  const argv = options.argv ?? process.argv.slice(2);
+  if (!canSelectEnvironment && (flags.env || argv.includes("--env"))) {
+    throw new Error(
+      "The published Dreamboard CLI is production-only and does not accept `--env`."
+    );
+  }
+  if (valueOrUndefined(flags.token) || argv.includes("--token")) {
+    throw new Error(
+      "Direct JWT injection is not supported in the published Dreamboard CLI. Use `dreamboard auth login` so the CLI can store and refresh your session."
+    );
+  }
+  if (process.env.DREAMBOARD_TOKEN) {
+    throw new Error(
+      "The published Dreamboard CLI ignores direct token environment variables. Use `dreamboard auth login` so the CLI can manage refreshable credentials."
+    );
+  }
+}
+async function configureClient(config) {
+  const localHarnessToken = resolveLocalHarnessAccessToken(config);
+  const resolvedToken = localHarnessToken ? { token: localHarnessToken } : await createUserSessionManager(config).resolveApiToken();
+  const effectiveAccessToken = resolvedToken?.token;
+  client.setConfig({
+    baseUrl: config.apiBaseUrl,
+    fetch: createRetryingReadFetch(globalThis.fetch.bind(globalThis)),
+    headers: effectiveAccessToken ? { Authorization: `Bearer ${effectiveAccessToken}` } : {}
+  });
+}
+function createRetryingReadFetch(fetchImpl) {
+  return (async (input, init) => {
+    const method = resolveFetchMethod(input, init);
+    if (method !== "GET" && method !== "HEAD") {
+      return fetchWithOptionalTrace(fetchImpl, input, init, {
+        attempt: 0,
+        willRetry: false
+      });
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= TRANSIENT_READ_RETRY_DELAYS_MS.length; attempt += 1) {
+      try {
+        return await fetchWithOptionalTrace(fetchImpl, input, init, {
+          attempt,
+          willRetry: attempt < TRANSIENT_READ_RETRY_DELAYS_MS.length
+        });
+      } catch (error) {
+        lastError = error;
+        if (attempt >= TRANSIENT_READ_RETRY_DELAYS_MS.length || !isTransientFetchError(error)) {
+          throw error;
+        }
+        await sleep(TRANSIENT_READ_RETRY_DELAYS_MS[attempt]);
+      }
+    }
+    throw lastError;
+  });
+}
+async function fetchWithOptionalTrace(fetchImpl, input, init, options) {
+  if (!isHttpTraceEnabled()) {
+    return fetchImpl(input, init);
+  }
+  const request = describeRequest(input, init);
+  const startedAt = Date.now();
+  try {
+    const response = await fetchImpl(input, init);
+    writeHttpTrace({
+      ...request,
+      attempt: options.attempt,
+      status: response.status,
+      durationMs: Date.now() - startedAt
+    });
+    return response;
+  } catch (error) {
+    writeHttpTrace({
+      ...request,
+      attempt: options.attempt,
+      durationMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.name : "UnknownError",
+      willRetry: options.willRetry
+    });
+    throw error;
+  }
+}
+function isHttpTraceEnabled() {
+  return process.env.DREAMBOARD_CLI_HTTP_TRACE === "1";
+}
+function describeRequest(input, init) {
+  return {
+    method: resolveFetchMethod(input, init),
+    url: redactUrl(input),
+    hasAuthorization: hasAuthorizationHeader(input, init)
+  };
+}
+function redactUrl(input) {
+  const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+  try {
+    const url = new URL(rawUrl);
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return "<unparseable-url>";
+  }
+}
+function hasAuthorizationHeader(input, init) {
+  return headersContainAuthorization(init?.headers) || typeof Request !== "undefined" && input instanceof Request && input.headers.has("Authorization");
+}
+function headersContainAuthorization(headers) {
+  if (!headers) {
+    return false;
+  }
+  if (headers instanceof Headers) {
+    return headers.has("Authorization");
+  }
+  if (Array.isArray(headers)) {
+    return headers.some(([name]) => name.toLowerCase() === "authorization");
+  }
+  return Object.keys(headers).some(
+    (name) => name.toLowerCase() === "authorization"
+  );
+}
+function writeHttpTrace(event) {
+  const parts = [
+    "[dreamboard-cli:http]",
+    `method=${event.method}`,
+    `url=${event.url}`,
+    `auth=${event.hasAuthorization ? "present" : "missing"}`,
+    `attempt=${event.attempt + 1}`,
+    `durationMs=${event.durationMs}`
+  ];
+  if (typeof event.status === "number") {
+    parts.push(`status=${event.status}`);
+  }
+  if (event.error) {
+    parts.push(`error=${event.error}`);
+  }
+  if (event.willRetry) {
+    parts.push("willRetry=true");
+  }
+  console.error(parts.join(" "));
+}
+function resolveFetchMethod(input, init) {
+  const method = init?.method ?? (typeof Request !== "undefined" && input instanceof Request ? input.method : void 0);
+  return (method ?? "GET").toUpperCase();
+}
+function isTransientFetchError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+  const normalized = message.toLowerCase();
+  return normalized.includes("fetch failed") || normalized.includes("network") || normalized.includes("timeout") || normalized.includes("econnreset") || normalized.includes("econnrefused") || normalized.includes("socket");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function requireAuth(config) {
+  if (!config.authToken && !config.refreshToken && !resolveLocalHarnessAccessToken(config)) {
+    throw new Error(
+      "Missing Dreamboard session. Run `dreamboard auth login` to authenticate."
+    );
+  }
+}
+function valueOrUndefined(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function getAuthTokenExpiry(accessToken) {
+  if (!accessToken) return null;
+  const parts = accessToken.split(".");
+  if (parts.length !== 3) return null;
+  try {
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf8")
+    );
+    if (typeof payload.exp !== "number" || !Number.isFinite(payload.exp)) {
+      return null;
+    }
+    return new Date(payload.exp * 1e3);
+  } catch {
+    return null;
+  }
+}
+async function loadProjectContextCredentials(requireAuth2, loadCredentials = getStoredSession) {
+  return requireAuth2 ? loadCredentials() : void 0;
+}
+async function resolveProjectContext(flags, opts) {
+  const projectRoot = await findProjectRoot(process.cwd());
+  if (!projectRoot) {
+    throw new Error(
+      "Not inside a dreamboard project (missing .dreamboard/project.json)."
+    );
+  }
+  const projectConfig = await loadProjectConfig(projectRoot);
+  const requireAuthForContext = opts?.requireAuth !== false;
+  const [globalConfig, credentials] = await Promise.all([
+    loadGlobalConfig(),
+    loadProjectContextCredentials(requireAuthForContext)
+  ]);
+  const config = resolveConfig(globalConfig, flags, projectConfig, credentials);
+  if (requireAuthForContext) {
+    requireAuth(config);
+    await configureClient(config);
+  }
+  return { projectRoot, projectConfig, config };
+}
+
+// src/flags.ts
+var configFlagsSchema = external_exports.object({
+  env: external_exports.enum(["local", "staging", "prod"]).optional(),
+  token: external_exports.string().optional()
+});
+var ruleInputFlagsSchema = external_exports.object({
+  "rule-file": external_exports.string().optional(),
+  rule: external_exports.string().optional()
+});
+var playerCountFlagsSchema = external_exports.object({
+  players: external_exports.string().optional(),
+  "player-count": external_exports.string().optional()
+});
+var newCommandArgsSchema = configFlagsSchema.extend({
+  slug: external_exports.string().min(1),
+  description: external_exports.string().min(1),
+  force: external_exports.boolean().default(false),
+  "wait-timeout-ms": external_exports.string().optional(),
+  "repository-poll-interval-ms": external_exports.string().optional()
+});
+var cloneCommandArgsSchema = configFlagsSchema.extend({
+  slug: external_exports.string().min(1),
+  "wait-timeout-ms": external_exports.string().optional(),
+  "repository-poll-interval-ms": external_exports.string().optional()
+});
+var queryCommandArgsSchema = configFlagsSchema.extend({
+  title: external_exports.string().min(1)
+});
+var pullCommandArgsSchema = configFlagsSchema.extend({
+  force: external_exports.boolean().default(false)
+});
+var syncCommandArgsSchema = configFlagsSchema.extend({
+  force: external_exports.boolean().default(false),
+  yes: external_exports.boolean().default(false)
+});
+var compileCommandArgsSchema = configFlagsSchema.extend({
+  debug: external_exports.boolean().default(false),
+  "skip-local-check": external_exports.boolean().default(false)
+});
+var statusCommandArgsSchema = configFlagsSchema.extend({
+  json: external_exports.boolean().default(false)
+});
+var commitScopedCommandArgsSchema = configFlagsSchema.extend({
+  commit: external_exports.string().min(1),
+  json: external_exports.boolean().default(false)
+});
+var buildCommandArgsSchema = commitScopedCommandArgsSchema.extend({
+  profile: external_exports.enum(["preview", "release"]).optional().default("preview")
+});
+var releasePublishCommandArgsSchema = commitScopedCommandArgsSchema.extend({
+  yes: external_exports.boolean().default(false)
+});
+var devCommandArgsSchema = configFlagsSchema.extend({
+  seed: external_exports.string().optional(),
+  "setup-profile": external_exports.string().optional(),
+  players: external_exports.string().optional(),
+  "player-count": external_exports.string().optional(),
+  debug: external_exports.boolean().default(false),
+  resume: external_exports.string().optional(),
+  "from-scenario": external_exports.string().optional(),
+  "new-session": external_exports.boolean().default(false),
+  open: external_exports.boolean().default(false),
+  port: external_exports.string().optional(),
+  host: external_exports.union([external_exports.string(), external_exports.boolean()]).optional(),
+  "allowed-host": external_exports.string().optional()
+});
+var joinCommandArgsSchema = configFlagsSchema.extend({
+  session: external_exports.string().min(1).optional(),
+  player: external_exports.string().min(1),
+  "raw-events": external_exports.boolean().default(false)
+});
+var configCommandArgsSchema = configFlagsSchema.extend({
+  action: external_exports.string().optional().default("show"),
+  scope: external_exports.enum(["global", "workspace"]).optional().default("global")
+});
+var authCommandArgsSchema = external_exports.object({
+  action: external_exports.enum(["set", "login", "logout", "env", "status", "git-credential"]),
+  tokenValue: external_exports.string().optional(),
+  token: external_exports.string().optional(),
+  jwt: external_exports.boolean().optional(),
+  env: external_exports.enum(["local", "staging", "prod"]).optional()
+});
+function parseArgs(commandName, schema, args) {
+  const parsed = schema.safeParse(args);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const details = parsed.error.issues.map((issue) => {
+    const field = issue.path.length > 0 ? issue.path.join(".") : "args";
+    return `${field}: ${issue.message}`;
+  }).join("; ");
+  throw new Error(`Invalid arguments for '${commandName}': ${details}`);
+}
+function parseConfigFlags(args) {
+  return parseArgs("config-flags", configFlagsSchema, args);
+}
+function parsePlayerCountFlags(args) {
+  return parseArgs("player-count", playerCountFlagsSchema, args);
+}
+function parseNewCommandArgs(args) {
+  return parseArgs("new", newCommandArgsSchema, args);
+}
+function parseCloneCommandArgs(args) {
+  return parseArgs("clone", cloneCommandArgsSchema, args);
+}
+function parseCommitScopedCommandArgs(commandName, args) {
+  return parseArgs(commandName, commitScopedCommandArgsSchema, args);
+}
+function parseBuildCommandArgs(args) {
+  return parseArgs("build", buildCommandArgsSchema, args);
+}
+function parseReleasePublishCommandArgs(args) {
+  return parseArgs("release publish", releasePublishCommandArgsSchema, args);
+}
+function parseDevCommandArgs(args) {
+  return parseArgs("dev", devCommandArgsSchema, args);
+}
+function parseAuthCommandArgs(args) {
+  return parseArgs("auth", authCommandArgsSchema, args);
+}
+
+// src/command-args.ts
+var CONFIG_FLAG_ARGS = {
+  env: {
+    type: "string",
+    description: "Environment: local | staging | prod"
+  },
+  token: {
+    type: "string",
+    description: "Auth token (Dreamboard bearer JWT)"
+  }
+};
+
+// src/utils/problem-types.ts
+var CLI_PROBLEM_TYPES = {
+  ...SERVER_PROBLEM_TYPES,
+  ...CLIENT_PROBLEM_TYPES
+};
+
+// src/utils/errors.ts
+var STALE_CONTRACT_ARTIFACT_CODE = "STALE_CONTRACT_ARTIFACT";
+var STALE_CONTRACT_ARTIFACT_EXIT_CODE = 42;
+function isProblemViolationArray(value) {
+  return Array.isArray(value) && value.every(
+    (entry) => typeof entry === "object" && entry !== null && typeof entry.message === "string"
+  );
+}
+function isProblemDetails(value) {
+  return zProblemDetails.safeParse(value).success;
+}
+function coerceViolations(value) {
+  if (isProblemViolationArray(value)) {
+    return value;
+  }
+  if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+    return value.map((message) => ({ message }));
+  }
+  return void 0;
+}
+function getRequestId(response) {
+  return response?.headers?.get?.("X-Correlation-ID") ?? response?.headers?.get?.("x-correlation-id") ?? void 0;
+}
+function toApiProblem(error, response, fallback) {
+  if (isProblemDetails(error)) {
+    return {
+      ...error,
+      status: error.status || response?.status || 0,
+      requestId: error.requestId ?? getRequestId(response)
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      type: CLI_PROBLEM_TYPES.TRANSPORT_ERROR,
+      title: response?.statusText || "API error",
+      status: response?.status ?? 0,
+      detail: error.message || fallback,
+      requestId: getRequestId(response)
+    };
+  }
+  if (error && typeof error === "object") {
+    const obj = error;
+    const detail2 = typeof obj.detail === "string" ? obj.detail : typeof obj.message === "string" ? obj.message : void 0;
+    const title = typeof obj.title === "string" ? obj.title : response?.statusText || "API error";
+    const violations = coerceViolations(obj.violations) ?? coerceViolations(obj.errors);
+    if (detail2) {
+      return {
+        type: typeof obj.type === "string" ? obj.type : CLI_PROBLEM_TYPES.UNKNOWN_API_ERROR,
+        title,
+        status: typeof obj.status === "number" ? obj.status : response?.status ?? 0,
+        detail: detail2,
+        requestId: typeof obj.requestId === "string" ? obj.requestId : getRequestId(response),
+        retryable: typeof obj.retryable === "boolean" ? obj.retryable : void 0,
+        context: typeof obj.context === "object" && obj.context !== null ? obj.context : void 0,
+        violations,
+        timestamp: typeof obj.timestamp === "string" ? obj.timestamp : void 0,
+        instance: typeof obj.instance === "string" ? obj.instance : void 0
+      };
+    }
+  }
+  const detail = typeof error === "string" ? error.trim() || fallback : fallback;
+  return {
+    type: CLI_PROBLEM_TYPES.UNKNOWN_API_ERROR,
+    title: response?.statusText || "API error",
+    status: response?.status ?? 0,
+    detail,
+    requestId: getRequestId(response)
+  };
+}
+function formatProblem(problem) {
+  const base = problem.detail || problem.title;
+  const violations = problem.violations && problem.violations.length > 0 ? ` (${problem.violations.map((entry) => entry.message).join("; ")})` : "";
+  const statusSuffix = problem.status && problem.status > 0 ? ` (HTTP ${problem.status})` : "";
+  return `${base}${violations}${statusSuffix}`;
+}
+var DreamboardApiError = class extends Error {
+  problem;
+  status;
+  requestId;
+  retryable;
+  constructor(problem, cause) {
+    super(formatProblem(problem), { cause });
+    this.name = "DreamboardApiError";
+    this.problem = problem;
+    this.status = problem.status;
+    this.requestId = problem.requestId;
+    this.retryable = problem.retryable;
+  }
+};
+function toDreamboardApiError(error, response, fallback) {
+  return new DreamboardApiError(toApiProblem(error, response, fallback), error);
+}
+function isDreamboardApiError(error) {
+  return error instanceof DreamboardApiError;
+}
+function getObjectStringProperty(value, property) {
+  return value && typeof value === "object" && typeof value[property] === "string" ? value[property] : void 0;
+}
+function isStaleContractArtifactMessage(message) {
+  return message.includes(STALE_CONTRACT_ARTIFACT_CODE) || message.includes("StaleContractArtifactError") || message.toLowerCase().includes("stale contract artifact");
+}
+function isStaleContractArtifactError(error) {
+  if (getObjectStringProperty(error, "code") === STALE_CONTRACT_ARTIFACT_CODE) {
+    return true;
+  }
+  if (getObjectStringProperty(error, "name") === "StaleContractArtifactError") {
+    return true;
+  }
+  const message = getObjectStringProperty(error, "message");
+  return message ? isStaleContractArtifactMessage(message) : false;
+}
+function getCliErrorExitCode(error) {
+  return isStaleContractArtifactError(error) ? STALE_CONTRACT_ARTIFACT_EXIT_CODE : 1;
+}
+function isGameNotFoundProblem(problem) {
+  return problem.status === 404 && (problem.detail?.startsWith("Game not found: ") === true || problem.instance?.includes("/source-blobs/upload-sessions") === true);
+}
+function getProblemResolution(problem) {
+  if (isGameNotFoundProblem(problem)) {
+    return [
+      "Verify the project binding with `dreamboard project status --commit <rev>` after pushing the exact commit.",
+      "If you meant to use an existing remote project, check that your selected account and environment point at the backend that has that project."
+    ].join(" ");
+  }
+  switch (problem.type) {
+    case CLI_PROBLEM_TYPES.UNAUTHORIZED:
+      return "Run `dreamboard auth login` to authenticate again.";
+    case CLI_PROBLEM_TYPES.FORBIDDEN:
+      return "Check that the signed-in account has access to this game, or run `dreamboard auth login` with the correct account.";
+    case CLI_PROBLEM_TYPES.TOO_MANY_REQUESTS:
+      return "Wait a moment, then retry the command.";
+    case CLI_PROBLEM_TYPES.TRANSPORT_ERROR:
+      return "Check that the selected Dreamboard server is reachable and try again later.";
+    case CLI_PROBLEM_TYPES.VALIDATION_FAILED:
+      return "Fix the validation issue above, then retry the command.";
+    case CLI_PROBLEM_TYPES.ACTIVE_JOB_CONFLICT:
+      return "Wait for the active job to finish, then retry the command.";
+    case CLI_PROBLEM_TYPES.GAME_SLUG_CONFLICT:
+      return "Choose a different game slug, or use the existing workspace for that slug.";
+    case CLI_PROBLEM_TYPES.SOURCE_REVISION_NOT_FOUND:
+      return "Push the exact Git commit, then run `dreamboard project status --commit <rev> --wait` before retrying.";
+    case CLI_PROBLEM_TYPES.SOURCE_REVISION_DRIFT:
+    case CLI_PROBLEM_TYPES.AUTHORING_STATE_DRIFT:
+    case CLI_PROBLEM_TYPES.STATE_CONFLICT:
+      return "Resolve the Git/source conflict in your worktree, push the intended exact commit, and retry the command against that commit.";
+    case CLI_PROBLEM_TYPES.SOURCE_REVISION_BASE_MISSING:
+    case CLI_PROBLEM_TYPES.AUTHORING_STATE_BASE_MISSING:
+      return "Clone the project repository into a clean workspace or push the intended exact commit before retrying.";
+    case CLI_PROBLEM_TYPES.INTERNAL_ERROR:
+      return "Retry the command. If it still fails, include the request id when asking for help.";
+    default:
+      return void 0;
+  }
+}
+function getProblemDetails(problem) {
+  return [
+    `Problem: ${problem.type}`,
+    problem.instance ? `Endpoint: ${problem.instance}` : void 0,
+    problem.requestId ? `Request ID: ${problem.requestId}` : void 0,
+    problem.timestamp ? `Timestamp: ${problem.timestamp}` : void 0
+  ].filter((detail) => Boolean(detail));
+}
+function presentCliError(error) {
+  if (isDreamboardApiError(error)) {
+    return {
+      message: formatProblem(error.problem),
+      resolution: getProblemResolution(error.problem),
+      details: getProblemDetails(error.problem)
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      details: []
+    };
+  }
+  if (typeof error === "object" && error !== null) {
+    let serialized;
+    try {
+      serialized = JSON.stringify(error);
+    } catch {
+      serialized = String(error);
+    }
+    return {
+      message: serialized,
+      details: []
+    };
+  }
+  return {
+    message: String(error),
+    details: []
+  };
+}
+function formatCliError(error) {
+  const presentation = presentCliError(error);
+  return [
+    presentation.message,
+    presentation.resolution ? `Resolution: ${presentation.resolution}` : void 0,
+    ...presentation.details
+  ].filter((line) => Boolean(line)).join("\n");
+}
+
+// src/utils/strings.ts
+import path from "path";
+function normalizeSlug(input) {
+  const lowered = input.trim().toLowerCase();
+  const replaced = lowered.replace(/[^a-z0-9]+/g, "-");
+  return replaced.replace(/^-+/, "").replace(/-+$/, "");
+}
+function titleFromSlug(slug) {
+  return slug.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function parsePositiveInt(value, label) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer.`);
+  }
+  return parsed;
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/services/api/compiled-results-api.ts
+var COMPILE_JOB_POLL_INTERVAL_MS = 1e3;
+var DEFAULT_COMPILE_JOB_WAIT_TIMEOUT_MS = 10 * 60 * 1e3;
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+function formatTerminalCompileJobMessage(job) {
+  const detail = firstNonEmpty(job.errorMessage, job.message);
+  const phase = firstNonEmpty(job.phase);
+  const prefix = `Compile ${job.status.toLowerCase()}${phase ? ` [${phase}]` : ""}`;
+  return detail ? `${prefix}: ${detail}` : `${prefix}: job ${job.jobId} ended before a compiled result was created.`;
+}
+function compareCreatedAtDesc(left, right) {
+  const leftTime = Date.parse(left.createdAt);
+  const rightTime = Date.parse(right.createdAt);
+  if (Number.isFinite(leftTime) && Number.isFinite(rightTime)) {
+    return rightTime - leftTime;
+  }
+  if (Number.isFinite(rightTime)) {
+    return 1;
+  }
+  if (Number.isFinite(leftTime)) {
+    return -1;
+  }
+  return 0;
+}
+async function findFallbackCompiledResultForJob(options) {
+  const { projectId, job } = options;
+  if (!projectId) {
+    return null;
+  }
+  const results = await listProjectCompiledResults({
+    path: { projectId },
+    query: { limit: 100 }
+  });
+  if (results.error || !results.data) {
+    return null;
+  }
+  if (results.data.results.length === 0) {
+    return null;
+  }
+  const jobCreatedAtMs = Date.parse(job.createdAt);
+  const resultsCreatedAfterJob = Number.isFinite(jobCreatedAtMs) ? results.data.results.filter((result) => {
+    const resultCreatedAtMs = Date.parse(result.createdAt);
+    return !Number.isFinite(resultCreatedAtMs) || resultCreatedAtMs >= jobCreatedAtMs;
+  }) : results.data.results;
+  const candidateResults = resultsCreatedAfterJob.length > 0 ? resultsCreatedAfterJob : results.data.results;
+  return [...candidateResults].sort(compareCreatedAtDesc)[0] ?? null;
+}
+async function findCompiledResultsForAuthoringState(options) {
+  void options;
+  return [];
+}
+async function getProjectCompiledResultSdk(projectId, compiledResultId) {
+  const { data, error, response } = await getProjectCompiledResult({
+    path: { projectId, compiledResultId }
+  });
+  if (error || !data) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      "Failed to fetch compiled result"
+    );
+  }
+  return data;
+}
+async function waitForCompiledResultJobSdk(options) {
+  const { projectId, jobId, onProgress } = options;
+  if (!projectId) {
+    throw new Error("projectId is required when waiting for a compile job.");
+  }
+  let previousTransitionKey = null;
+  const startedAt = Date.now();
+  const timeoutMs = readCompileJobWaitTimeoutMs();
+  while (Date.now() - startedAt < timeoutMs) {
+    const {
+      data: job,
+      error,
+      response
+    } = await getJob({
+      path: { jobId }
+    });
+    if (error || !job) {
+      if (isTransientJobPollError(error, response)) {
+        await sleep2(COMPILE_JOB_POLL_INTERVAL_MS);
+        continue;
+      }
+      throw toDreamboardApiError(error, response, "Failed to get job");
+    }
+    const transitionKey = `${job.status}:${job.phase ?? ""}`;
+    if (transitionKey !== previousTransitionKey) {
+      previousTransitionKey = transitionKey;
+      onProgress?.(job);
+    }
+    if (job.status === "COMPLETED" || job.status === "FAILED") {
+      const compiledResultId = job.createdCompiledResultId ?? job.createdAppScriptId;
+      if (compiledResultId) {
+        const compiledResult = await getProjectCompiledResultSdk(
+          projectId,
+          compiledResultId
+        );
+        return { job, compiledResult };
+      }
+      const fallbackCompiledResult = await findFallbackCompiledResultForJob({
+        projectId,
+        job
+      });
+      if (fallbackCompiledResult) {
+        return { job, compiledResult: fallbackCompiledResult };
+      }
+      throw new Error(formatTerminalCompileJobMessage(job));
+    }
+    if (job.status === "CANCELLED" || job.status === "INTERRUPTED") {
+      throw new Error(formatTerminalCompileJobMessage(job));
+    }
+    await sleep2(COMPILE_JOB_POLL_INTERVAL_MS);
+  }
+  throw new Error(`Compile job ${jobId} did not complete in time.`);
+}
+function readCompileJobWaitTimeoutMs() {
+  const raw = process.env.DREAMBOARD_COMPILE_WAIT_TIMEOUT_MS;
+  if (!raw) return DEFAULT_COMPILE_JOB_WAIT_TIMEOUT_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_COMPILE_JOB_WAIT_TIMEOUT_MS;
+  }
+  return parsed;
+}
+function isTransientJobPollError(error, response) {
+  if (response) return false;
+  if (!error) return false;
+  if (error instanceof Error) {
+    return isTransientJobPollMessage(error.message);
+  }
+  if (typeof error === "object" && error !== null && "message" in error) {
+    return isTransientJobPollMessage(String(error.message));
+  }
+  return isTransientJobPollMessage(String(error));
+}
+function isTransientJobPollMessage(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("fetch failed") || normalized.includes("network") || normalized.includes("timeout") || normalized.includes("econnreset") || normalized.includes("econnrefused") || normalized.includes("socket");
+}
+
+// src/services/testing/reducer-native-test-harness.ts
+import path3 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+import { createRequire } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { readdir } from "fs/promises";
+import { isDeepStrictEqual } from "util";
+
+// src/utils/ts-module-loader.ts
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import path2 from "path";
+import { pathToFileURL } from "url";
+import { build } from "esbuild";
+var ESBUILD_EXTERNALS = [
+  "playwright",
+  "playwright-core",
+  "chromium-bidi",
+  "electron"
+];
+function resolveSourceCheckoutBuildContext() {
+  try {
+    const repoRoot = resolveCliRepoRoot(import.meta.url);
+    return {
+      nodePaths: [
+        path2.join(repoRoot, "apps", "dreamboard-cli", "node_modules"),
+        path2.join(repoRoot, "node_modules")
+      ],
+      plugins: [createRepoLocalPackageResolutionPlugin({ repoRoot })]
+    };
+  } catch {
+    return {
+      nodePaths: [path2.join(process.cwd(), "node_modules")],
+      plugins: []
+    };
+  }
+}
+async function bundleTypeScriptModuleText(entryPath, options = {}) {
+  const sourceCheckoutContext = resolveSourceCheckoutBuildContext();
+  const result = await build({
+    entryPoints: [entryPath],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node24",
+    sourcemap: "inline",
+    external: [...ESBUILD_EXTERNALS, ...options.external ?? []],
+    nodePaths: sourceCheckoutContext.nodePaths,
+    plugins: sourceCheckoutContext.plugins,
+    write: false
+  });
+  const output = result.outputFiles?.[0];
+  if (!output) {
+    throw new Error(`Failed to bundle TypeScript module '${entryPath}'.`);
+  }
+  return output.text;
+}
+async function importTypeScriptModule(entryPath) {
+  const tempDir = await mkdtemp(path2.join(tmpdir(), "dreamboard-ts-module-"));
+  const outfile = path2.join(
+    tempDir,
+    `${path2.basename(entryPath).replace(/\.[^.]+$/u, "")}.mjs`
+  );
+  try {
+    const bundledText = await bundleTypeScriptModuleText(entryPath);
+    await writeFile(outfile, bundledText);
+    return await import(pathToFileURL(outfile).href);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+// src/services/gameplay-authority-submit.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// ../../node_modules/.pnpm/@dreamboard-games+gameplay-authority-protocol@0.1.0-alpha.0/node_modules/@dreamboard-games/gameplay-authority-protocol/dist/frames.js
+var GAMEPLAY_AUTHORITY_AUDIENCE = "dreamboard-gameplay-authority";
+var GAMEPLAY_TUNNEL_AUDIENCE = "dreamboard-gameplay-authority-tunnel";
+var GameplayPermissionSchema = external_exports.enum([
+  "observe",
+  "submit",
+  "restore-history"
+]);
+var GameplayConnectionContextSchema = external_exports.object({
+  sessionId: external_exports.string().uuid(),
+  playerId: external_exports.string().min(1),
+  permissions: external_exports.array(GameplayPermissionSchema)
+});
+var GameplayActorKindSchema = external_exports.enum(["user", "demo", "perf"]);
+var JsonPatchOperationSchema = external_exports.object({
+  op: external_exports.string().min(1),
+  path: external_exports.string()
+}).catchall(external_exports.unknown());
+var ProjectedDeltaSchema = external_exports.object({
+  kind: external_exports.literal("delta"),
+  generation: external_exports.number().int().nonnegative(),
+  baseVersion: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  patch: external_exports.array(JsonPatchOperationSchema)
+});
+var ProjectedSnapshotSchema = external_exports.object({
+  kind: external_exports.literal("snapshot"),
+  generation: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  view: external_exports.unknown()
+});
+var BaseGameplayCapabilityClaimsSchema = external_exports.object({
+  typ: external_exports.literal("gameplay-capability"),
+  aud: external_exports.literal(GAMEPLAY_AUTHORITY_AUDIENCE),
+  iss: external_exports.string().min(1),
+  exp: external_exports.number().int().positive(),
+  iat: external_exports.number().int().positive().optional(),
+  jti: external_exports.string().min(1).optional(),
+  sessionId: external_exports.string().uuid(),
+  playerId: external_exports.string().min(1),
+  permissions: external_exports.array(GameplayPermissionSchema)
+});
+var UserGameplayCapabilityClaimsSchema = BaseGameplayCapabilityClaimsSchema.extend({
+  actorKind: external_exports.literal("user")
+});
+var DemoGameplayCapabilityClaimsSchema = BaseGameplayCapabilityClaimsSchema.extend({
+  actorKind: external_exports.literal("demo")
+});
+var PerfGameplayCapabilityClaimsSchema = BaseGameplayCapabilityClaimsSchema.extend({
+  actorKind: external_exports.literal("perf"),
+  perfRunId: external_exports.string().uuid(),
+  laneId: external_exports.string().min(1)
+});
+var GameplayCapabilityClaimsSchema = external_exports.discriminatedUnion("actorKind", [
+  UserGameplayCapabilityClaimsSchema,
+  DemoGameplayCapabilityClaimsSchema,
+  PerfGameplayCapabilityClaimsSchema
+]);
+var GameplayTunnelClaimsSchema = external_exports.object({
+  aud: external_exports.literal(GAMEPLAY_TUNNEL_AUDIENCE),
+  iss: external_exports.string().min(1),
+  exp: external_exports.number().int().positive(),
+  iat: external_exports.number().int().positive().optional(),
+  jti: external_exports.string().min(1).optional(),
+  targetInstanceId: external_exports.string().min(1),
+  sessionId: external_exports.string().uuid(),
+  playerId: external_exports.string().min(1),
+  // Permissions are cryptographically bound into the tunnel token so the owner
+  // task trusts the signed claim set rather than the unauthenticated
+  // `tunnel.bind` frame. An ingress task cannot grant a player capabilities the
+  // issued token did not attest.
+  permissions: external_exports.array(GameplayPermissionSchema)
+});
+var AuthConnectFrameSchema = external_exports.object({
+  type: external_exports.literal("auth.connect"),
+  capabilityToken: external_exports.string().min(1)
+});
+var AuthRefreshFrameSchema = external_exports.object({
+  type: external_exports.literal("auth.refresh"),
+  capabilityToken: external_exports.string().min(1)
+});
+var SessionResumeFrameSchema = external_exports.object({
+  type: external_exports.literal("session.resume"),
+  lastSeenGeneration: external_exports.number().int().nonnegative().nullable(),
+  lastSeenVersion: external_exports.number().int().nonnegative().nullable(),
+  unacknowledgedClientActionIds: external_exports.array(external_exports.string().min(1)).max(32)
+});
+var CommandSubmitFrameSchema = external_exports.object({
+  type: external_exports.literal("command.submit"),
+  clientActionId: external_exports.string().min(1).max(128),
+  expectedVersion: external_exports.number().int().nonnegative(),
+  actionSetVersion: external_exports.string().min(1),
+  interactionId: external_exports.string().min(1),
+  inputs: external_exports.record(external_exports.string(), external_exports.unknown())
+});
+var HistoryRestoreFrameSchema = external_exports.object({
+  type: external_exports.literal("history.restore"),
+  restoreId: external_exports.string().min(1).max(128),
+  targetGeneration: external_exports.number().int().nonnegative(),
+  targetVersion: external_exports.number().int().nonnegative()
+});
+var ClientGameplayFrameSchema = external_exports.discriminatedUnion("type", [
+  AuthConnectFrameSchema,
+  AuthRefreshFrameSchema,
+  SessionResumeFrameSchema,
+  CommandSubmitFrameSchema,
+  HistoryRestoreFrameSchema
+]);
+var TunnelBindFrameSchema = external_exports.object({
+  type: external_exports.literal("tunnel.bind"),
+  context: GameplayConnectionContextSchema
+});
+var TunnelClientFrameSchema = external_exports.discriminatedUnion("type", [
+  TunnelBindFrameSchema,
+  SessionResumeFrameSchema,
+  CommandSubmitFrameSchema,
+  HistoryRestoreFrameSchema
+]);
+var CommandAcceptedFrameSchema = external_exports.object({
+  type: external_exports.literal("command.accepted"),
+  clientActionId: external_exports.string().min(1),
+  generation: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  stateHash: external_exports.string().min(1),
+  update: ProjectedSnapshotSchema
+});
+var CommandRejectedFrameSchema = external_exports.object({
+  type: external_exports.literal("command.rejected"),
+  clientActionId: external_exports.string().min(1).optional(),
+  errorCode: external_exports.string().min(1),
+  message: external_exports.string().min(1),
+  currentGeneration: external_exports.number().int().nonnegative().optional(),
+  currentVersion: external_exports.number().int().nonnegative().optional()
+});
+var HistoryRestoredFrameSchema = external_exports.object({
+  type: external_exports.literal("history.restored"),
+  restoreId: external_exports.string().min(1),
+  generation: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  stateHash: external_exports.string().min(1),
+  update: ProjectedSnapshotSchema
+});
+var HistoryRestoreRejectedFrameSchema = external_exports.object({
+  type: external_exports.literal("history.restoreRejected"),
+  restoreId: external_exports.string().min(1).optional(),
+  errorCode: external_exports.string().min(1),
+  message: external_exports.string().min(1),
+  currentGeneration: external_exports.number().int().nonnegative().optional(),
+  currentVersion: external_exports.number().int().nonnegative().optional()
+});
+var AuthAcceptedFrameSchema = external_exports.object({
+  type: external_exports.literal("auth.accepted"),
+  expiresAt: external_exports.string().datetime()
+});
+var AuthorityRecoveringFrameSchema = external_exports.object({
+  type: external_exports.literal("authority.recovering"),
+  retryAfterMs: external_exports.number().int().positive(),
+  message: external_exports.string().min(1)
+});
+var SessionSnapshotFrameSchema = external_exports.object({
+  type: external_exports.literal("session.snapshot"),
+  generation: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  stateHash: external_exports.string().min(1),
+  update: ProjectedSnapshotSchema
+});
+var SessionDeltaFrameSchema = external_exports.object({
+  type: external_exports.literal("session.delta"),
+  clientActionId: external_exports.string().min(1).optional(),
+  update: ProjectedDeltaSchema
+});
+var ServerGameplayFrameSchema = external_exports.discriminatedUnion("type", [
+  AuthAcceptedFrameSchema,
+  AuthorityRecoveringFrameSchema,
+  SessionSnapshotFrameSchema,
+  SessionDeltaFrameSchema,
+  CommandAcceptedFrameSchema,
+  CommandRejectedFrameSchema,
+  HistoryRestoredFrameSchema,
+  HistoryRestoreRejectedFrameSchema
+]);
+var TunnelBoundFrameSchema = external_exports.object({
+  type: external_exports.literal("tunnel.bound"),
+  sessionId: external_exports.string().uuid(),
+  playerId: external_exports.string().min(1)
+});
+var TunnelServerFrameSchema = external_exports.discriminatedUnion("type", [
+  TunnelBoundFrameSchema,
+  AuthorityRecoveringFrameSchema,
+  SessionSnapshotFrameSchema,
+  SessionDeltaFrameSchema,
+  CommandAcceptedFrameSchema,
+  CommandRejectedFrameSchema,
+  HistoryRestoredFrameSchema,
+  HistoryRestoreRejectedFrameSchema
+]);
+
+// ../../node_modules/.pnpm/@dreamboard-games+gameplay-authority-client@0.1.0-alpha.1/node_modules/@dreamboard-games/gameplay-authority-client/dist/index.js
+var DEFAULT_OPEN_TIMEOUT_MS = 5e3;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var GameplayAuthorityRecoveringError = class extends Error {
+  retryAfterMs;
+  constructor(message, retryAfterMs) {
+    super(message);
+    this.name = "GameplayAuthorityRecoveringError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+async function connectGameplayAuthority(input) {
+  const webSocketFactory = input.webSocketFactory ?? browserWebSocketFactory();
+  const openTimeoutMs = input.openTimeoutMs ?? DEFAULT_OPEN_TIMEOUT_MS;
+  const requestTimeoutMs = input.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const socket = new webSocketFactory(input.websocketUrl, input.webSocketInit);
+  try {
+    await waitUntilOpen(socket, openTimeoutMs);
+    socket.send(JSON.stringify({
+      type: "auth.connect",
+      capabilityToken: input.capabilityToken
+    }));
+    await waitForServerFrame(socket, (frame) => frame.type === "auth.accepted", requestTimeoutMs);
+    return new WebSocketGameplayAuthorityClient(socket, requestTimeoutMs);
+  } catch (error) {
+    socket.close();
+    throw error;
+  }
+}
+var WebSocketGameplayAuthorityClient = class {
+  socket;
+  requestTimeoutMs;
+  constructor(socket, requestTimeoutMs) {
+    this.socket = socket;
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+  resume(input = {}) {
+    this.socket.send(JSON.stringify({
+      type: "session.resume",
+      lastSeenGeneration: input.lastSeenGeneration ?? null,
+      lastSeenVersion: input.lastSeenVersion ?? null,
+      unacknowledgedClientActionIds: input.unacknowledgedClientActionIds ?? []
+    }));
+  }
+  async submitCommand(input) {
+    this.socket.send(JSON.stringify({
+      type: "command.submit",
+      clientActionId: input.clientActionId,
+      expectedVersion: input.expectedVersion,
+      actionSetVersion: input.actionSetVersion,
+      interactionId: input.interactionId,
+      inputs: input.inputs
+    }));
+    const frame = await waitForServerFrame(this.socket, (candidate) => candidate.type === "authority.recovering" || candidate.type === "command.accepted" && candidate.clientActionId === input.clientActionId || candidate.type === "command.rejected" && (candidate.clientActionId === void 0 || candidate.clientActionId === input.clientActionId), this.requestTimeoutMs);
+    throwIfRecovering(frame);
+    if (frame.type !== "command.accepted" && frame.type !== "command.rejected") {
+      throw new Error("Unexpected gameplay authority command frame.");
+    }
+    return frame;
+  }
+  async restoreHistory(input) {
+    this.socket.send(JSON.stringify({
+      type: "history.restore",
+      restoreId: input.restoreId,
+      targetGeneration: input.targetGeneration,
+      targetVersion: input.targetVersion
+    }));
+    const frame = await waitForServerFrame(this.socket, (candidate) => candidate.type === "authority.recovering" || candidate.type === "history.restored" && candidate.restoreId === input.restoreId || candidate.type === "history.restoreRejected" && (candidate.restoreId === void 0 || candidate.restoreId === input.restoreId), this.requestTimeoutMs);
+    throwIfRecovering(frame);
+    if (frame.type !== "history.restored" && frame.type !== "history.restoreRejected") {
+      throw new Error("Unexpected gameplay authority history frame.");
+    }
+    return frame;
+  }
+  frames(signal) {
+    return readServerFrames(this.socket, signal);
+  }
+  close() {
+    this.socket.close();
+  }
+};
+function throwIfRecovering(frame) {
+  if (frame.type === "authority.recovering") {
+    throw new GameplayAuthorityRecoveringError(frame.message, frame.retryAfterMs);
+  }
+}
+function browserWebSocketFactory() {
+  return BrowserGameplayAuthorityWebSocket;
+}
+var BrowserGameplayAuthorityWebSocket = class {
+  socket;
+  listeners = /* @__PURE__ */ new Map();
+  constructor(url, init) {
+    if (init?.headers && Object.keys(init.headers).length > 0) {
+      throw new Error("Browser WebSocket does not support custom headers; provide a webSocketFactory for header-aware runtimes.");
+    }
+    this.socket = new WebSocket(url);
+  }
+  send(data) {
+    this.socket.send(data);
+  }
+  close() {
+    this.socket.close();
+  }
+  on(event, listener) {
+    const wrapped = (observed) => {
+      if (event === "message" && "data" in observed) {
+        listener(observed.data);
+        return;
+      }
+      listener(observed);
+    };
+    const listeners = this.listeners.get(event) ?? /* @__PURE__ */ new Map();
+    listeners.set(listener, wrapped);
+    this.listeners.set(event, listeners);
+    this.socket.addEventListener(event, wrapped);
+  }
+  off(event, listener) {
+    const listeners = this.listeners.get(event);
+    const wrapped = listeners?.get(listener);
+    if (!listeners || !wrapped) {
+      return;
+    }
+    this.socket.removeEventListener(event, wrapped);
+    listeners.delete(listener);
+  }
+};
+async function waitUntilOpen(socket, timeoutMs) {
+  await waitForEvent(socket, "open", timeoutMs);
+}
+async function waitForEvent(socket, event, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const cleanup = installSocketListeners(socket, {
+      timeoutMs,
+      onEvent(observed) {
+        if (observed === event) {
+          cleanup();
+          resolve();
+        }
+      },
+      onError(error) {
+        cleanup();
+        reject(error instanceof Error ? error : new Error("gameplay socket error"));
+      },
+      onClose() {
+        cleanup();
+        reject(new Error("gameplay socket closed"));
+      },
+      onTimeout() {
+        cleanup();
+        reject(new Error("gameplay socket timed out"));
+      }
+    });
+  });
+}
+async function waitForServerFrame(socket, predicate, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const cleanup = installSocketListeners(socket, {
+      timeoutMs,
+      onMessage(data) {
+        let frame;
+        try {
+          frame = ServerGameplayFrameSchema.parse(JSON.parse(messageToString(data)));
+        } catch (error) {
+          cleanup();
+          reject(error instanceof Error ? error : new Error("invalid gameplay authority frame"));
+          return;
+        }
+        if (predicate(frame)) {
+          cleanup();
+          resolve(frame);
+        }
+      },
+      onError(error) {
+        cleanup();
+        reject(error instanceof Error ? error : new Error("gameplay socket error"));
+      },
+      onClose() {
+        cleanup();
+        reject(new Error("gameplay socket closed"));
+      },
+      onTimeout() {
+        cleanup();
+        reject(new Error("gameplay socket timed out"));
+      }
+    });
+  });
+}
+function installSocketListeners(socket, handlers) {
+  const timer = setTimeout(handlers.onTimeout, handlers.timeoutMs);
+  const onOpen = () => handlers.onEvent?.("open");
+  const onMessage = (data) => handlers.onMessage?.(data);
+  const onError = (error) => handlers.onError(error);
+  const onClose = () => handlers.onClose();
+  socket.on("open", onOpen);
+  socket.on("message", onMessage);
+  socket.on("error", onError);
+  socket.on("close", onClose);
+  return () => {
+    clearTimeout(timer);
+    socket.off?.("open", onOpen);
+    socket.off?.("message", onMessage);
+    socket.off?.("error", onError);
+    socket.off?.("close", onClose);
+  };
+}
+function readServerFrames(socket, signal) {
+  const queue = [];
+  let wake = null;
+  let closed = false;
+  let error = null;
+  const wakeReader = () => {
+    wake?.();
+    wake = null;
+  };
+  const onMessage = (data) => {
+    try {
+      queue.push(ServerGameplayFrameSchema.parse(JSON.parse(messageToString(data))));
+    } catch (candidate) {
+      error = candidate instanceof Error ? candidate : new Error("invalid gameplay authority frame");
+    }
+    wakeReader();
+  };
+  const onError = (candidate) => {
+    error = candidate instanceof Error ? candidate : new Error("gameplay socket error");
+    wakeReader();
+  };
+  const onClose = () => {
+    closed = true;
+    wakeReader();
+  };
+  const onAbort = () => {
+    closed = true;
+    wakeReader();
+  };
+  socket.on("message", onMessage);
+  socket.on("error", onError);
+  socket.on("close", onClose);
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const cleanup = () => {
+    socket.off?.("message", onMessage);
+    socket.off?.("error", onError);
+    socket.off?.("close", onClose);
+    signal?.removeEventListener("abort", onAbort);
+  };
+  const iterator = {
+    async next() {
+      while (!closed && !signal?.aborted) {
+        const next = queue.shift();
+        if (next) {
+          return { done: false, value: next };
+        }
+        if (error) {
+          cleanup();
+          throw error;
+        }
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+      cleanup();
+      if (error) {
+        throw error;
+      }
+      return { done: true, value: void 0 };
+    },
+    async return(value) {
+      closed = true;
+      wakeReader();
+      cleanup();
+      return { done: true, value };
+    },
+    async throw(candidate) {
+      closed = true;
+      wakeReader();
+      cleanup();
+      throw candidate;
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async [Symbol.asyncDispose]() {
+      await this.return(void 0);
+    }
+  };
+  return iterator;
+}
+function messageToString(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new TextDecoder().decode(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new TextDecoder().decode(data);
+  }
+  return String(data);
+}
+
+// src/services/gameplay-authority-submit.ts
+var CLIENT_ACTION_ID_HEADER = "X-Dreamboard-Client-Action-Id";
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function submitGameplayAuthorityAction(options) {
+  try {
+    const requestCapability = options.capabilityRequester ?? createGameplayCapability;
+    const connectAuthority = options.connectAuthority ?? connectGameplayAuthority;
+    const capability = await requestCapability({
+      path: {
+        sessionId: options.path.sessionId,
+        playerId: options.path.playerId
+      }
+    });
+    if (capability.error || !capability.data) {
+      return { error: capability.error ?? new Error("Missing capability.") };
+    }
+    const clientActionId = options.headers?.[CLIENT_ACTION_ID_HEADER] ?? options.clientActionIdFactory?.() ?? randomUUID2();
+    const client2 = await connectAuthority({
+      websocketUrl: capability.data.websocketUrl,
+      capabilityToken: capability.data.token,
+      openTimeoutMs: DEFAULT_TIMEOUT_MS,
+      requestTimeoutMs: DEFAULT_TIMEOUT_MS
+    });
+    try {
+      const frame = await client2.submitCommand({
+        clientActionId,
+        expectedVersion: options.body.expectedVersion,
+        actionSetVersion: options.body.actionSetVersion,
+        interactionId: options.path.interactionId,
+        inputs: options.body.inputs ?? {}
+      });
+      if (frame.type === "command.rejected") {
+        return {
+          data: {
+            success: false,
+            accepted: false,
+            version: typeof frame.currentVersion === "number" ? frame.currentVersion : options.body.expectedVersion,
+            actionSetVersion: options.body.actionSetVersion,
+            errorCode: typeof frame.errorCode === "string" ? frame.errorCode : void 0,
+            message: typeof frame.message === "string" ? frame.message : void 0,
+            clientActionId
+          }
+        };
+      }
+      const acceptedVersion = typeof frame.version === "number" ? frame.version : void 0;
+      if (acceptedVersion === void 0) {
+        return {
+          error: new Error("Accepted frame did not include a numeric version.")
+        };
+      }
+      const update = frame.update && typeof frame.update === "object" ? frame.update : {};
+      const view = update.view && typeof update.view === "object" ? update.view : {};
+      const projectedActionSetVersion = typeof view.actionSetVersion === "string" ? view.actionSetVersion : void 0;
+      return {
+        data: {
+          success: true,
+          accepted: true,
+          durabilityStatus: "COMMITTED",
+          version: acceptedVersion,
+          actionSetVersion: projectedActionSetVersion ?? options.body.actionSetVersion,
+          clientActionId
+        }
+      };
+    } catch (error) {
+      if (error instanceof GameplayAuthorityRecoveringError) {
+        return {
+          error: new Error(error.message || "Session authority is recovering.")
+        };
+      }
+      throw error;
+    } finally {
+      client2.close();
+    }
+  } catch (error) {
+    return { error };
+  }
+}
+
+// src/services/workflows/resolve-setup-profile.ts
+function resolveSetupProfileSelection(options) {
+  const setupProfiles = options.manifest.setupProfiles ?? [];
+  const requestedSetupProfileId = options.requestedSetupProfileId?.trim() || void 0;
+  if (requestedSetupProfileId) {
+    const requestedProfile = setupProfiles.find(
+      (profile) => profile.id === requestedSetupProfileId
+    );
+    if (!requestedProfile) {
+      const knownProfiles = setupProfiles.map((profile) => profile.id).join(", ");
+      throw new Error(
+        setupProfiles.length === 0 ? `Unknown setup profile '${requestedSetupProfileId}'. The manifest defines no setup profiles.` : `Unknown setup profile '${requestedSetupProfileId}'. Expected one of: ${knownProfiles}.`
+      );
+    }
+    return {
+      id: requestedProfile.id,
+      name: requestedProfile.name,
+      source: "explicit"
+    };
+  }
+  if (setupProfiles.length === 0) {
+    return {
+      id: null,
+      name: null,
+      source: "none"
+    };
+  }
+  if (setupProfiles.length === 1) {
+    return {
+      id: setupProfiles[0]?.id ?? null,
+      name: setupProfiles[0]?.name ?? null,
+      source: "implicit-single"
+    };
+  }
+  return {
+    id: setupProfiles[0]?.id ?? null,
+    name: setupProfiles[0]?.name ?? null,
+    source: "implicit-first"
+  };
+}
+async function resolveSetupProfileSelectionForSession(options) {
+  const manifest = await loadManifest(options.projectRoot);
+  return resolveSetupProfileSelection({
+    manifest,
+    requestedSetupProfileId: options.requestedSetupProfileId
+  });
+}
+
+// src/utils/session-game-source.ts
+function projectIdFromSessionGameSource(source) {
+  if (source.kind === "USER_COMPILED") {
+    return source.projectId;
+  }
+  return `demo:${source.slug}:${source.revisionId}`;
+}
+
+// src/services/testing/reducer-native-test-harness.ts
+globalThis.__DREAMBOARD_AUTHORING_WARNINGS__ = true;
+var GENERATED_TESTING_TYPES_PREFIX = "// Generated by dreamboard";
+var TESTING_TYPES_STUB = "export function defineScenario(scenario) { return scenario; }\n";
+var BASE_SUFFIX = ".base.ts";
+var SCENARIO_SUFFIX = ".scenario.ts";
+var SDK_UI_RUNTIME_EXTERNALS = [
+  "@radix-ui/react-accordion",
+  "@radix-ui/react-dialog",
+  "@radix-ui/react-label",
+  "@radix-ui/react-select",
+  "@radix-ui/react-slot",
+  "@radix-ui/react-tooltip",
+  "@use-gesture/react",
+  "clsx",
+  "framer-motion",
+  "lucide-react",
+  "react",
+  "react-dom",
+  "vaul"
+];
+function formatScenarioErrorForDisplay(options) {
+  const message = options.error.message || "Scenario failed.";
+  const scenarioFrame = findScenarioStackFrame({
+    stack: options.error.stack,
+    projectRoot: options.projectRoot,
+    scenarioFilePath: options.scenarioFilePath
+  });
+  return scenarioFrame ? `${message}
+${scenarioFrame}` : message;
+}
+function findScenarioStackFrame(options) {
+  if (!options.stack) {
+    return null;
+  }
+  const absolutePath = path3.resolve(options.scenarioFilePath);
+  const relativePath = path3.relative(options.projectRoot, absolutePath);
+  const normalizedRelativePath = relativePath.split(path3.sep).join("/");
+  const escapedAbsolutePath = escapeRegExp(absolutePath);
+  const escapedRelativePath = escapeRegExp(normalizedRelativePath);
+  const absoluteFrame = new RegExp(`${escapedAbsolutePath}:(\\d+):(\\d+)`);
+  const relativeFrame = new RegExp(`${escapedRelativePath}:(\\d+):(\\d+)`);
+  for (const line of options.stack.split("\n")) {
+    const normalizedLine = line.split(path3.sep).join("/");
+    const match = normalizedLine.match(absoluteFrame) ?? normalizedLine.match(relativeFrame);
+    if (match?.[1] && match?.[2]) {
+      return `at ${normalizedRelativePath}:${match[1]}:${match[2]}`;
+    }
+  }
+  return null;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var projectReducerNativeModules = /* @__PURE__ */ new Map();
+function resolveProjectSdkModule(projectRoot, specifier) {
+  const requireFromProject = createRequire(
+    path3.join(projectRoot, "package.json")
+  );
+  return requireFromProject.resolve(specifier);
+}
+async function importProjectSdkModule(projectRoot, specifier) {
+  const modulePath = resolveProjectSdkModule(projectRoot, specifier);
+  return await import(pathToFileURL2(modulePath).href);
+}
+async function loadProjectReducerNativeModules(projectRoot) {
+  const cacheKey = path3.resolve(projectRoot);
+  const cached = projectReducerNativeModules.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const promise = Promise.all([
+    importProjectSdkModule(cacheKey, "@dreamboard-games/sdk/reducer"),
+    importProjectSdkModule(cacheKey, "@dreamboard-games/sdk/reducer-contract"),
+    importProjectSdkModule(
+      cacheKey,
+      "@dreamboard-games/sdk/testing"
+    )
+  ]).then(([reducerModule, reducerContractModule, testingModule]) => {
+    if (typeof reducerModule.createReducerBundle !== "function" || typeof reducerModule.contractFingerprint !== "function" || typeof reducerContractModule.materializeManifestTable !== "function" || typeof testingModule.createExpectApi !== "function") {
+      throw new Error(
+        "Installed @dreamboard-games/sdk does not expose the reducer-native test helpers required by this CLI."
+      );
+    }
+    return {
+      createReducerBundle: reducerModule.createReducerBundle,
+      contractFingerprint: reducerModule.contractFingerprint,
+      materializeManifestTable: reducerContractModule.materializeManifestTable,
+      createExpectApi: testingModule.createExpectApi
+    };
+  });
+  projectReducerNativeModules.set(cacheKey, promise);
+  return promise;
+}
+function createSubmissionError(errorCode, message, fallbackMessage) {
+  const error = new Error(message ?? fallbackMessage);
+  error.name = "SubmissionError";
+  error.errorCode = errorCode;
+  return error;
+}
+function deepEqual(left, right) {
+  return isDeepStrictEqual(left, right);
+}
+function shouldRefreshReducerTestingTypes(existingContent) {
+  if (existingContent === null || existingContent.trim().length === 0 || existingContent === TESTING_TYPES_STUB || existingContent.startsWith(GENERATED_TESTING_TYPES_PREFIX)) {
+    return true;
+  }
+  return false;
+}
+async function discoverFiles(root, suffix) {
+  if (!await exists(root)) {
+    return [];
+  }
+  const entries = await readdir(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path3.join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await discoverFiles(entryPath, suffix));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(suffix)) {
+      files.push(entryPath);
+    }
+  }
+  files.sort();
+  return files;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function parseTypedBaseDefinition(value) {
+  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string" || !("setup" in value) || !isFunction(value.setup)) {
+    throw new Error("Invalid reducer-native base definition.");
+  }
+  const parentBaseId = "extends" in value && typeof value.extends === "string" ? value.extends : void 0;
+  const seed = "seed" in value && typeof value.seed === "number" ? value.seed : void 0;
+  const players = "players" in value && typeof value.players === "number" ? value.players : void 0;
+  if ((seed === void 0 || players === void 0) && !parentBaseId) {
+    throw new Error(
+      "Invalid reducer-native base definition. Base definitions without --extends must declare numeric seed and players."
+    );
+  }
+  const setupProfileId = "setupProfileId" in value && typeof value.setupProfileId === "string" ? value.setupProfileId : void 0;
+  return {
+    ...value,
+    seed,
+    players,
+    setupProfileId,
+    extends: parentBaseId
+  };
+}
+function parseTypedScenarioDefinition(value) {
+  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string" || !("from" in value) || typeof value.from !== "string" || !("when" in value) || !isFunction(value.when) || !("then" in value) || !isFunction(value.then)) {
+    throw new Error("Invalid reducer-native scenario definition.");
+  }
+  const phase = "phase" in value && typeof value.phase === "string" ? value.phase : void 0;
+  const stage = "stage" in value && typeof value.stage === "string" ? value.stage : void 0;
+  return {
+    ...value,
+    phase,
+    stage
+  };
+}
+async function isReducerNativeTestingWorkspace(projectRoot) {
+  return await exists(path3.join(projectRoot, "app", "game.ts")) && await exists(
+    path3.join(projectRoot, "shared", "generated", "ui-contract.ts")
+  );
+}
+async function ensureReducerNativeTestingFiles(projectRoot) {
+  const testingTypesPath = "test/testing-types.ts";
+  const testingContractPath = "test/generated/testing-contract.ts";
+  const baseStatesPath = "test/generated/base-states.generated.ts";
+  const baseStatesDtsPath = "test/generated/base-states.generated.d.ts";
+  const scenarioManifestPath = "test/generated/scenario-manifest.generated.ts";
+  await ensureDir(resolveWorkspacePath(projectRoot, "test"));
+  await ensureDir(resolveWorkspacePath(projectRoot, "test/generated"));
+  const existingTestingTypes = await readWorkspaceTextFileIfExists(
+    projectRoot,
+    testingTypesPath
+  );
+  if (shouldRefreshReducerTestingTypes(existingTestingTypes)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
+      testingTypesPath,
+      REDUCER_TESTING_TYPES_WRAPPER_CONTENT
+    );
+  }
+  const rejectionCodes = await collectKnownRejectionCodes(projectRoot);
+  await writeWorkspaceTextFile(
+    projectRoot,
+    testingContractPath,
+    buildReducerTestingContractContent({ rejectionCodes })
+  );
+  const header = "// Generated by dreamboard test. Do not edit by hand.\n";
+  if (!await workspacePathExists(projectRoot, baseStatesPath)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
+      baseStatesPath,
+      `${header}export const BASE_STATES = {} as const;
+export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
+`
+    );
+  } else {
+    const existingBaseStates = await readWorkspaceTextFileIfExists(
+      projectRoot,
+      baseStatesPath
+    );
+    if (existingBaseStates && !existingBaseStates.includes("BASE_STATES_CONTRACT_FINGERPRINT")) {
+      await writeWorkspaceTextFile(
+        projectRoot,
+        baseStatesPath,
+        `${existingBaseStates.trimEnd()}
+export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
+`
+      );
+    }
+  }
+  if (!await workspacePathExists(projectRoot, baseStatesDtsPath)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
+      baseStatesDtsPath,
+      `${header}export declare const BASE_STATES: Record<string, unknown>;
+export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
+`
+    );
+  } else {
+    const existingBaseStatesDts = await readWorkspaceTextFileIfExists(
+      projectRoot,
+      baseStatesDtsPath
+    );
+    if (existingBaseStatesDts && !existingBaseStatesDts.includes("BASE_STATES_CONTRACT_FINGERPRINT")) {
+      await writeWorkspaceTextFile(
+        projectRoot,
+        baseStatesDtsPath,
+        `${existingBaseStatesDts.trimEnd()}
+export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
+`
+      );
+    }
+  }
+  if (!await workspacePathExists(projectRoot, scenarioManifestPath)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
+      scenarioManifestPath,
+      `${header}export const SCENARIO_MANIFEST = [] as const;
+`
+    );
+  }
+}
+var DEFAULT_REJECTION_CODES = [
+  "NOT_YOUR_TURN",
+  "action-unavailable",
+  "invalid-action-params",
+  "prompt-not-owned"
+];
+async function collectKnownRejectionCodes(projectRoot) {
+  const knownCodes = new Set(DEFAULT_REJECTION_CODES);
+  const gamePath = path3.join(projectRoot, "app", "game.ts");
+  if (!await exists(gamePath)) {
+    return Array.from(knownCodes).sort(
+      (left, right) => left.localeCompare(right)
+    );
+  }
+  try {
+    const module = await importTypeScriptModule(gamePath);
+    const phases = module.default?.phases ?? {};
+    for (const phase of Object.values(phases)) {
+      const interactions = phase.interactions ?? {};
+      for (const interaction of Object.values(interactions)) {
+        for (const errorCode of interaction.errorCodes ?? []) {
+          if (typeof errorCode === "string" && errorCode.length > 0) {
+            knownCodes.add(errorCode);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return Array.from(knownCodes).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+async function loadTypedBases(projectRoot) {
+  const baseFiles = await discoverFiles(
+    resolveWorkspacePath(projectRoot, "test/bases"),
+    BASE_SUFFIX
+  );
+  const loaded = [];
+  for (const filePath of baseFiles) {
+    const externals = reducerNativeTestHelperExternals(projectRoot, filePath);
+    const [module, bundledText] = await Promise.all([
+      importTypeScriptModule(filePath),
+      bundleTypeScriptModuleText(filePath, { external: externals })
+    ]);
+    loaded.push({
+      filePath,
+      definition: parseTypedBaseDefinition(module.default),
+      bundleHash: hashContent(bundledText)
+    });
+  }
+  return loaded;
+}
+async function loadTypedScenarios(projectRoot, options) {
+  const scenarioFiles = options.scenarioPath ? [resolveWorkspacePath(projectRoot, options.scenarioPath)] : await discoverFiles(
+    resolveWorkspacePath(projectRoot, "test/scenarios"),
+    SCENARIO_SUFFIX
+  );
+  const loaded = [];
+  for (const filePath of scenarioFiles) {
+    const externals = reducerNativeTestHelperExternals(projectRoot, filePath);
+    const [module, bundledText] = await Promise.all([
+      importTypeScriptModule(filePath),
+      bundleTypeScriptModuleText(filePath, { external: externals })
+    ]);
+    loaded.push({
+      filePath,
+      definition: parseTypedScenarioDefinition(module.default),
+      bundleHash: hashContent(bundledText)
+    });
+  }
+  return loaded;
+}
+function reducerNativeTestHelperExternals(projectRoot, filePath) {
+  const testingTypesPath = path3.join(projectRoot, "test", "testing-types");
+  const relative = path3.relative(path3.dirname(filePath), testingTypesPath).replaceAll("\\", "/");
+  const specifier = relative.startsWith(".") ? relative : `./${relative}`;
+  return [specifier, `${specifier}.ts`, ...SDK_UI_RUNTIME_EXTERNALS];
+}
+var JS_MAX_SAFE_INTEGER = 9007199254740991n;
+var JS_MIN_SAFE_INTEGER = -JS_MAX_SAFE_INTEGER;
+var JS_MAX_SAFE_INTEGER_EXCLUSIVE = JS_MAX_SAFE_INTEGER + 1n;
+var KotlinSeededRandom = class {
+  x;
+  y;
+  z;
+  w;
+  v;
+  addend;
+  constructor(seed) {
+    const seedBig = BigInt.asIntN(64, BigInt(Math.trunc(seed)));
+    const seed1 = Number(BigInt.asIntN(32, seedBig));
+    const seed2 = Number(BigInt.asIntN(32, seedBig >> 32n));
+    this.x = seed1 | 0;
+    this.y = seed2 | 0;
+    this.z = 0;
+    this.w = 0;
+    this.v = ~seed1;
+    this.addend = seed1 << 10 ^ seed2 >>> 4 | 0;
+    if ((this.x | this.y | this.z | this.w | this.v) === 0) {
+      throw new Error(
+        "Kotlin random seed must initialize at least one state word."
+      );
+    }
+    for (let index = 0; index < 64; index += 1) {
+      this.nextInt();
+    }
+  }
+  nextInt() {
+    let next = this.x | 0;
+    next ^= next >>> 2;
+    this.x = this.y;
+    this.y = this.z;
+    this.z = this.w;
+    const currentV = this.v | 0;
+    this.w = currentV;
+    next = next ^ next << 1 ^ currentV ^ currentV << 4 | 0;
+    this.v = next;
+    this.addend = this.addend + 362437 | 0;
+    return next + this.addend | 0;
+  }
+  nextBits(bitCount) {
+    if (bitCount <= 0) {
+      return 0;
+    }
+    return this.nextInt() >>> 32 - bitCount;
+  }
+  nextIntBound(bound) {
+    if (bound <= 0) {
+      throw new Error("bound must be positive");
+    }
+    if ((bound & -bound) === bound) {
+      const bitCount = 31 - Math.clz32(bound);
+      return this.nextBits(bitCount);
+    }
+    let value;
+    while (true) {
+      const bits = this.nextInt() >>> 1;
+      value = bits % bound;
+      if (bits - value + (bound - 1) >= 0) {
+        return value;
+      }
+    }
+  }
+  nextLong() {
+    return Number(this.nextLongBigInt());
+  }
+  nextLongBigInt() {
+    const high = BigInt(this.nextInt());
+    const low = BigInt(this.nextInt());
+    return BigInt.asIntN(64, (high << 32n) + low);
+  }
+  nextReducerRuntimeSeed() {
+    return Number(
+      this.nextLongRange(JS_MIN_SAFE_INTEGER, JS_MAX_SAFE_INTEGER_EXCLUSIVE)
+    );
+  }
+  nextLongRange(from, until) {
+    if (until <= from) {
+      throw new Error("until must be greater than from");
+    }
+    const bound = until - from;
+    const mask = bound - 1n;
+    if ((bound & mask) === 0n) {
+      return from + (BigInt.asUintN(64, this.nextLongBigInt()) & mask);
+    }
+    while (true) {
+      const bits = BigInt.asUintN(64, this.nextLongBigInt()) >> 1n;
+      const value = bits % bound;
+      if (BigInt.asIntN(64, bits + mask - value) >= 0n) {
+        return from + value;
+      }
+    }
+  }
+};
+function shuffleWithKotlinRandom(values, random) {
+  const next = [...values];
+  for (let index = next.length - 1; index > 0; index -= 1) {
+    const swapIndex = random.nextIntBound(index + 1);
+    const current = next[index];
+    next[index] = next[swapIndex];
+    next[swapIndex] = current;
+  }
+  return next;
+}
+function resolveEffectiveBaseSetup(options) {
+  const inheritedSetupProfileId = options.base.setupProfileId ?? (options.base.extends && options.basesById ? resolveEffectiveBaseSetup({
+    manifest: options.manifest,
+    base: options.basesById.get(options.base.extends)?.definition ?? (() => {
+      throw new Error(
+        `Base '${options.base.id}' extends unknown parent '${options.base.extends}'.`
+      );
+    })(),
+    basesById: options.basesById
+  }).setupProfileId : void 0);
+  const selection = resolveSetupProfileSelection({
+    manifest: options.manifest,
+    requestedSetupProfileId: inheritedSetupProfileId ?? void 0
+  });
+  return {
+    setupProfileId: selection.id
+  };
+}
+function resolveBaseDefinition(base, basesById) {
+  const inherited = base.definition.extends !== void 0 ? resolveBaseDefinition(
+    basesById.get(base.definition.extends) ?? (() => {
+      throw new Error(
+        `Base '${base.definition.id}' extends unknown parent '${base.definition.extends}'.`
+      );
+    })(),
+    basesById
+  ) : null;
+  const seed = base.definition.seed ?? inherited?.seed;
+  const players = base.definition.players ?? inherited?.players;
+  if (seed === void 0 || players === void 0) {
+    throw new Error(
+      `Base '${base.definition.id}' must resolve numeric seed and players.`
+    );
+  }
+  return {
+    ...base.definition,
+    seed,
+    players,
+    setupProfileId: base.definition.setupProfileId ?? inherited?.setupProfileId ?? void 0
+  };
+}
+function summarizeTableValidationError(manifest, error) {
+  const issues = error.message.split("; ").map((issue) => issue.trim()).filter((issue) => issue.length > 0);
+  if (issues.length === 0 || !issues.every((issue) => issue.startsWith("table"))) {
+    return error.message;
+  }
+  const boardBaseIdByRuntimeId = new Map(
+    (manifest.boards ?? []).flatMap(
+      (board) => board.scope === "perPlayer" ? Array.from(
+        { length: manifest.players.maxPlayers },
+        (_, index) => [`${board.id}:player-${index + 1}`, board.id]
+      ) : [[board.id, board.id]]
+    )
+  );
+  const representativeIssues = issues.slice(0, 3).map((issue) => {
+    const [, runtimeBoardId = ""] = issue.match(/^table\.boards\.byId\.([^.]+)\./) ?? [];
+    const boardBaseId = boardBaseIdByRuntimeId.get(runtimeBoardId);
+    if (!boardBaseId) {
+      return `- ${issue.replace(/^table\./, "")}`;
+    }
+    const boardSpecificPath = issue.replace(/^table\.boards\.byId\.[^.]+\./, "").replace(/^table\./, "");
+    return `- board '${boardBaseId}' (${runtimeBoardId}): ${boardSpecificPath}`;
+  });
+  return [
+    `Reducer-native table validation failed with ${issues.length} issue${issues.length === 1 ? "" : "s"}.`,
+    "Likely root cause: the generated test table shape does not match the authored manifest topology.",
+    ...representativeIssues,
+    "Pass --debug for the full validation dump."
+  ].join("\n");
+}
+var ShadowReducerRuntime = class {
+  constructor(modules, manifest, gameModuleDefault, createInitialTable, seed, players, setupProfileId, debug = false) {
+    this.modules = modules;
+    this.manifest = manifest;
+    this.gameModuleDefault = gameModuleDefault;
+    this.createInitialTable = createInitialTable;
+    this.seed = seed;
+    this.players = players;
+    this.setupProfileId = setupProfileId;
+    this.debug = debug;
+    if (typeof gameModuleDefault !== "object" || gameModuleDefault === null || !("contract" in gameModuleDefault)) {
+      throw new Error(
+        "app/game.ts must export a reducer-native project definition."
+      );
+    }
+    this.bundle = this.modules.createReducerBundle(gameModuleDefault);
+    this.runtime = this.bundle.createInProcessRuntime();
+    this.playerIds = Array.from(
+      { length: players },
+      (_, index) => `player-${index + 1}`
+    );
+  }
+  bundle;
+  runtime;
+  playerIds;
+  historyRecords = [];
+  version = 0;
+  started = false;
+  async start() {
+    if (this.started) {
+      return;
+    }
+    const random = new KotlinSeededRandom(this.seed);
+    const shuffleItems = (values) => shuffleWithKotlinRandom(values, random);
+    const table = JSON.parse(
+      JSON.stringify(
+        this.createInitialTable?.({
+          playerIds: this.playerIds,
+          shuffleItems
+        }) ?? this.modules.materializeManifestTable({
+          manifest: this.manifest,
+          playerIds: this.playerIds,
+          shuffleItems
+        })
+      )
+    );
+    const rngSeed = random.nextReducerRuntimeSeed();
+    try {
+      await this.runtime.initialize({
+        table,
+        playerIds: this.playerIds,
+        rngSeed,
+        setup: this.setupProfileId ? {
+          profileId: this.setupProfileId
+        } : null
+      });
+    } catch (error) {
+      if (!this.debug && error instanceof Error) {
+        throw new Error(summarizeTableValidationError(this.manifest, error));
+      }
+      throw error;
+    }
+    this.version = 0;
+    this.started = true;
+  }
+  phase() {
+    return (this.runtime.unsafeState()?.domain?.flow?.currentPhase ?? null) || "";
+  }
+  playerOrder() {
+    return this.playerIds;
+  }
+  rawState() {
+    return this.runtime.snapshot();
+  }
+  currentVersion() {
+    return this.version;
+  }
+  hydrate(snapshot, version = 0) {
+    this.runtime.hydrate({ state: structuredClone(snapshot) });
+    this.version = version;
+    this.started = true;
+  }
+  patchState(mutator) {
+    const next = structuredClone(this.rawState());
+    mutator(next);
+    this.hydrate(next, this.version + 1);
+  }
+  projectAllSeats() {
+    const projection = this.runtime.projectSeatsDynamic({
+      playerIds: this.playerIds
+    });
+    const interactionsByRef = projection.interactionsByRef && typeof projection.interactionsByRef === "object" && !Array.isArray(projection.interactionsByRef) ? projection.interactionsByRef : {};
+    const seats = Object.fromEntries(
+      Object.entries(projection.seats ?? {}).map(([playerId, seat]) => {
+        const availableInteractionRefs = Array.isArray(
+          seat.availableInteractionRefs
+        ) ? seat.availableInteractionRefs.filter(
+          (ref) => typeof ref === "string"
+        ) : [];
+        const availableInteractions = seat.availableInteractions ?? availableInteractionRefs.map((ref) => interactionsByRef[ref]).filter(
+          (descriptor) => !!descriptor && typeof descriptor === "object"
+        );
+        return [
+          playerId,
+          {
+            view: seat.view,
+            availableInteractions,
+            zones: seat.zones
+          }
+        ];
+      })
+    );
+    return {
+      currentStage: projection.currentStage ?? null,
+      stageSeats: projection.stageSeats ?? [],
+      seats
+    };
+  }
+  currentStage() {
+    return this.projectAllSeats().currentStage;
+  }
+  view(playerId) {
+    return this.runtime.projectSeatViewDynamic({
+      playerId
+    }) ?? null;
+  }
+  availableInteractionsForPlayer(playerId) {
+    const projection = this.projectAllSeats();
+    const seat = projection.seats[playerId];
+    const descriptors = seat?.availableInteractions ?? [];
+    return descriptors.filter(
+      (descriptor) => !!descriptor && typeof descriptor.interactionId === "string"
+    ).map((descriptor) => descriptor.interactionId);
+  }
+  /**
+   * Phase-kind interaction descriptors (action + prompt) available to
+   * `playerId` in the current phase. Surfaces the same projection the UI
+   * SDK consumes, so scenarios can assert addressee authorization and
+   * availability without reaching into game-specific state. Returned as
+   * loose records — the typed `InteractionDescriptor` shape is narrowed
+   * downstream in the workspace-generated `testing-contract.ts`.
+   */
+  interactionsForPlayer(playerId) {
+    return this.projectAllSeats().seats[playerId]?.availableInteractions ?? [];
+  }
+  explain(playerId, interactionId) {
+    const runtime = this.runtime;
+    if (typeof runtime.explainInteraction !== "function") {
+      throw new Error(
+        "The installed @dreamboard-games/sdk does not expose interaction explanations. Update the workspace SDK pin."
+      );
+    }
+    return runtime.explainInteraction({ playerId, interactionId });
+  }
+  clearHistory() {
+    this.historyRecords.length = 0;
+  }
+  async applyInput(input) {
+    const parsedInput = toReducerInput(input);
+    const result = await this.runtime.dispatch({ input: parsedInput });
+    if (result.kind === "reject") {
+      const record = {
+        input,
+        accepted: false,
+        errorCode: result.errorCode,
+        message: result.message
+      };
+      this.historyRecords.push(record);
+      throw createSubmissionError(
+        result.errorCode,
+        result.message,
+        "Reducer input rejected."
+      );
+    }
+    this.version += 1;
+    this.historyRecords.push({ input, accepted: true });
+  }
+  async submitInteraction(playerId, interactionId, params) {
+    await this.applyInput({
+      kind: "interaction",
+      playerId,
+      interactionId,
+      params
+    });
+  }
+};
+function toReducerInput(input) {
+  return {
+    kind: "interaction",
+    playerId: input.playerId,
+    interactionId: input.interactionId,
+    params: input.params
+  };
+}
+function sanitizeSnapshotSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+function createScenarioSnapshotMatcher(options) {
+  return (filename, actual) => {
+    const suffix = filename ? `.${sanitizeSnapshotSegment(filename)}` : "";
+    const snapshotPath = resolveWorkspacePath(
+      options.projectRoot,
+      `test/generated/snapshots/${sanitizeSnapshotSegment(options.scenarioId)}${suffix}.snapshot.json`
+    );
+    const wrappedValue = {
+      value: actual
+    };
+    const serialized = `${JSON.stringify(wrappedValue, null, 2)}
+`;
+    mkdirSync(path3.dirname(snapshotPath), { recursive: true });
+    if (!existsSync(snapshotPath) || options.updateSnapshots) {
+      writeFileSync(snapshotPath, serialized, "utf8");
+      return;
+    }
+    const previous = JSON.parse(readFileSync(snapshotPath, "utf8"));
+    if (!deepEqual(previous.value, actual)) {
+      throw new Error(
+        `Snapshot mismatch for scenario '${options.scenarioId}'. Re-run with --update-snapshots to refresh ${path3.relative(options.projectRoot, snapshotPath)}.`
+      );
+    }
+  };
+}
+async function createScenarioContext(options) {
+  const api = {
+    start: async () => {
+      await options.shadow.start();
+    },
+    patchState: async (mutator) => {
+      await api.start();
+      if (options.live || options.actionPlan) {
+        throw new Error(
+          "game.patchState is only supported for reducer snapshot scenarios. Use it to materialize a state before --from-scenario or reducer tests, not inside live replay."
+        );
+      }
+      options.shadow.patchState(mutator);
+    },
+    submit: async (playerId, interactionId, params) => {
+      await api.start();
+      const interactionParams = params ?? {};
+      const normalizedInputs = interactionParams && typeof interactionParams === "object" && !Array.isArray(interactionParams) ? interactionParams : {};
+      const previousVersion = options.live ? options.live.version : options.actionPlan ? options.shadow.currentVersion() : 0;
+      if (options.live) {
+        if (!options.live.actionSetVersion) {
+          options.live.actionSetVersion = await fetchLiveActionSetVersion(
+            options.live.sessionId,
+            playerId
+          );
+        }
+        const submittedActionSetVersion = options.live.actionSetVersion;
+        const submitStartedAt = performance.now();
+        const clientActionId = randomUUID3();
+        const { data, error, response } = await submitGameplayAuthorityAction({
+          path: {
+            sessionId: options.live.sessionId,
+            playerId,
+            interactionId
+          },
+          body: {
+            expectedVersion: previousVersion,
+            actionSetVersion: options.live.actionSetVersion,
+            inputs: normalizedInputs
+          },
+          headers: { "X-Dreamboard-Client-Action-Id": clientActionId }
+        });
+        const durationMs = performance.now() - submitStartedAt;
+        options.live.diagnostics?.push({
+          index: options.live.submitIndex ?? 0,
+          playerId,
+          interactionId,
+          inputs: normalizedInputs,
+          expectedVersion: previousVersion,
+          actionSetVersion: submittedActionSetVersion,
+          responseStatus: response?.status,
+          responseBody: options.live.captureResponseBody === false ? void 0 : JSON.stringify(error ?? data ?? null),
+          accepted: data?.accepted ?? void 0,
+          errorCode: data?.accepted === false ? data.errorCode ?? void 0 : error && typeof error === "object" && "detail" in error ? String(error.detail) : void 0,
+          backendTiming: response?.headers?.get("server-timing") ?? response?.headers?.get("x-dreamboard-timing") ?? void 0,
+          durationMs
+        });
+        options.live.submitIndex = (options.live.submitIndex ?? 0) + 1;
+        if (error) {
+          throw createSubmissionError(
+            "api-error",
+            void 0,
+            "Failed to submit interaction"
+          );
+        }
+        if (data?.accepted === false) {
+          const shadowError = await tryShadowSubmit(
+            options.shadow,
+            playerId,
+            interactionId,
+            interactionParams
+          );
+          if (!shadowError || shadowError.errorCode !== data.errorCode) {
+            throw new Error(
+              "Live session rejection diverged from reducer shadow state."
+            );
+          }
+          throw createSubmissionError(
+            data.errorCode ?? void 0,
+            data.message ?? void 0,
+            "Interaction rejected"
+          );
+        }
+        options.live.version = typeof data?.version === "number" ? data.version : previousVersion + 1;
+        options.live.actionSetVersion = data?.actionSetVersion ?? options.live.actionSetVersion;
+      }
+      await options.shadow.submitInteraction(
+        playerId,
+        interactionId,
+        interactionParams
+      );
+      if (options.actionPlan) {
+        options.actionPlan.diagnostics.push({
+          index: options.actionPlan.submitIndex ?? 0,
+          playerId,
+          interactionId,
+          inputs: normalizedInputs,
+          expectedVersion: previousVersion,
+          actionSetVersion: "",
+          accepted: true,
+          durationMs: 0
+        });
+        options.actionPlan.submitIndex = (options.actionPlan.submitIndex ?? 0) + 1;
+      }
+    }
+  };
+  return {
+    game: api,
+    players: () => options.shadow.playerOrder(),
+    seat: (index) => {
+      const order = options.shadow.playerOrder();
+      if (!Number.isInteger(index) || index < 0 || index >= order.length) {
+        throw new Error(
+          `seat(${index}) is out of range; scenario has ${order.length} player(s).`
+        );
+      }
+      return order[index];
+    },
+    state: () => options.shadow.phase(),
+    view: (playerId) => options.shadow.view(playerId),
+    interactions: (playerId) => options.shadow.interactionsForPlayer(playerId),
+    explain: (playerId, interactionId) => options.shadow.explain(playerId, interactionId),
+    expect: options.expect
+  };
+}
+async function tryShadowSubmit(shadow, playerId, interactionId, params) {
+  try {
+    await shadow.submitInteraction(playerId, interactionId, params);
+    throw new Error("Expected shadow interaction to reject.");
+  } catch (error) {
+    if (error instanceof Error && error.name === "SubmissionError") {
+      return error;
+    }
+    throw error;
+  }
+}
+async function createSessionFromScenario(options) {
+  const startedAt = Date.now();
+  const materialized = await materializeScenarioReducerState(options);
+  const reducerHarnessMs = Date.now() - startedAt;
+  const hydrateStartedAt = Date.now();
+  const {
+    data: snapshot,
+    error,
+    response
+  } = await createProjectSessionFromReducerSnapshot({
+    path: { projectId: options.projectId },
+    body: {
+      compiledResultId: options.compiledResultId,
+      seed: materialized.seed,
+      playerCount: materialized.playerCount,
+      setupProfileId: materialized.setupProfileId ?? void 0,
+      baseId: materialized.baseId,
+      scenarioId: materialized.scenarioId,
+      reducerState: materialized.reducerState,
+      reducerStateVersion: materialized.reducerStateVersion,
+      fingerprintMetadata: materialized.fingerprintMetadata
+    }
+  });
+  const backendHydrateMs = Date.now() - hydrateStartedAt;
+  if (error || !snapshot) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      `Failed to materialize scenario '${options.scenarioId}' from reducer snapshot`
+    );
+  }
+  return {
+    sessionId: snapshot.context.sessionId,
+    shortCode: snapshot.context.shortCode,
+    projectId: projectIdFromSessionGameSource(snapshot.context.gameSource),
+    seed: materialized.seed,
+    playerCount: materialized.playerCount,
+    setupProfileId: materialized.setupProfileId,
+    scenarioId: materialized.scenarioId,
+    phase: materialized.phase,
+    stage: materialized.stage,
+    materialization: {
+      mode: "snapshot",
+      totalMs: Date.now() - startedAt,
+      reducerHarnessMs,
+      backendHydrateMs
+    }
+  };
+}
+var MATERIALIZED_SCENARIO_CACHE_VERSION = 1;
+function materializedScenarioCachePath(options) {
+  return [
+    PROJECT_DIR_NAME,
+    "dev",
+    "scenario-cache",
+    `${sanitizeSnapshotSegment(options.baseId)}.${sanitizeSnapshotSegment(
+      options.scenarioId
+    )}.${options.fingerprintHash}.json`
+  ].join("/");
+}
+function materializedScenarioCacheFilePath(options) {
+  return resolveWorkspacePath(
+    options.projectRoot,
+    materializedScenarioCachePath(options)
+  );
+}
+async function readMaterializedScenarioCache(options) {
+  const text = await readWorkspaceTextFileIfExists(
+    options.projectRoot,
+    materializedScenarioCachePath(options)
+  );
+  if (!text) return null;
+  try {
+    const payload = JSON.parse(
+      text
+    );
+    if (payload.cacheVersion !== MATERIALIZED_SCENARIO_CACHE_VERSION || payload.fingerprintHash !== options.fingerprintHash || !payload.materialized) {
+      return null;
+    }
+    return payload.materialized;
+  } catch {
+    return null;
+  }
+}
+async function writeMaterializedScenarioCache(options) {
+  const cachePath = materializedScenarioCacheFilePath(options);
+  await ensureDir(path3.dirname(cachePath));
+  await writeWorkspaceJsonFile(
+    options.projectRoot,
+    materializedScenarioCachePath(options),
+    {
+      cacheVersion: MATERIALIZED_SCENARIO_CACHE_VERSION,
+      fingerprintHash: options.fingerprintHash,
+      materialized: options.materialized
+    }
+  );
+}
+async function materializeScenarioReducerState(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  let preloadedGeneratedBaseStates;
+  if (options.trustGeneratedFingerprint === true) {
+    const [generatedBaseStates2, scenarioManifest] = await Promise.all([
+      loadGeneratedBaseStates(options.projectRoot),
+      loadGeneratedScenarioManifest(options.projectRoot)
+    ]);
+    preloadedGeneratedBaseStates = generatedBaseStates2;
+    const scenarioEntry = scenarioManifest.find(
+      (entry) => entry.id === options.scenarioId
+    );
+    const generatedBase2 = scenarioEntry ? generatedBaseStates2?.[baseStateKey(scenarioEntry.base)] : null;
+    if (generatedBase2 && generatedBase2.fingerprint.compiledResultId === options.compiledResultId && generatedBase2.fingerprint.projectId === options.projectId) {
+      const cached2 = await readMaterializedScenarioCache({
+        projectRoot: options.projectRoot,
+        baseId: scenarioEntry.base,
+        scenarioId: options.scenarioId,
+        fingerprintHash: fingerprintHash(generatedBase2.fingerprint)
+      });
+      if (cached2) {
+        return cached2;
+      }
+    }
+  }
+  const [bases, scenarios, generatedBaseStates, manifest] = await Promise.all([
+    loadTypedBases(options.projectRoot),
+    loadTypedScenarios(options.projectRoot, {}),
+    preloadedGeneratedBaseStates === void 0 ? loadGeneratedBaseStates(options.projectRoot) : Promise.resolve(preloadedGeneratedBaseStates),
+    loadManifest(options.projectRoot)
+  ]);
+  const matchingScenarios = scenarios.filter(
+    (scenario2) => scenario2.definition.id === options.scenarioId
+  );
+  if (matchingScenarios.length === 0) {
+    throw new Error(
+      `Unknown scenario '${options.scenarioId}'. Available scenarios: ${scenarios.map((scenario2) => scenario2.definition.id).sort().join(", ")}`
+    );
+  }
+  if (matchingScenarios.length > 1) {
+    throw new Error(
+      `Scenario id '${options.scenarioId}' is defined more than once. Keep one scenario per file and one unique id per workspace.`
+    );
+  }
+  const scenario = matchingScenarios[0];
+  const basesById = new Map(bases.map((base2) => [base2.definition.id, base2]));
+  validateTypedScenarioBases([scenario], basesById);
+  const base = basesById.get(scenario.definition.from);
+  if (!base) {
+    throw new Error(
+      `Missing typed base '${scenario.definition.from}' for scenario '${scenario.definition.id}'.`
+    );
+  }
+  const generatedBase = generatedBaseStates?.[baseStateKey(base.definition.id)];
+  if (!generatedBase) {
+    throw new Error(
+      `Missing generated base artifact for '${base.definition.id}'. Run 'dreamboard test' before using --from-scenario.`
+    );
+  }
+  if (typeof generatedBase.version !== "number") {
+    throw new Error(
+      `Generated base artifact for '${base.definition.id}' is stale. Run 'dreamboard test' before using --from-scenario.`
+    );
+  }
+  const canTrustGeneratedFingerprint = options.trustGeneratedFingerprint === true && generatedBase.fingerprint.compiledResultId === options.compiledResultId && generatedBase.fingerprint.projectId === options.projectId;
+  const current = canTrustGeneratedFingerprint ? generatedBase.fingerprint : await currentFingerprint({
+    projectRoot: options.projectRoot,
+    base,
+    basesById,
+    compiledResultId: options.compiledResultId,
+    projectId: options.projectId
+  });
+  if (!canTrustGeneratedFingerprint) {
+    validateGeneratedFingerprint({
+      generated: generatedBase.fingerprint,
+      current
+    });
+  }
+  const currentHash = fingerprintHash(current);
+  const cached = await readMaterializedScenarioCache({
+    projectRoot: options.projectRoot,
+    baseId: base.definition.id,
+    scenarioId: scenario.definition.id,
+    fingerprintHash: currentHash
+  });
+  if (cached) {
+    return cached;
+  }
+  const [gameModule, manifestContractModule, modules] = await Promise.all([
+    importTypeScriptModule(
+      path3.join(options.projectRoot, "app", "game.ts")
+    ),
+    importTypeScriptModule(
+      path3.join(options.projectRoot, "shared", "manifest-contract.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
+  ]);
+  const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
+  const resolvedBase = resolveBaseDefinition(base, basesById);
+  const effectiveSetup = resolveEffectiveBaseSetup({
+    manifest,
+    base: base.definition,
+    basesById
+  });
+  const shadow = new ShadowReducerRuntime(
+    modules,
+    manifest,
+    gameModule.default,
+    createInitialTable,
+    resolvedBase.seed,
+    resolvedBase.players,
+    effectiveSetup.setupProfileId,
+    options.debug ?? false
+  );
+  shadow.hydrate(generatedBase.snapshot, generatedBase.version);
+  const context = await createScenarioContext({
+    shadow,
+    expect: modules.createExpectApi()
+  });
+  shadow.clearHistory();
+  await scenario.definition.when(context);
+  if (scenario.definition.phase && shadow.phase() !== scenario.definition.phase) {
+    throw new Error(
+      `Scenario '${scenario.definition.id}' expected phase '${scenario.definition.phase}' but reached '${shadow.phase()}'.`
+    );
+  }
+  if (scenario.definition.stage && shadow.currentStage() !== scenario.definition.stage) {
+    throw new Error(
+      `Scenario '${scenario.definition.id}' expected stage '${scenario.definition.stage}' but reached '${shadow.currentStage() ?? "null"}'.`
+    );
+  }
+  const materialized = {
+    baseId: base.definition.id,
+    scenarioId: scenario.definition.id,
+    seed: resolvedBase.seed,
+    playerCount: resolvedBase.players,
+    setupProfileId: effectiveSetup.setupProfileId,
+    reducerState: shadow.rawState(),
+    reducerStateVersion: shadow.currentVersion(),
+    fingerprintMetadata: {
+      baseFingerprintHash: fingerprintHash(generatedBase.fingerprint),
+      currentFingerprintHash: fingerprintHash(current),
+      baseBundleHash: generatedBase.fingerprint.baseBundleHash,
+      manifestHash: generatedBase.fingerprint.manifestHash,
+      appBundleHash: generatedBase.fingerprint.appBundleHash,
+      uiContractHash: generatedBase.fingerprint.uiContractHash,
+      baseId: base.definition.id,
+      scenarioId: scenario.definition.id
+    },
+    phase: shadow.phase(),
+    stage: shadow.currentStage()
+  };
+  await writeMaterializedScenarioCache({
+    projectRoot: options.projectRoot,
+    baseId: base.definition.id,
+    scenarioId: scenario.definition.id,
+    fingerprintHash: currentHash,
+    materialized
+  });
+  return materialized;
+}
+async function fetchLiveActionSetVersion(sessionId, playerId) {
+  const { data, error, response } = await getSessionSnapshot({
+    path: { sessionId },
+    query: { playerId }
+  });
+  if (error || !data || data.type !== "gameplay") {
+    throw toDreamboardApiError(
+      error ?? { detail: "Gameplay snapshot was unavailable." },
+      response,
+      "Failed to read live gameplay action set version"
+    );
+  }
+  return data.gameplay.actionSetVersion;
+}
+function baseStateKey(baseId) {
+  return baseId;
+}
+function fingerprintHash(fingerprint) {
+  return hashContent(JSON.stringify(fingerprint));
+}
+function sortBasesForArtifacts(bases, basesById) {
+  const ordered = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (base) => {
+    if (visited.has(base.definition.id)) {
+      return;
+    }
+    if (visiting.has(base.definition.id)) {
+      throw new Error(
+        `Cyclic reducer-native base inheritance detected at '${base.definition.id}'.`
+      );
+    }
+    visiting.add(base.definition.id);
+    if (base.definition.extends) {
+      const parent = basesById.get(base.definition.extends);
+      if (!parent) {
+        throw new Error(
+          `Base '${base.definition.id}' extends unknown parent '${base.definition.extends}'.`
+        );
+      }
+      visit(parent);
+    }
+    visiting.delete(base.definition.id);
+    visited.add(base.definition.id);
+    ordered.push(base);
+  };
+  for (const base of bases) {
+    visit(base);
+  }
+  return ordered;
+}
+function writeProjectionSnapshots(options) {
+  const projectionDir = resolveWorkspacePath(
+    options.projectRoot,
+    `test/generated/bases/${sanitizeSnapshotSegment(options.baseId)}`
+  );
+  rmSync(projectionDir, { recursive: true, force: true });
+  mkdirSync(projectionDir, { recursive: true });
+  const projection = options.shadow.projectAllSeats();
+  for (const [playerId, seatProjection] of Object.entries(projection.seats)) {
+    const outputPath = resolveWorkspacePath(
+      options.projectRoot,
+      `test/generated/bases/${sanitizeSnapshotSegment(options.baseId)}/${sanitizeSnapshotSegment(playerId)}.projection.json`
+    );
+    writeFileSync(
+      outputPath,
+      `${JSON.stringify(
+        {
+          currentStage: projection.currentStage,
+          stageSeats: projection.stageSeats,
+          ...seatProjection
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+  }
+}
+function validateTypedScenarioBases(scenarios, basesById) {
+  const available = new Set(basesById.keys());
+  const invalid = scenarios.filter((scenario) => !available.has(scenario.definition.from)).map(
+    (scenario) => path3.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.definition.from}'`
+  );
+  if (invalid.length > 0) {
+    throw new Error(
+      `Unknown scenario base(s): ${invalid.join(", ")}. Available bases: ${Array.from(available).sort().join(", ")}`
+    );
+  }
+}
+async function writeReducerNativeGeneratedFiles(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  const manifest = await loadManifest(options.projectRoot);
+  const manifestHash = hashContent(JSON.stringify(manifest));
+  const appBundleHash = hashContent(
+    await bundleTypeScriptModuleText(
+      path3.join(options.projectRoot, "app", "game.ts")
+    )
+  );
+  const uiContractHash = hashContent(
+    await bundleTypeScriptModuleText(
+      path3.join(options.projectRoot, "shared", "generated", "ui-contract.ts"),
+      { external: SDK_UI_RUNTIME_EXTERNALS }
+    )
+  );
+  const generatedDir = resolveWorkspacePath(
+    options.projectRoot,
+    "test/generated"
+  );
+  await ensureDir(generatedDir);
+  const baseStates = {};
+  const [gameModule, manifestContractModule, modules] = await Promise.all([
+    importTypeScriptModule(
+      path3.join(options.projectRoot, "app", "game.ts")
+    ),
+    importTypeScriptModule(
+      path3.join(options.projectRoot, "shared", "manifest-contract.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
+  ]);
+  const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
+  const contractFingerprintValue = modules.contractFingerprint(
+    gameModule.default
+  ).value;
+  const basesById = new Map(
+    options.bases.map((base) => [base.definition.id, base])
+  );
+  for (const base of sortBasesForArtifacts(options.bases, basesById)) {
+    const resolvedBase = resolveBaseDefinition(base, basesById);
+    const effectiveSetup = resolveEffectiveBaseSetup({
+      manifest,
+      base: base.definition,
+      basesById
+    });
+    const shadow = new ShadowReducerRuntime(
+      modules,
+      manifest,
+      gameModule.default,
+      createInitialTable,
+      resolvedBase.seed,
+      resolvedBase.players,
+      effectiveSetup.setupProfileId,
+      options.debug ?? false
+    );
+    let parentFingerprintHash = null;
+    if (base.definition.extends) {
+      const parentArtifact = baseStates[baseStateKey(base.definition.extends)];
+      if (!parentArtifact) {
+        throw new Error(
+          `Base '${base.definition.id}' extends '${base.definition.extends}', but the parent artifact does not exist yet.`
+        );
+      }
+      if (parentArtifact.fingerprint.seed !== resolvedBase.seed) {
+        throw new Error(
+          `Base '${base.definition.id}' extends '${base.definition.extends}' but changes seed from ${parentArtifact.fingerprint.seed} to ${resolvedBase.seed}.`
+        );
+      }
+      if (parentArtifact.fingerprint.players !== resolvedBase.players) {
+        throw new Error(
+          `Base '${base.definition.id}' extends '${base.definition.extends}' but changes players from ${parentArtifact.fingerprint.players} to ${resolvedBase.players}.`
+        );
+      }
+      if ((parentArtifact.fingerprint.setupProfileId ?? null) !== (effectiveSetup.setupProfileId ?? null)) {
+        throw new Error(
+          `Base '${base.definition.id}' extends '${base.definition.extends}' but changes setup profile from ${parentArtifact.fingerprint.setupProfileId ?? "none"} to ${effectiveSetup.setupProfileId ?? "none"}.`
+        );
+      }
+      parentFingerprintHash = fingerprintHash(parentArtifact.fingerprint);
+      shadow.hydrate(parentArtifact.snapshot, parentArtifact.version);
+    }
+    const context = await createScenarioContext({
+      shadow,
+      expect: modules.createExpectApi()
+    });
+    await context.game.start();
+    try {
+      await base.definition.setup({
+        game: context.game,
+        players: context.players,
+        seat: context.seat
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Base '${base.definition.id}' setup failed with setupProfileId '${effectiveSetup.setupProfileId ?? "none"}': ${message}`,
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+    baseStates[baseStateKey(base.definition.id)] = {
+      key: baseStateKey(base.definition.id),
+      base: base.definition.id,
+      snapshot: shadow.rawState(),
+      version: shadow.currentVersion(),
+      fingerprint: {
+        base: base.definition.id,
+        seed: resolvedBase.seed,
+        players: resolvedBase.players,
+        baseBundleHash: base.bundleHash,
+        manifestHash,
+        appBundleHash,
+        uiContractHash,
+        setupProfileId: effectiveSetup.setupProfileId,
+        compiledResultId: options.compiledResultId,
+        projectId: options.projectId,
+        parentBaseId: base.definition.extends ?? null,
+        parentFingerprintHash,
+        contractFingerprint: contractFingerprintValue
+      }
+    };
+    writeProjectionSnapshots({
+      projectRoot: options.projectRoot,
+      baseId: base.definition.id,
+      shadow
+    });
+  }
+  const header = "// Generated by dreamboard test. Do not edit by hand.\n";
+  await writeWorkspaceTextFile(
+    options.projectRoot,
+    "test/generated/base-states.generated.ts",
+    `${header}export const BASE_STATES = ${JSON.stringify(baseStates, null, 2)} as const;
+export const BASE_STATES_CONTRACT_FINGERPRINT = ${JSON.stringify(contractFingerprintValue)};
+`
+  );
+  await writeWorkspaceTextFile(
+    options.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;
+`
+  );
+  await writeWorkspaceTextFile(
+    options.projectRoot,
+    "test/generated/scenario-manifest.generated.ts",
+    `${header}export const SCENARIO_MANIFEST = ${JSON.stringify(
+      options.scenarios.map((scenario) => ({
+        id: scenario.definition.id,
+        filePath: path3.relative(generatedDir, scenario.filePath),
+        base: scenario.definition.from
+      })),
+      null,
+      2
+    )} as const;
+`
+  );
+  await writeWorkspaceJsonFile(
+    options.projectRoot,
+    "test/generated/.generation-meta.json",
+    {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      contractFingerprint: contractFingerprintValue,
+      scenarioCount: options.scenarios.length,
+      baseStateCount: options.bases.length
+    }
+  );
+}
+async function loadGeneratedBaseStates(projectRoot) {
+  const filePath = path3.join(
+    projectRoot,
+    "test",
+    "generated",
+    "base-states.generated.ts"
+  );
+  if (!await exists(filePath)) {
+    return null;
+  }
+  const module = await importTypeScriptModule(filePath);
+  return module.BASE_STATES ?? null;
+}
+async function loadGeneratedScenarioManifest(projectRoot) {
+  const filePath = path3.join(
+    projectRoot,
+    "test",
+    "generated",
+    "scenario-manifest.generated.ts"
+  );
+  if (!await exists(filePath)) {
+    return [];
+  }
+  const module = await importTypeScriptModule(filePath);
+  const entries = module.SCENARIO_MANIFEST;
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    if (entry && typeof entry === "object" && "id" in entry && "base" in entry && typeof entry.id === "string" && typeof entry.base === "string") {
+      return [{ id: entry.id, base: entry.base }];
+    }
+    return [];
+  });
+}
+function validateGeneratedFingerprint(options) {
+  const mismatches = [];
+  if (options.generated.contractFingerprint && options.current.contractFingerprint && options.generated.contractFingerprint !== options.current.contractFingerprint) {
+    const error = new Error(
+      `Base states were generated for contract ${options.generated.contractFingerprint} but the current contract is ${options.current.contractFingerprint}. Remedy: run \`dreamboard test\`, then re-run the tests.`
+    );
+    error.code = STALE_CONTRACT_ARTIFACT_CODE;
+    throw error;
+  }
+  if (options.generated.baseBundleHash !== options.current.baseBundleHash) {
+    mismatches.push("base module changed");
+  }
+  if (options.generated.manifestHash !== options.current.manifestHash) {
+    mismatches.push("manifest changed");
+  }
+  if (options.generated.appBundleHash !== options.current.appBundleHash) {
+    mismatches.push("project reducer bundle changed");
+  }
+  if (options.generated.uiContractHash !== options.current.uiContractHash) {
+    mismatches.push("ui contract changed");
+  }
+  if (options.generated.seed !== options.current.seed || options.generated.players !== options.current.players) {
+    mismatches.push("base seed/player count changed");
+  }
+  if ((options.generated.setupProfileId ?? null) !== (options.current.setupProfileId ?? null)) {
+    mismatches.push("base setup profile changed");
+  }
+  if ((options.generated.parentBaseId ?? null) !== (options.current.parentBaseId ?? null)) {
+    mismatches.push("base parent changed");
+  }
+  if ((options.generated.parentFingerprintHash ?? null) !== (options.current.parentFingerprintHash ?? null)) {
+    mismatches.push("parent base artifact changed");
+  }
+  if (mismatches.length > 0) {
+    throw new Error(
+      `${mismatches.join("; ")}. Run 'dreamboard test' to refresh reducer-native base artifacts.`
+    );
+  }
+}
+async function currentFingerprint(options) {
+  const manifest = await loadManifest(options.projectRoot);
+  const [gameModule, modules] = await Promise.all([
+    importTypeScriptModule(
+      path3.join(options.projectRoot, "app", "game.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
+  ]);
+  const contractFingerprintValue = modules.contractFingerprint(
+    gameModule.default
+  ).value;
+  const resolvedBase = resolveBaseDefinition(
+    options.base,
+    options.basesById ?? /* @__PURE__ */ new Map([[options.base.definition.id, options.base]])
+  );
+  const effectiveSetup = resolveEffectiveBaseSetup({
+    manifest,
+    base: options.base.definition,
+    basesById: options.basesById
+  });
+  let parentFingerprintHash = null;
+  if (options.base.definition.extends) {
+    const parentBase = options.basesById?.get(options.base.definition.extends);
+    if (!parentBase) {
+      throw new Error(
+        `Base '${options.base.definition.id}' extends unknown parent '${options.base.definition.extends}'.`
+      );
+    }
+    parentFingerprintHash = fingerprintHash(
+      await currentFingerprint({
+        projectRoot: options.projectRoot,
+        base: parentBase,
+        basesById: options.basesById,
+        compiledResultId: options.compiledResultId,
+        projectId: options.projectId
+      })
+    );
+  }
+  return {
+    base: options.base.definition.id,
+    seed: resolvedBase.seed,
+    players: resolvedBase.players,
+    baseBundleHash: options.base.bundleHash,
+    manifestHash: hashContent(JSON.stringify(manifest)),
+    appBundleHash: hashContent(
+      await bundleTypeScriptModuleText(
+        path3.join(options.projectRoot, "app", "game.ts")
+      )
+    ),
+    uiContractHash: hashContent(
+      await bundleTypeScriptModuleText(
+        path3.join(options.projectRoot, "shared", "generated", "ui-contract.ts"),
+        { external: SDK_UI_RUNTIME_EXTERNALS }
+      )
+    ),
+    setupProfileId: effectiveSetup.setupProfileId,
+    compiledResultId: options.compiledResultId,
+    projectId: options.projectId,
+    parentBaseId: options.base.definition.extends ?? null,
+    parentFingerprintHash,
+    contractFingerprint: contractFingerprintValue
+  };
+}
+async function generateReducerNativeArtifacts(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  const [bases, scenarios] = await Promise.all([
+    loadTypedBases(options.projectRoot),
+    loadTypedScenarios(options.projectRoot, {
+      scenarioPath: options.scenarioPath
+    })
+  ]);
+  const basesById = new Map(bases.map((base) => [base.definition.id, base]));
+  validateTypedScenarioBases(scenarios, basesById);
+  await writeReducerNativeGeneratedFiles({
+    projectRoot: options.projectRoot,
+    bases,
+    scenarios,
+    compiledResultId: options.compiledResultId,
+    projectId: options.projectId,
+    debug: options.debug
+  });
+  return { bases, scenarios };
+}
+async function runReducerNativeScenarios(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  const [
+    bases,
+    scenarios,
+    initialGeneratedBaseStates,
+    manifest,
+    gameModule,
+    manifestContractModule,
+    modules
+  ] = await Promise.all([
+    loadTypedBases(options.projectRoot),
+    loadTypedScenarios(options.projectRoot, {
+      scenarioPath: options.scenarioPath
+    }),
+    loadGeneratedBaseStates(options.projectRoot),
+    loadManifest(options.projectRoot),
+    importTypeScriptModule(
+      path3.join(options.projectRoot, "app", "game.ts")
+    ),
+    importTypeScriptModule(
+      path3.join(options.projectRoot, "shared", "manifest-contract.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
+  ]);
+  let generatedBaseStates = initialGeneratedBaseStates;
+  const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
+  const basesById = new Map(bases.map((base) => [base.definition.id, base]));
+  validateTypedScenarioBases(scenarios, basesById);
+  if (options.updateSnapshots) {
+    await writeReducerNativeGeneratedFiles({
+      projectRoot: options.projectRoot,
+      bases,
+      scenarios,
+      compiledResultId: options.compiledResultId,
+      projectId: options.projectId,
+      debug: options.debug
+    });
+    generatedBaseStates = await loadGeneratedBaseStates(options.projectRoot);
+  }
+  let passed = 0;
+  let failed = 0;
+  const results = [];
+  for (const scenario of scenarios) {
+    const base = basesById.get(scenario.definition.from);
+    if (!base) {
+      throw new Error(
+        `Missing typed base '${scenario.definition.from}' for scenario '${scenario.definition.id}'.`
+      );
+    }
+    if (generatedBaseStates?.[baseStateKey(base.definition.id)]) {
+      validateGeneratedFingerprint({
+        generated: generatedBaseStates[baseStateKey(base.definition.id)].fingerprint,
+        current: await currentFingerprint({
+          projectRoot: options.projectRoot,
+          base,
+          basesById,
+          compiledResultId: options.compiledResultId,
+          projectId: options.projectId
+        })
+      });
+    }
+    try {
+      const resolvedBase = resolveBaseDefinition(base, basesById);
+      const effectiveSetup = resolveEffectiveBaseSetup({
+        manifest,
+        base: base.definition,
+        basesById
+      });
+      const shadow = new ShadowReducerRuntime(
+        modules,
+        manifest,
+        gameModule.default,
+        createInitialTable,
+        resolvedBase.seed,
+        resolvedBase.players,
+        effectiveSetup.setupProfileId,
+        options.debug ?? false
+      );
+      if (base.definition.extends) {
+        const parentArtifact = generatedBaseStates?.[baseStateKey(base.definition.extends)];
+        if (!parentArtifact) {
+          throw new Error(
+            `Base '${base.definition.id}' extends '${base.definition.extends}', but the parent artifact is missing. Run 'dreamboard test' first.`
+          );
+        }
+        shadow.hydrate(parentArtifact.snapshot, parentArtifact.version);
+      }
+      const context = await createScenarioContext({
+        shadow,
+        expect: modules.createExpectApi({
+          matchSnapshot: createScenarioSnapshotMatcher({
+            projectRoot: options.projectRoot,
+            scenarioId: scenario.definition.id,
+            updateSnapshots: options.updateSnapshots ?? false
+          })
+        })
+      });
+      await context.game.start();
+      await base.definition.setup({
+        game: context.game,
+        players: context.players,
+        seat: context.seat
+      });
+      shadow.clearHistory();
+      await scenario.definition.when(context);
+      if (scenario.definition.phase && shadow.phase() !== scenario.definition.phase) {
+        throw new Error(
+          `Scenario '${scenario.definition.id}' expected phase '${scenario.definition.phase}' but reached '${shadow.phase()}'.`
+        );
+      }
+      if (scenario.definition.stage && shadow.currentStage() !== scenario.definition.stage) {
+        throw new Error(
+          `Scenario '${scenario.definition.id}' expected stage '${scenario.definition.stage}' but reached '${shadow.currentStage() ?? "null"}'.`
+        );
+      }
+      await scenario.definition.then(context);
+      passed += 1;
+      results.push({
+        id: scenario.definition.id,
+        success: true
+      });
+    } catch (error) {
+      failed += 1;
+      results.push({
+        id: scenario.definition.id,
+        success: false,
+        errorCode: isStaleContractArtifactError(error) ? STALE_CONTRACT_ARTIFACT_CODE : void 0,
+        error: error instanceof Error ? formatScenarioErrorForDisplay({
+          error,
+          projectRoot: options.projectRoot,
+          scenarioFilePath: scenario.filePath
+        }) : `Scenario '${scenario.definition.id}' failed.`
+      });
+    } finally {
+    }
+  }
+  return { passed, failed, results };
+}
+
+// src/services/project/local-maintainer-registry-shared.ts
+import crypto2 from "crypto";
+import path4 from "path";
+var localRegistryAddress = readLocalRegistryAddress();
+var LOCAL_REGISTRY_HOST = localRegistryAddress.host;
+var LOCAL_REGISTRY_PORT = localRegistryAddress.port;
+var LOCAL_REGISTRY_URL = `http://${LOCAL_REGISTRY_HOST}:${LOCAL_REGISTRY_PORT}`;
+var LOCAL_SCOPE_NPMRC_CONTENT = `@dreamboard-games:registry=${LOCAL_REGISTRY_URL}
+`;
+function readLocalRegistryAddress() {
+  const urlOverride = process.env.DREAMBOARD_LOCAL_REGISTRY_URL?.trim();
+  const hostOverride = process.env.DREAMBOARD_LOCAL_REGISTRY_HOST?.trim();
+  const portOverride = process.env.DREAMBOARD_LOCAL_REGISTRY_PORT?.trim();
+  if (urlOverride) {
+    let parsed;
+    try {
+      parsed = new URL(urlOverride);
+    } catch {
+      throw new Error(
+        `Invalid DREAMBOARD_LOCAL_REGISTRY_URL '${urlOverride}'. Expected an http://host:port URL.`
+      );
+    }
+    if (parsed.protocol !== "http:" || !parsed.hostname || !parsed.port) {
+      throw new Error(
+        `Invalid DREAMBOARD_LOCAL_REGISTRY_URL '${urlOverride}'. Expected an http://host:port URL.`
+      );
+    }
+    return {
+      host: hostOverride || parsed.hostname,
+      port: parseLocalRegistryPort(portOverride || parsed.port)
+    };
+  }
+  return {
+    host: hostOverride || "127.0.0.1",
+    port: portOverride ? parseLocalRegistryPort(portOverride) : 4873
+  };
+}
+function parseLocalRegistryPort(raw) {
+  const port = Number.parseInt(raw, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(
+      `Invalid DREAMBOARD_LOCAL_REGISTRY_PORT '${raw}'. Expected a TCP port from 1 to 65535.`
+    );
+  }
+  return port;
+}
+function shortHash(value) {
+  return crypto2.createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function isLocalMaintainerRegistryEnabled(apiBaseUrl) {
+  let isLocalLoopbackUrl = false;
+  try {
+    const parsed = new URL(apiBaseUrl);
+    isLocalLoopbackUrl = parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1");
+  } catch {
+    isLocalLoopbackUrl = false;
+  }
+  return !IS_PUBLISHED_BUILD && (apiBaseUrl === ENVIRONMENT_CONFIGS.local?.apiBaseUrl || isLocalLoopbackUrl) && BUILD_CHANNEL === "development";
+}
+function didLocalMaintainerSnapshotChange(previous, next) {
+  if (!next) {
+    return false;
+  }
+  return previous?.snapshotId !== next.snapshotId;
+}
+
+export {
+  createPkcePair,
+  buildClerkAuthorizationUrl,
+  exchangeClerkOAuthCode,
+  createUserSessionManager,
+  IS_PUBLISHED_BUILD,
+  CAN_SELECT_ENVIRONMENT,
+  PUBLISHED_ENVIRONMENT,
+  resolveLocalHarnessAccessToken,
+  resolveConfig,
+  configureClient,
+  requireAuth,
+  getAuthTokenExpiry,
+  resolveProjectContext,
+  parseConfigFlags,
+  parsePlayerCountFlags,
+  parseNewCommandArgs,
+  parseCloneCommandArgs,
+  parseCommitScopedCommandArgs,
+  parseBuildCommandArgs,
+  parseReleasePublishCommandArgs,
+  parseDevCommandArgs,
+  parseAuthCommandArgs,
+  CONFIG_FLAG_ARGS,
+  STALE_CONTRACT_ARTIFACT_CODE,
+  STALE_CONTRACT_ARTIFACT_EXIT_CODE,
+  toDreamboardApiError,
+  isDreamboardApiError,
+  isStaleContractArtifactMessage,
+  isStaleContractArtifactError,
+  getCliErrorExitCode,
+  presentCliError,
+  formatCliError,
+  normalizeSlug,
+  titleFromSlug,
+  parsePositiveInt,
+  findCompiledResultsForAuthoringState,
+  waitForCompiledResultJobSdk,
+  importTypeScriptModule,
+  resolveSetupProfileSelectionForSession,
+  projectIdFromSessionGameSource,
+  isReducerNativeTestingWorkspace,
+  ensureReducerNativeTestingFiles,
+  createSessionFromScenario,
+  generateReducerNativeArtifacts,
+  runReducerNativeScenarios,
+  LOCAL_REGISTRY_URL,
+  shortHash,
+  isLocalMaintainerRegistryEnabled,
+  didLocalMaintainerSnapshotChange
+};
+//# sourceMappingURL=chunk-5IYJOVUA.js.map