@dreamboard-games/cli 0.1.30-alpha.0

package/dist/agent-verifier/chunk-VYJTHSYR.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import {
+  importTypeScriptModule
+} from "./chunk-CEDUHGNH.mjs";
+
+// src/services/project/reducer-contract-preflight.ts
+import path from "path";
+var GAME_CONTRACT_ENTRY_PATH = path.join("app", "game-contract.ts");
+function normalizeErrorMessage(error) {
+  const rawMessage = error instanceof Error ? error.message : String(error ?? "Unknown error");
+  return rawMessage.split("\n").map((line) => line.trim()).find(Boolean)?.replace(/^Error:\s*/u, "") ?? "Unknown error";
+}
+function isManifestScopedIdBrandingError(message) {
+  return message.includes("defineGameContract:") && message.includes("manifest-scoped") && (message.includes("uses a raw z.string()") || message.includes("uses z.array(z.string())"));
+}
+async function assertReducerContractPreflight(projectRoot) {
+  const entryPath = path.join(projectRoot, GAME_CONTRACT_ENTRY_PATH);
+  try {
+    await importTypeScriptModule(entryPath);
+  } catch (error) {
+    const message = normalizeErrorMessage(error);
+    if (isManifestScopedIdBrandingError(message)) {
+      throw new Error(
+        [
+          `Dreamboard could not validate \`${GAME_CONTRACT_ENTRY_PATH}\` during \`dreamboard sync\`.`,
+          "This happens because a state field name looks like a manifest-scoped id, but the schema uses a plain string instead of the manifest-backed id schema.",
+          "Workaround: use `gameContract.schemas.<id>` (or `manifest.ids.<id>`) for manifest ids. If the field is intentionally free-form text, rename it so it does not look like a manifest id field.",
+          `Original error: ${message}`
+        ].join(" ")
+      );
+    }
+    throw new Error(
+      [
+        `Dreamboard could not validate \`${GAME_CONTRACT_ENTRY_PATH}\` during \`dreamboard sync\`.`,
+        "Fix the authored reducer contract module so it can be imported locally, then run `dreamboard sync` again.",
+        `Original error: ${message}`
+      ].join(" ")
+    );
+  }
+}
+
+export {
+  assertReducerContractPreflight
+};

package/dist/agent-verifier/chunk-XYDL7GY6.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/agent-verifier/compile-WNCQQVOF.mjs

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+import {
+  resolveRemoteProject
+} from "./chunk-PM3SVG6R.mjs";
+import {
+  CONFIG_FLAG_ARGS,
+  findProjectCompiledResultsForRevision,
+  parseCompileCommandArgs,
+  queueProjectRevisionCompileSdk,
+  waitForCompiledResultJobSdk
+} from "./chunk-EOQIV6PS.mjs";
+import {
+  formatCliError
+} from "./chunk-BVVNBJM4.mjs";
+import {
+  getProjectAuthoringState,
+  getProjectPendingAuthoringSync,
+  setLatestCompileAttempt
+} from "./chunk-MRCUP5SW.mjs";
+import {
+  runLocalTypecheck
+} from "./chunk-CEQ2VJWN.mjs";
+import {
+  assertCompilerPortableDependencies,
+  assertReleaseEnvironmentPortableDependencies,
+  consola,
+  resolveProjectContext
+} from "./chunk-RJBLBYHX.mjs";
+import "./chunk-HJFQDSTU.mjs";
+import {
+  getLocalDiff
+} from "./chunk-EIQWDQWJ.mjs";
+import {
+  assertCliStaticScaffoldComplete
+} from "./chunk-DTMJCPS4.mjs";
+import "./chunk-2GBBP27W.mjs";
+import {
+  updateProjectState
+} from "./chunk-2NZNKIND.mjs";
+import "./chunk-SYPLYRGB.mjs";
+import "./chunk-2QMNAVV4.mjs";
+import "./chunk-6UUJEYDV.mjs";
+import "./chunk-2E5P5NWG.mjs";
+import "./chunk-MINCYHXN.mjs";
+import "./chunk-U6OJN7XS.mjs";
+import "./chunk-54TAYXUD.mjs";
+import "./chunk-LM3OZLZG.mjs";
+import "./chunk-RBDDIIPM.mjs";
+import "./chunk-SHUMAVAP.mjs";
+import "./chunk-XYDL7GY6.mjs";
+
+// src/commands/compile.ts
+import { defineCommand } from "citty";
+function formatDiagnosticsSummary(diagnostics) {
+  const firstMessage = diagnostics?.find(
+    (diagnostic) => diagnostic.message
+  )?.message;
+  return firstMessage?.trim() || void 0;
+}
+function formatCompileJobProgressMessage(job) {
+  const phase = job.phase ? ` [${job.phase}]` : "";
+  const detail = job.message ? ` ${job.message}` : "";
+  if (job.status === "PENDING") {
+    const queue = typeof job.queuePosition === "number" ? ` (queue ${job.queuePosition + 1})` : "";
+    return `Compile queued${queue}${phase}${detail}`.trim();
+  }
+  if (job.status === "RUNNING") {
+    return `Compile running${phase}${detail}`.trim();
+  }
+  if (job.status === "FAILED") {
+    return `Compile failed${phase}${detail}`.trim();
+  }
+  return `Compile ${job.status.toLowerCase()}${phase}${detail}`.trim();
+}
+function formatFailedCompileJobSummary(job) {
+  return formatCompileJobProgressMessage({
+    status: "FAILED",
+    phase: job.phase,
+    message: job.errorMessage ?? job.message ?? void 0
+  });
+}
+function formatFailedCompileJobWithCompiledResultMessage(options) {
+  return `${formatFailedCompileJobSummary(options.job)}. The backend created compiled result ${options.compiledResultId}, but the compile job did not complete cleanly. Run 'dreamboard compile' again after fixing the backend/compiler issue.`;
+}
+function formatRemoteCompileCommandError(options) {
+  const detail = options.message.trim();
+  const hasActionableTerminalContext = /^Compile\s+(failed|completed|cancelled|interrupted)\b/i.test(detail);
+  if (options.jobId) {
+    if (hasActionableTerminalContext) {
+      return `Remote compile job ${options.jobId} could not be completed. ${detail}`;
+    }
+    return `Remote compile job ${options.jobId} could not be completed. ${detail} Check backend health and try 'dreamboard compile' again.`;
+  }
+  return `Remote compile could not be started. ${detail} Check backend health and try 'dreamboard compile' again.`;
+}
+async function persistFailedCompileAttempt(options) {
+  const nextProjectConfig = setLatestCompileAttempt(options.projectConfig, {
+    resultId: void 0,
+    jobId: options.jobId,
+    revisionDigest: options.revisionDigest,
+    authoringStateId: options.authoringStateId ?? options.revisionDigest,
+    status: "failed",
+    diagnosticsSummary: options.diagnosticsSummary
+  });
+  await updateProjectState(options.projectRoot, nextProjectConfig);
+}
+var compile_default = defineCommand({
+  meta: {
+    name: "compile",
+    description: "Compile the current remote authoring head"
+  },
+  args: {
+    debug: {
+      type: "boolean",
+      description: "Print additional compile progress context",
+      default: false
+    },
+    "skip-local-check": {
+      type: "boolean",
+      description: "Skip the best-effort local typecheck before compiling",
+      default: false
+    },
+    ...CONFIG_FLAG_ARGS
+  },
+  async run({ args }) {
+    const parsedArgs = parseCompileCommandArgs(args);
+    const { projectRoot, projectConfig, config } = await resolveProjectContext(parsedArgs);
+    let nextProjectConfig = projectConfig;
+    await assertReleaseEnvironmentPortableDependencies({
+      projectRoot,
+      projectConfig: nextProjectConfig,
+      environment: config.environment
+    });
+    await assertCompilerPortableDependencies({
+      projectRoot,
+      projectConfig: nextProjectConfig
+    });
+    const diff = await getLocalDiff(projectRoot);
+    await assertCliStaticScaffoldComplete(projectRoot, diff.deleted);
+    if (diff.modified.length > 0 || diff.added.length > 0 || diff.deleted.length > 0) {
+      throw new Error(
+        "Local authored changes are not synced yet. Run 'dreamboard sync' before compiling."
+      );
+    }
+    const remoteProject = await resolveRemoteProject({
+      projectRoot,
+      projectConfig: nextProjectConfig,
+      config
+    });
+    nextProjectConfig = remoteProject.projectConfig;
+    const localAuthoring = getProjectAuthoringState(nextProjectConfig);
+    const pendingSync = getProjectPendingAuthoringSync(nextProjectConfig);
+    if (pendingSync) {
+      if (pendingSync.phase === "authoring_state_created") {
+        throw new Error(
+          "Previous sync reached the remote authored head, but local scaffold finalization did not complete. Run 'dreamboard sync' again before compiling."
+        );
+      }
+      throw new Error(
+        "Previous sync uploaded source changes but did not finish creating the authored head. Run 'dreamboard sync' again before compiling."
+      );
+    }
+    const localRevisionDigest = localAuthoring.revisionDigest ?? nextProjectConfig.remoteHeadDigest;
+    if (!localRevisionDigest) {
+      throw new Error(
+        "This workspace does not know its authored revision yet. Run 'dreamboard sync' first."
+      );
+    }
+    const remoteRevisionDigest = remoteProject.project.head?.revisionDigest;
+    if (!remoteRevisionDigest) {
+      throw new Error("Remote has no authored project revision to compile yet.");
+    }
+    if (remoteRevisionDigest !== localRevisionDigest) {
+      throw new Error(
+        `Remote project head is ${remoteRevisionDigest} but this workspace is based on ${localRevisionDigest}. Run 'dreamboard pull' before compiling.`
+      );
+    }
+    if (!parsedArgs["skip-local-check"]) {
+      consola.start("Running local typecheck...");
+      const typecheckResult = await runLocalTypecheck(projectRoot);
+      if (typecheckResult.skipped) {
+        if (typecheckResult.output) {
+          consola.warn(typecheckResult.output);
+        }
+      } else if (!typecheckResult.success) {
+        if (typecheckResult.output) {
+          consola.error(typecheckResult.output);
+        }
+        throw new Error(
+          "Local typecheck failed. Fix the diagnostics or re-run with --skip-local-check."
+        );
+      } else {
+        consola.success("Local typecheck passed.");
+      }
+    }
+    const existingCompiledResult = (await findProjectCompiledResultsForRevision({
+      projectId: nextProjectConfig.projectId,
+      revisionDigest: localRevisionDigest
+    })).find((result) => result.success);
+    if (existingCompiledResult) {
+      nextProjectConfig = setLatestCompileAttempt(nextProjectConfig, {
+        resultId: existingCompiledResult.id,
+        jobId: void 0,
+        revisionDigest: localRevisionDigest,
+        authoringStateId: existingCompiledResult.authoringStateId ?? localRevisionDigest,
+        status: "successful",
+        diagnosticsSummary: void 0
+      });
+      await updateProjectState(projectRoot, nextProjectConfig);
+      consola.success(
+        `Reusing compiled ${existingCompiledResult.id} for authored state ${existingCompiledResult.authoringStateId}.`
+      );
+      return;
+    }
+    let compileJobId;
+    let compileJobStatus;
+    let compileJobPhase;
+    let compileJobMessage;
+    let compileJobErrorMessage;
+    let compiledResult;
+    try {
+      const compileJob = await queueProjectRevisionCompileSdk({
+        projectId: nextProjectConfig.projectId,
+        revisionDigest: localRevisionDigest
+      });
+      compileJobId = compileJob.jobId;
+      if (!compileJobId) {
+        throw new Error("Failed to create compile job: missing jobId.");
+      }
+      ({
+        job: {
+          status: compileJobStatus,
+          phase: compileJobPhase,
+          message: compileJobMessage,
+          errorMessage: compileJobErrorMessage
+        },
+        compiledResult
+      } = await waitForCompiledResultJobSdk({
+        projectId: nextProjectConfig.projectId,
+        jobId: compileJobId,
+        onProgress: (job) => {
+          const message = formatCompileJobProgressMessage(job);
+          if (parsedArgs.debug) {
+            consola.info(message);
+          } else {
+            consola.start(message);
+          }
+        }
+      }));
+    } catch (error) {
+      const message = formatCliError(error);
+      if (compileJobId) {
+        await persistFailedCompileAttempt({
+          projectRoot,
+          projectConfig: nextProjectConfig,
+          revisionDigest: localRevisionDigest,
+          authoringStateId: localAuthoring.authoringStateId,
+          diagnosticsSummary: message,
+          jobId: compileJobId
+        });
+      }
+      throw new Error(
+        formatRemoteCompileCommandError({
+          message,
+          jobId: compileJobId
+        })
+      );
+    }
+    const failedJobProducedCompiledResult = compileJobStatus === "FAILED" && compiledResult.success;
+    const failedJobWithCompiledResultSummary = failedJobProducedCompiledResult ? formatFailedCompileJobSummary({
+      phase: compileJobPhase,
+      message: compileJobMessage,
+      errorMessage: compileJobErrorMessage
+    }) : void 0;
+    nextProjectConfig = setLatestCompileAttempt(nextProjectConfig, {
+      resultId: compiledResult.id,
+      jobId: compileJobId,
+      revisionDigest: localRevisionDigest,
+      authoringStateId: compiledResult.authoringStateId ?? localRevisionDigest,
+      status: compiledResult.success && !failedJobProducedCompiledResult ? "successful" : "failed",
+      diagnosticsSummary: failedJobWithCompiledResultSummary ?? formatDiagnosticsSummary(compiledResult.diagnostics)
+    });
+    await updateProjectState(projectRoot, nextProjectConfig);
+    if (failedJobProducedCompiledResult) {
+      throw new Error(
+        formatFailedCompileJobWithCompiledResultMessage({
+          compiledResultId: compiledResult.id,
+          job: {
+            phase: compileJobPhase,
+            message: compileJobMessage,
+            errorMessage: compileJobErrorMessage
+          }
+        })
+      );
+    }
+    if (!compiledResult.success) {
+      for (const diagnostic of compiledResult.diagnostics ?? []) {
+        if (diagnostic.message) {
+          consola.error(diagnostic.message);
+        }
+      }
+      throw new Error(
+        "Remote compile failed, but your authored state is synced. Fix the diagnostics and run 'dreamboard compile' again."
+      );
+    }
+    consola.success(
+      `Compiled ${compiledResult.id} for revision ${localRevisionDigest}.`
+    );
+  }
+});
+export {
+  compile_default as default
+};

package/dist/agent-verifier/global-config-WX3ZZIVU.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  getGlobalAuthPath,
+  getGlobalConfigPath,
+  loadGlobalConfig,
+  saveGlobalConfig
+} from "./chunk-HJFQDSTU.mjs";
+import "./chunk-MINCYHXN.mjs";
+import "./chunk-LM3OZLZG.mjs";
+import "./chunk-SHUMAVAP.mjs";
+import "./chunk-XYDL7GY6.mjs";
+export {
+  getGlobalAuthPath,
+  getGlobalConfigPath,
+  loadGlobalConfig,
+  saveGlobalConfig
+};

package/dist/agent-verifier/keychain-backend-TNOPQV3Z.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import "./chunk-XYDL7GY6.mjs";
+
+// src/config/keychain-backend.ts
+var KEYCHAIN_SERVICE = "dreamboard-cli";
+var KEYCHAIN_ACCOUNT = "session";
+var cachedModule;
+async function loadKeyringModule() {
+  if (cachedModule !== void 0) return cachedModule;
+  try {
+    const mod = await import("@napi-rs/keyring");
+    cachedModule = mod;
+  } catch {
+    cachedModule = null;
+  }
+  return cachedModule;
+}
+function keychainProbe(entry) {
+  try {
+    entry.getPassword();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parsePayload(raw) {
+  if (raw === null || raw === void 0) return null;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed.accessToken && !parsed.refreshToken) return null;
+    return {
+      accessToken: parsed.accessToken || void 0,
+      refreshToken: parsed.refreshToken || void 0,
+      tokenExpiresAt: parsed.tokenExpiresAt || void 0,
+      clerkOAuthIssuer: parsed.clerkOAuthIssuer || void 0,
+      clerkOAuthClientId: parsed.clerkOAuthClientId || void 0,
+      clerkOAuthTokenUrl: parsed.clerkOAuthTokenUrl || void 0,
+      environment: parsed.environment || void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function writeFull(entry, creds) {
+  if (!creds.accessToken || !creds.refreshToken) {
+    throw new Error(
+      "Refusing to persist credentials with an empty accessToken or refreshToken."
+    );
+  }
+  const payload = {
+    accessToken: creds.accessToken,
+    refreshToken: creds.refreshToken,
+    tokenExpiresAt: creds.tokenExpiresAt,
+    clerkOAuthIssuer: creds.clerkOAuthIssuer,
+    clerkOAuthClientId: creds.clerkOAuthClientId,
+    clerkOAuthTokenUrl: creds.clerkOAuthTokenUrl,
+    environment: creds.environment
+  };
+  entry.setPassword(JSON.stringify(payload));
+}
+function writeAccessOnly(entry, accessToken) {
+  if (!accessToken) {
+    throw new Error("Refusing to persist an empty access token.");
+  }
+  const payload = { accessToken };
+  entry.setPassword(JSON.stringify(payload));
+}
+function clear(entry) {
+  try {
+    entry.deletePassword();
+  } catch {
+  }
+}
+async function tryKeychainBackend() {
+  const mod = await loadKeyringModule();
+  if (!mod) {
+    return {
+      available: false,
+      reason: "@napi-rs/keyring is not installed for this platform"
+    };
+  }
+  let entry;
+  try {
+    entry = new mod.Entry(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+  } catch (err) {
+    return {
+      available: false,
+      reason: `Failed to construct keyring entry: ${String(err.message ?? err)}`
+    };
+  }
+  if (!keychainProbe(entry)) {
+    return {
+      available: false,
+      reason: "OS keyring is not accessible from this process"
+    };
+  }
+  const backend = {
+    name: "keychain",
+    async read() {
+      try {
+        return parsePayload(entry.getPassword());
+      } catch (err) {
+        const message = String(err.message ?? err);
+        if (/no matching entry|not found/i.test(message)) {
+          return null;
+        }
+        throw err;
+      }
+    },
+    async writeFull(creds) {
+      writeFull(entry, creds);
+    },
+    async writeAccessOnly(accessToken) {
+      writeAccessOnly(entry, accessToken);
+    },
+    async clear() {
+      clear(entry);
+    }
+  };
+  return { available: true, backend };
+}
+function _setKeyringModuleForTests(mod) {
+  cachedModule = mod;
+}
+function _resetKeyringModuleForTests() {
+  cachedModule = void 0;
+}
+export {
+  _resetKeyringModuleForTests,
+  _setKeyringModuleForTests,
+  tryKeychainBackend
+};

package/dist/agent-verifier/local-files-MTPLP62S.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import {
+  collectLocalFiles,
+  getLocalDiff,
+  isAllowedGamePath,
+  isLibraryPath,
+  loadManifest,
+  loadRule,
+  removeExtraneousFiles,
+  walkDir,
+  writeManifest,
+  writeRule,
+  writeScaffoldFiles,
+  writeSnapshot,
+  writeSnapshotFromFiles,
+  writeSourceFiles
+} from "./chunk-EIQWDQWJ.mjs";
+import {
+  computeManifestHash
+} from "./chunk-SYPLYRGB.mjs";
+import "./chunk-2QMNAVV4.mjs";
+import "./chunk-6UUJEYDV.mjs";
+import "./chunk-2E5P5NWG.mjs";
+import "./chunk-MINCYHXN.mjs";
+import "./chunk-U6OJN7XS.mjs";
+import "./chunk-54TAYXUD.mjs";
+import "./chunk-LM3OZLZG.mjs";
+import "./chunk-SHUMAVAP.mjs";
+import "./chunk-XYDL7GY6.mjs";
+export {
+  collectLocalFiles,
+  computeManifestHash,
+  getLocalDiff,
+  isAllowedGamePath,
+  isLibraryPath,
+  loadManifest,
+  loadRule,
+  removeExtraneousFiles,
+  walkDir,
+  writeManifest,
+  writeRule,
+  writeScaffoldFiles,
+  writeSnapshot,
+  writeSnapshotFromFiles,
+  writeSourceFiles
+};

package/dist/agent-verifier/local-typecheck-QFYYAZOK.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  runLocalTypecheck
+} from "./chunk-CEQ2VJWN.mjs";
+import "./chunk-SHUMAVAP.mjs";
+import "./chunk-XYDL7GY6.mjs";
+export {
+  runLocalTypecheck
+};

package/dist/agent-verifier/materialize-workspace-EWGZIVOY.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import {
+  updateProjectAuthoringState,
+  updateProjectLocalMaintainerRegistry
+} from "./chunk-MRCUP5SW.mjs";
+import {
+  writeManifest,
+  writeRule,
+  writeSnapshot
+} from "./chunk-EIQWDQWJ.mjs";
+import {
+  scaffoldStaticWorkspace
+} from "./chunk-DTMJCPS4.mjs";
+import "./chunk-2GBBP27W.mjs";
+import {
+  updateProjectState
+} from "./chunk-2NZNKIND.mjs";
+import "./chunk-SYPLYRGB.mjs";
+import "./chunk-2QMNAVV4.mjs";
+import "./chunk-6UUJEYDV.mjs";
+import "./chunk-2E5P5NWG.mjs";
+import "./chunk-MINCYHXN.mjs";
+import {
+  applyWorkspaceCodegen
+} from "./chunk-CFU5EWIC.mjs";
+import "./chunk-U6OJN7XS.mjs";
+import "./chunk-54TAYXUD.mjs";
+import {
+  ensureDir
+} from "./chunk-LM3OZLZG.mjs";
+import {
+  installWorkspaceDependencies
+} from "./chunk-7653FPGJ.mjs";
+import "./chunk-RBDDIIPM.mjs";
+import "./chunk-SHUMAVAP.mjs";
+import "./chunk-XYDL7GY6.mjs";
+
+// src/services/project/materialize-workspace.ts
+import path from "path";
+async function materializeWorkspaceProject(input) {
+  const targetDir = path.resolve(input.targetDir);
+  await ensureDir(targetDir);
+  await writeManifest(targetDir, input.manifest);
+  await writeRule(targetDir, input.ruleText);
+  await scaffoldStaticWorkspace(targetDir, "new", {
+    localMaintainerRegistry: input.localMaintainerRegistry
+  });
+  await applyWorkspaceCodegen({
+    projectRoot: targetDir,
+    manifest: input.manifest
+  });
+  if (input.installDependencies ?? true) {
+    await installWorkspaceDependencies(targetDir);
+  }
+  const authoringConfig = input.ruleId && input.manifestId && input.manifestContentHash ? updateProjectAuthoringState(baseProjectConfig(input), {
+    ruleId: input.ruleId,
+    manifestId: input.manifestId,
+    manifestContentHash: input.manifestContentHash
+  }) : baseProjectConfig(input);
+  const projectConfig = updateProjectLocalMaintainerRegistry(
+    authoringConfig,
+    input.localMaintainerRegistry ?? void 0
+  );
+  await updateProjectState(targetDir, projectConfig);
+  await writeSnapshot(targetDir);
+  return projectConfig;
+}
+function baseProjectConfig(input) {
+  return {
+    schemaVersion: 2,
+    projectId: input.projectId ?? input.gameId,
+    gameId: input.gameId,
+    deploymentId: input.deploymentId ?? "legacy",
+    ownerScopeId: input.ownerScopeId ?? "default",
+    bindingKey: input.bindingKey,
+    remoteHeadDigest: input.remoteHeadDigest,
+    slug: input.slug,
+    jobId: input.jobId,
+    agentManaged: input.agentManaged,
+    workspacePrepared: input.workspacePrepared,
+    allowCreateGame: input.allowCreateGame,
+    apiBaseUrl: input.apiBaseUrl,
+    webBaseUrl: input.webBaseUrl,
+    packageManifest: input.packageManifest,
+    environmentManifest: input.environmentManifest
+  };
+}
+export {
+  materializeWorkspaceProject
+};

package/dist/agent-verifier/project-state-7GR6BQTQ.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import {
+  clearProjectCompileState,
+  clearProjectPendingAuthoringSync,
+  finalizeProjectPendingAuthoringSync,
+  getProjectAuthoringState,
+  getProjectCompileState,
+  getProjectLocalMaintainerRegistry,
+  getProjectPendingAuthoringSync,
+  sanitizeProjectLocalMaintainerRegistry,
+  setLatestCompileAttempt,
+  setProjectPendingAuthoringSync,
+  updateProjectAuthoringState,
+  updateProjectCompileState,
+  updateProjectLocalMaintainerRegistry
+} from "./chunk-MRCUP5SW.mjs";
+import "./chunk-XYDL7GY6.mjs";
+export {
+  clearProjectCompileState,
+  clearProjectPendingAuthoringSync,
+  finalizeProjectPendingAuthoringSync,
+  getProjectAuthoringState,
+  getProjectCompileState,
+  getProjectLocalMaintainerRegistry,
+  getProjectPendingAuthoringSync,
+  sanitizeProjectLocalMaintainerRegistry,
+  setLatestCompileAttempt,
+  setProjectPendingAuthoringSync,
+  updateProjectAuthoringState,
+  updateProjectCompileState,
+  updateProjectLocalMaintainerRegistry
+};