create-spatius-app 0.1.0-beta.0

package/dist/templates.js

@@ -0,0 +1,2856 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var EXIT_CODES, CliError, PromptCancelledError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    EXIT_CODES = {
+      cancelled: 130,
+      filesystem: 4,
+      general: 1,
+      invalidArgument: 2,
+      success: 0,
+      targetConflict: 3
+    };
+    CliError = class extends Error {
+      code;
+      exitCode;
+      path;
+      recovery;
+      constructor(code, message, { exitCode = EXIT_CODES.general, path, recovery } = {}) {
+        super(message);
+        this.name = "CliError";
+        this.code = code;
+        this.exitCode = exitCode;
+        this.path = path;
+        this.recovery = recovery;
+      }
+    };
+    PromptCancelledError = class extends CliError {
+      constructor(message = "Project creation was cancelled.") {
+        super("CANCELLED", message, {
+          exitCode: EXIT_CODES.cancelled,
+          recovery: "Run the command again when you are ready."
+        });
+        this.name = "PromptCancelledError";
+      }
+    };
+  }
+});
+
+// src/package-managers.ts
+import { execFile, spawn } from "child_process";
+function requiresWindowsCommandShell(command, platform = process.platform) {
+  if (platform !== "win32") {
+    return false;
+  }
+  const executableName = command.split(/[\\/]/u).at(-1)?.toLowerCase();
+  return executableName !== void 0 && (["npm", "pnpm", "bun", "uv", "lk"].includes(executableName) || executableName.endsWith(".cmd") || executableName.endsWith(".bat"));
+}
+function createProcessInvocation(command, args, platform = process.platform, environment = process.env) {
+  if (!requiresWindowsCommandShell(command, platform)) {
+    return { args: [...args], command };
+  }
+  return {
+    args: ["/d", "/s", "/c", command, ...args],
+    command: environment.ComSpec ?? environment.COMSPEC ?? "cmd.exe"
+  };
+}
+function executable(command, ...argsPrefix) {
+  return {
+    argsPrefix,
+    command,
+    displayName: [command, ...argsPrefix].join(" ")
+  };
+}
+function pythonRuntimeCandidates(platform) {
+  return platform === "win32" ? [executable("py", "-3"), executable("python"), executable("python3")] : [executable("python3"), executable("python")];
+}
+function inferInvokingPackageManager(userAgent) {
+  const name = userAgent?.split(" ")[0]?.split("/")[0];
+  return JAVASCRIPT_PACKAGE_MANAGERS.find((manager) => manager === name);
+}
+function unavailableJavaScriptManager(name) {
+  return {
+    available: false,
+    command: executable(name),
+    name
+  };
+}
+function unavailablePythonManager(name, platform) {
+  if (name === "uv") {
+    return {
+      available: false,
+      command: executable("uv"),
+      name
+    };
+  }
+  const pythonRuntime = pythonRuntimeCandidates(platform)[0];
+  return {
+    available: false,
+    command: executable(
+      pythonRuntime.command,
+      ...pythonRuntime.argsPrefix,
+      "-m",
+      "pip"
+    ),
+    name,
+    pythonRuntime
+  };
+}
+function selectJavaScriptPackageManager(inventory, explicit, userAgent) {
+  if (explicit !== void 0) {
+    return inventory.javascript.find((manager) => manager.name === explicit) ?? unavailableJavaScriptManager(explicit);
+  }
+  const invoked = inferInvokingPackageManager(userAgent);
+  const selected = inventory.javascript.find((manager) => manager.name === invoked) ?? inventory.javascript[0];
+  if (selected === void 0) {
+    throw new CliError(
+      "PACKAGE_MANAGER_NOT_FOUND",
+      "No supported JavaScript package manager was found.",
+      {
+        exitCode: EXIT_CODES.invalidArgument,
+        recovery: "Install pnpm, Bun, or npm, then run the command again."
+      }
+    );
+  }
+  return selected;
+}
+function selectPythonPackageManager(inventory, explicit, platform = process.platform) {
+  if (explicit !== void 0) {
+    return inventory.python.find((manager) => manager.name === explicit) ?? unavailablePythonManager(explicit, platform);
+  }
+  const selected = inventory.python[0];
+  if (selected === void 0) {
+    throw new CliError(
+      "PACKAGE_MANAGER_NOT_FOUND",
+      "No supported Python package manager was found.",
+      {
+        exitCode: EXIT_CODES.invalidArgument,
+        recovery: "Install uv, or install Python with pip, then run the command again."
+      }
+    );
+  }
+  return selected;
+}
+function javascriptInstallCommand(packageManager) {
+  return `${packageManager} install`;
+}
+function javascriptRunCommand(packageManager, script) {
+  return `${packageManager} run ${script}`;
+}
+function pythonInstallCommands(packageManager, platform = process.platform) {
+  if (packageManager.name === "uv") {
+    return ["uv sync --directory agent --extra dev"];
+  }
+  const python = packageManager.pythonRuntime?.displayName ?? (platform === "win32" ? "py -3" : "python3");
+  const virtualEnvironmentPython = platform === "win32" ? "agent\\.venv\\Scripts\\python.exe" : "agent/.venv/bin/python";
+  return [
+    `${python} -m venv agent/.venv`,
+    `${virtualEnvironmentPython} -m pip install -e "./agent[dev]"`
+  ];
+}
+var JAVASCRIPT_PACKAGE_MANAGERS;
+var init_package_managers = __esm({
+  "src/package-managers.ts"() {
+    "use strict";
+    init_errors();
+    JAVASCRIPT_PACKAGE_MANAGERS = ["pnpm", "bun", "npm"];
+  }
+});
+
+// src/setup/project.ts
+import { lstat } from "fs/promises";
+import { join } from "path";
+async function assertSpatiusProject(targetDirectory) {
+  try {
+    const target = await lstat(targetDirectory);
+    if (!target.isDirectory() || target.isSymbolicLink()) {
+      throw new Error("not a regular directory");
+    }
+    await Promise.all([
+      ...requiredProjectDirectories.map(async (relativePath) => {
+        const stats = await lstat(join(targetDirectory, relativePath));
+        if (!stats.isDirectory() || stats.isSymbolicLink()) {
+          throw new Error(`${relativePath} is not a regular directory`);
+        }
+      }),
+      ...requiredProjectPaths.map(async (relativePath) => {
+        const stats = await lstat(join(targetDirectory, relativePath));
+        if (!stats.isFile() || stats.isSymbolicLink()) {
+          throw new Error(`${relativePath} is not a regular file`);
+        }
+      })
+    ]);
+  } catch {
+    throw new CliError(
+      "INVALID_ARGUMENT",
+      "The target is not a compatible create-spatius-app project.",
+      {
+        exitCode: EXIT_CODES.invalidArgument,
+        path: targetDirectory,
+        recovery: "Run this command from a generated project, or pass its directory explicitly."
+      }
+    );
+  }
+}
+var requiredProjectPaths, requiredProjectDirectories;
+var init_project = __esm({
+  "src/setup/project.ts"() {
+    "use strict";
+    init_errors();
+    requiredProjectPaths = [
+      "package.json",
+      "wrangler.jsonc",
+      ".dev.vars.example",
+      "worker/index.ts",
+      "agent/src/agent.py",
+      "agent/.env.example"
+    ];
+    requiredProjectDirectories = ["agent", "worker"];
+  }
+});
+
+// src/templates/cloudflare-livekit/voices.ts
+var CHARACTER_VOICES;
+var init_voices = __esm({
+  "src/templates/cloudflare-livekit/voices.ts"() {
+    "use strict";
+    CHARACTER_VOICES = [
+      {
+        value: "feminine",
+        label: "Feminine \u2014 Jacqueline",
+        hint: "Standard female voice \xB7 English (US)",
+        voiceId: "9626c31c-bec5-4cca-baa8-f8ba9e84c8bc"
+      },
+      {
+        value: "masculine",
+        label: "Masculine \u2014 Blake",
+        hint: "Standard male voice \xB7 English (US)",
+        voiceId: "a167e0f3-df7e-4d52-a9c3-f949145efdab"
+      }
+    ];
+  }
+});
+
+// src/setup/environment.ts
+import {
+  chmod,
+  lstat as lstat2,
+  readFile as readFile2,
+  rename,
+  rm,
+  writeFile as writeFile2
+} from "fs/promises";
+import { randomUUID as randomUUID2 } from "crypto";
+import { join as join3 } from "path";
+function parseQuotedValue(rawValue) {
+  const value = rawValue.trim();
+  if (value.startsWith('"')) {
+    const match = value.match(/^((?:"(?:\\.|[^"\\])*")).*$/u);
+    if (match?.[1] !== void 0) {
+      try {
+        return JSON.parse(match[1]);
+      } catch {
+        return match[1].slice(1, -1);
+      }
+    }
+  }
+  if (value.startsWith("'")) {
+    const closingQuote = value.indexOf("'", 1);
+    if (closingQuote !== -1) {
+      return value.slice(1, closingQuote);
+    }
+  }
+  return value.replace(/\s+#.*$/u, "").trim();
+}
+function parseDotenv(contents) {
+  const values = /* @__PURE__ */ new Map();
+  for (const line of contents.split(/\r?\n/u)) {
+    const match = line.match(assignmentPattern);
+    if (match?.[1] !== void 0 && match[2] !== void 0) {
+      values.set(match[1], parseQuotedValue(match[2]));
+    }
+  }
+  return values;
+}
+function isPlaceholderValue(value) {
+  if (value === void 0 || value.trim() === "") {
+    return true;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized.includes("your-") || normalized.includes("your_") || normalized.includes("replace-me") || normalized.includes("changeme") || normalized.includes("placeholder") || /^<[^>]+>$/u.test(normalized);
+}
+function assertSafeValue(name, value) {
+  const normalized = value.trim();
+  if (isPlaceholderValue(normalized)) {
+    throw new CliError(
+      "INVALID_ARGUMENT",
+      `${name} must be a non-placeholder value.`,
+      { exitCode: EXIT_CODES.invalidArgument }
+    );
+  }
+  if (new RegExp("\\p{Cc}", "u").test(normalized)) {
+    throw new CliError(
+      "INVALID_ARGUMENT",
+      `${name} cannot contain control characters.`,
+      { exitCode: EXIT_CODES.invalidArgument }
+    );
+  }
+  return normalized;
+}
+function validateLiveKitUrl(value) {
+  const normalized = assertSafeValue("LIVEKIT_URL", value);
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new CliError(
+      "INVALID_ARGUMENT",
+      "LIVEKIT_URL must be a valid https:// or wss:// URL.",
+      { exitCode: EXIT_CODES.invalidArgument }
+    );
+  }
+  if (!["https:", "wss:"].includes(parsed.protocol) || parsed.hostname === "") {
+    throw new CliError(
+      "INVALID_ARGUMENT",
+      "LIVEKIT_URL must use https:// or wss://.",
+      { exitCode: EXIT_CODES.invalidArgument }
+    );
+  }
+  return normalized;
+}
+function publicBackgroundUrl(value) {
+  if (!value) return void 0;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password ? url.href : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function validateCredentialBundle(credentials) {
+  return {
+    ...credentials.voiceId === void 0 ? {} : {
+      voiceId: assertSafeValue("CARTESIA_VOICE_ID", credentials.voiceId)
+    },
+    liveKit: {
+      apiKey: assertSafeValue("LIVEKIT_API_KEY", credentials.liveKit.apiKey),
+      apiSecret: assertSafeValue(
+        "LIVEKIT_API_SECRET",
+        credentials.liveKit.apiSecret
+      ),
+      url: validateLiveKitUrl(credentials.liveKit.url)
+    },
+    spatius: {
+      backgroundUrl: publicBackgroundUrl(credentials.spatius.backgroundUrl),
+      apiKey: assertSafeValue("SPATIUS_API_KEY", credentials.spatius.apiKey),
+      appId: assertSafeValue("SPATIUS_APP_ID", credentials.spatius.appId),
+      avatarId: assertSafeValue(
+        "SPATIUS_AVATAR_ID",
+        credentials.spatius.avatarId
+      )
+    }
+  };
+}
+function managedValues(contents, keys) {
+  const parsed = parseDotenv(contents ?? "");
+  return new Map(
+    keys.flatMap((key) => {
+      const value = parsed.get(key);
+      return value === void 0 ? [] : [[key, value]];
+    })
+  );
+}
+function inspectCredentialConfiguration(contents, expectedAgentName = "spatius-agent") {
+  const worker = managedValues(contents.worker, WORKER_MANAGED_KEYS);
+  const agent = managedValues(contents.agent, AGENT_MANAGED_KEYS);
+  const allEntries = [...worker.entries(), ...agent.entries()];
+  const hasManagedValues = allEntries.length > 0 || parseDotenv(contents.worker ?? "").has("CARTESIA_VOICE_ID");
+  const hasPlaceholder = allEntries.some(
+    ([, value]) => isPlaceholderValue(value)
+  );
+  const allPresent = WORKER_MANAGED_KEYS.every((key) => worker.has(key)) && AGENT_MANAGED_KEYS.every((key) => agent.has(key));
+  const sharedKeys = [
+    "LIVEKIT_URL",
+    "LIVEKIT_API_KEY",
+    "LIVEKIT_API_SECRET",
+    "SPATIUS_APP_ID"
+  ];
+  const inconsistent = sharedKeys.some((key) => {
+    const workerValue = worker.get(key);
+    const agentValue = agent.get(key);
+    return workerValue !== void 0 && agentValue !== void 0 && !isPlaceholderValue(workerValue) && !isPlaceholderValue(agentValue) && workerValue !== agentValue;
+  }) || worker.get("LIVEKIT_AGENT_NAME") !== void 0 && !isPlaceholderValue(worker.get("LIVEKIT_AGENT_NAME")) && worker.get("LIVEKIT_AGENT_NAME") !== expectedAgentName;
+  if (inconsistent) {
+    return { hasManagedValues, status: "inconsistent" };
+  }
+  if (!allPresent) {
+    return { hasManagedValues, status: "missing" };
+  }
+  if (hasPlaceholder) {
+    return { hasManagedValues, status: "placeholder" };
+  }
+  return { hasManagedValues, status: "complete" };
+}
+function isMissingFile(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function readOptionalCredentialFile(path) {
+  try {
+    const stats = await lstat2(path);
+    if (stats.isSymbolicLink() || !stats.isFile()) {
+      throw new CliError(
+        "FILESYSTEM_ERROR",
+        `Refusing to manage a credential path that is not a regular file: ${path}`,
+        {
+          exitCode: EXIT_CODES.filesystem,
+          path,
+          recovery: "Replace it with a regular local file and rerun setup."
+        }
+      );
+    }
+    return await readFile2(path, "utf8");
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function readCredentialFileState(targetDirectory) {
+  const [worker, agent, workerExample] = await Promise.all([
+    readOptionalCredentialFile(join3(targetDirectory, ".dev.vars")),
+    readOptionalCredentialFile(join3(targetDirectory, "agent", ".env.local")),
+    readOptionalCredentialFile(join3(targetDirectory, ".dev.vars.example"))
+  ]);
+  return {
+    agent,
+    ...inspectCredentialConfiguration(
+      { agent, worker },
+      parseDotenv(workerExample ?? "").get("LIVEKIT_AGENT_NAME")
+    ),
+    worker
+  };
+}
+function serializeDotenvValue(value) {
+  return JSON.stringify(value);
+}
+function mergeDotenv(baseContents, values) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = baseContents.replace(/\r\n/gu, "\n").split("\n");
+  const rendered = lines.map((line) => {
+    const match = line.match(assignmentPattern);
+    const key = match?.[1];
+    if (key === void 0 || !(key in values)) {
+      return line;
+    }
+    seen.add(key);
+    return `${key}=${serializeDotenvValue(values[key])}`;
+  });
+  while (rendered.at(-1) === "") {
+    rendered.pop();
+  }
+  for (const [key, value] of Object.entries(values)) {
+    if (!seen.has(key)) {
+      rendered.push(`${key}=${serializeDotenvValue(value)}`);
+    }
+  }
+  return `${rendered.join("\n")}
+`;
+}
+function buildCredentialFileContents(state, examples, rawCredentials) {
+  const credentials = validateCredentialBundle(rawCredentials);
+  const shared = {
+    LIVEKIT_API_KEY: credentials.liveKit.apiKey,
+    LIVEKIT_API_SECRET: credentials.liveKit.apiSecret,
+    LIVEKIT_URL: credentials.liveKit.url,
+    SPATIUS_APP_ID: credentials.spatius.appId
+  };
+  return {
+    agent: mergeDotenv(state.agent ?? examples.agent, {
+      ...shared,
+      SPATIUS_API_KEY: credentials.spatius.apiKey
+    }),
+    worker: mergeDotenv(state.worker ?? examples.worker, {
+      ...credentials.voiceId === void 0 ? {} : { CARTESIA_VOICE_ID: credentials.voiceId },
+      ...shared,
+      LIVEKIT_AGENT_NAME: parseDotenv(examples.worker).get("LIVEKIT_AGENT_NAME") ?? "spatius-agent",
+      SPATIUS_AVATAR_ID: credentials.spatius.avatarId,
+      // Clear a previous avatar’s background when a new selection has none.
+      SPATIUS_AVATAR_BACKGROUND_URL: credentials.spatius.backgroundUrl ?? ""
+    })
+  };
+}
+async function pathExists(path, fileSystem) {
+  try {
+    await fileSystem.lstat(path);
+    return true;
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function writeCredentialFilesAtomically(targetDirectory, contents, fileSystem = defaultAtomicFileSystem) {
+  const nonce = randomUUID2();
+  const targets = [
+    {
+      backupMoved: false,
+      backupPath: join3(targetDirectory, `.dev.vars.${nonce}.backup`),
+      destinationPath: join3(targetDirectory, ".dev.vars"),
+      hadOriginal: false,
+      installed: false,
+      stagedPath: join3(targetDirectory, `.dev.vars.${nonce}.tmp`)
+    },
+    {
+      backupMoved: false,
+      backupPath: join3(targetDirectory, "agent", `.env.local.${nonce}.backup`),
+      destinationPath: join3(targetDirectory, "agent", ".env.local"),
+      hadOriginal: false,
+      installed: false,
+      stagedPath: join3(targetDirectory, "agent", `.env.local.${nonce}.tmp`)
+    }
+  ];
+  const payloads = [contents.worker, contents.agent];
+  try {
+    for (const [index, target] of targets.entries()) {
+      await fileSystem.writeFile(target.stagedPath, payloads[index], {
+        flag: "wx",
+        mode: 384
+      });
+      target.hadOriginal = await pathExists(target.destinationPath, fileSystem);
+      if (target.hadOriginal) {
+        target.original = await fileSystem.readFile(target.destinationPath);
+      }
+    }
+    for (const target of targets) {
+      if (target.hadOriginal) {
+        await fileSystem.rename(target.destinationPath, target.backupPath);
+        target.backupMoved = true;
+      }
+    }
+    for (const target of targets) {
+      await fileSystem.rename(target.stagedPath, target.destinationPath);
+      target.installed = true;
+      await fileSystem.chmod(target.destinationPath, 384);
+    }
+    for (const target of targets) {
+      await fileSystem.rm(target.backupPath);
+    }
+  } catch {
+    const unrestoredPaths = [];
+    for (const target of [...targets].reverse()) {
+      try {
+        if (target.backupMoved) {
+          if (!await pathExists(target.backupPath, fileSystem)) {
+            await fileSystem.writeFile(target.backupPath, target.original, {
+              flag: "wx",
+              mode: 384
+            });
+          }
+          await fileSystem.rename(target.backupPath, target.destinationPath);
+        } else if (target.installed) {
+          await fileSystem.rm(target.destinationPath);
+        }
+      } catch {
+        unrestoredPaths.push(target.destinationPath);
+      }
+      await fileSystem.rm(target.stagedPath).catch(() => void 0);
+    }
+    throw new CliError(
+      "FILESYSTEM_ERROR",
+      "Could not save the local credential files. " + (unrestoredPaths.length === 0 ? "Existing files were left unchanged or restored." : "Some credential files could not be restored. Any remaining backups were kept."),
+      {
+        exitCode: EXIT_CODES.filesystem,
+        path: targetDirectory,
+        recovery: unrestoredPaths.length === 0 ? "Check file permissions, then rerun create-spatius-app setup . --interactive." : `Check file permissions and inspect the affected files (${unrestoredPaths.join(", ")}) and remaining .backup files before rerunning setup.`
+      }
+    );
+  }
+}
+async function readCredentialExamples(targetDirectory) {
+  const [worker, agent] = await Promise.all([
+    readFile2(join3(targetDirectory, ".dev.vars.example"), "utf8"),
+    readFile2(join3(targetDirectory, "agent", ".env.example"), "utf8")
+  ]);
+  return { agent, worker };
+}
+var WORKER_MANAGED_KEYS, AGENT_MANAGED_KEYS, assignmentPattern, defaultAtomicFileSystem;
+var init_environment = __esm({
+  "src/setup/environment.ts"() {
+    "use strict";
+    init_errors();
+    WORKER_MANAGED_KEYS = [
+      "LIVEKIT_URL",
+      "LIVEKIT_API_KEY",
+      "LIVEKIT_API_SECRET",
+      "LIVEKIT_AGENT_NAME",
+      "SPATIUS_APP_ID",
+      "SPATIUS_AVATAR_ID"
+    ];
+    AGENT_MANAGED_KEYS = [
+      "LIVEKIT_URL",
+      "LIVEKIT_API_KEY",
+      "LIVEKIT_API_SECRET",
+      "SPATIUS_API_KEY",
+      "SPATIUS_APP_ID"
+    ];
+    assignmentPattern = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z\d_]*)\s*=\s*(.*)$/u;
+    defaultAtomicFileSystem = {
+      chmod,
+      lstat: lstat2,
+      readFile: (path) => readFile2(path),
+      rename,
+      rm: (path) => rm(path, { force: true }),
+      writeFile: writeFile2
+    };
+  }
+});
+
+// src/setup/livekit.ts
+import { spawn as spawn2 } from "child_process";
+import { chmod as chmod2, mkdtemp, readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+async function terminate(child) {
+  if (child.pid === void 0) {
+    child.kill("SIGKILL");
+    return;
+  }
+  if (process.platform === "win32") {
+    await new Promise((resolvePromise) => {
+      const killer = spawn2(
+        "taskkill.exe",
+        ["/pid", String(child.pid), "/t", "/f"],
+        { stdio: "ignore", windowsHide: true }
+      );
+      killer.once("close", () => resolvePromise());
+      killer.once("error", () => resolvePromise());
+    });
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    child.kill("SIGKILL");
+  }
+}
+function captureCommand(command, args, { cwd, timeoutMs = 3e3 } = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const invocation = createProcessInvocation(command, args);
+    const child = spawn2(invocation.command, invocation.args, {
+      ...cwd === void 0 ? {} : { cwd },
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let output = "";
+    let settled = false;
+    const onData = (chunk) => {
+      if (output.length < 128e3) {
+        output += chunk.toString();
+      }
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      void terminate(child).finally(() => {
+        reject(new Error(`${command} timed out.`));
+      });
+    }, timeoutMs);
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (code !== 0) {
+        reject(new Error(`${command} exited unsuccessfully.`));
+        return;
+      }
+      resolvePromise(output.trim());
+    });
+  });
+}
+function interactiveCommand(command, args, { cwd }) {
+  return new Promise((resolvePromise, reject) => {
+    const invocation = createProcessInvocation(command, args);
+    const child = spawn2(invocation.command, invocation.args, {
+      cwd,
+      stdio: "inherit",
+      windowsHide: true
+    });
+    child.once("error", () => {
+      reject(new Error("The LiveKit CLI could not be started."));
+    });
+    child.once("close", (code, signal) => {
+      if (signal === "SIGINT" || signal === "SIGTERM" || code === 130) {
+        reject(new PromptCancelledError("LiveKit setup was cancelled."));
+        return;
+      }
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      reject(new Error("The LiveKit CLI credential flow did not complete."));
+    });
+  });
+}
+function parseVersion(output) {
+  return output.match(/\d+\.\d+(?:\.\d+)?(?:-[\w.-]+)?/u)?.[0];
+}
+async function probeLiveKitCli(runner = defaultLiveKitCommandRunner) {
+  let versionOutput;
+  try {
+    versionOutput = await runner.capture("lk", ["--version"]);
+  } catch {
+    return { available: false, reason: "missing" };
+  }
+  try {
+    const help = await runner.capture("lk", ["app", "env", "--help"]);
+    if (!help.includes("--write") || !help.includes("--destination") || !help.includes("--example")) {
+      return {
+        available: false,
+        reason: "incompatible",
+        ...parseVersion(versionOutput) === void 0 ? {} : { version: parseVersion(versionOutput) }
+      };
+    }
+    return {
+      available: true,
+      ...parseVersion(versionOutput) === void 0 ? {} : { version: parseVersion(versionOutput) }
+    };
+  } catch {
+    return {
+      available: false,
+      reason: "incompatible",
+      ...parseVersion(versionOutput) === void 0 ? {} : { version: parseVersion(versionOutput) }
+    };
+  }
+}
+function createLiveKitEnvArguments(temporaryDirectory) {
+  return [
+    "app",
+    "env",
+    "--write",
+    "--destination",
+    ".env.local",
+    "--example",
+    ".env.example",
+    temporaryDirectory
+  ];
+}
+async function loadLiveKitCredentialsWithCli({
+  fileSystem = defaultTemporaryFileSystem,
+  runner = defaultLiveKitCommandRunner,
+  temporaryRoot = tmpdir()
+} = {}) {
+  const directory = await fileSystem.mkdtemp(
+    join4(temporaryRoot, "create-spatius-app-livekit-")
+  );
+  try {
+    await fileSystem.chmod(directory, 448);
+    await fileSystem.writeFile(
+      join4(directory, ".env.example"),
+      "LIVEKIT_URL=\nLIVEKIT_API_KEY=\nLIVEKIT_API_SECRET=\n",
+      384
+    );
+    await runner.interactive("lk", createLiveKitEnvArguments(directory), {
+      cwd: directory
+    });
+    const values = parseDotenv(
+      await fileSystem.readFile(join4(directory, ".env.local"))
+    );
+    const validated = validateCredentialBundle({
+      liveKit: {
+        apiKey: values.get("LIVEKIT_API_KEY") ?? "",
+        apiSecret: values.get("LIVEKIT_API_SECRET") ?? "",
+        url: values.get("LIVEKIT_URL") ?? ""
+      },
+      spatius: {
+        apiKey: "validation-only",
+        appId: "validation-only",
+        avatarId: "validation-only"
+      }
+    });
+    return validated.liveKit;
+  } catch (error) {
+    if (error instanceof PromptCancelledError) throw error;
+    throw new Error(
+      "LiveKit CLI did not return a complete, valid credential set.",
+      { cause: error }
+    );
+  } finally {
+    await fileSystem.remove(directory).catch(() => {
+      throw new Error(
+        "The temporary LiveKit credential directory could not be removed."
+      );
+    });
+  }
+}
+var defaultLiveKitCommandRunner, defaultTemporaryFileSystem;
+var init_livekit = __esm({
+  "src/setup/livekit.ts"() {
+    "use strict";
+    init_errors();
+    init_package_managers();
+    init_environment();
+    defaultLiveKitCommandRunner = {
+      capture: captureCommand,
+      interactive: interactiveCommand
+    };
+    defaultTemporaryFileSystem = {
+      chmod: chmod2,
+      mkdtemp,
+      readFile: (path) => readFile3(path, "utf8"),
+      remove: (path) => rm2(path, {
+        force: true,
+        maxRetries: 3,
+        recursive: true,
+        retryDelay: 100
+      }),
+      writeFile: (path, contents, mode) => writeFile3(path, contents, { mode })
+    };
+  }
+});
+
+// src/setup/livekit-install.ts
+import { tmpdir as tmpdir2 } from "os";
+async function planLiveKitInstall(update, platform = process.platform, runner = defaultLiveKitCommandRunner) {
+  try {
+    if (platform === "darwin") {
+      await runner.capture("brew", ["--version"]);
+      const args = [update ? "upgrade" : "install", "livekit-cli"];
+      return {
+        command: "brew",
+        args,
+        displayCommand: `brew ${args.join(" ")}`
+      };
+    }
+    if (platform === "win32") {
+      await runner.capture("winget", ["--version"]);
+      const args = [
+        update ? "upgrade" : "install",
+        "--id",
+        "LiveKit.LiveKitCLI",
+        "--exact"
+      ];
+      return {
+        command: "winget",
+        args,
+        displayCommand: `winget ${args.join(" ")}`
+      };
+    }
+    if (platform === "linux") {
+      await runner.capture("bash", ["--version"]);
+      await runner.capture("curl", ["--version"]);
+      const script = "curl -fsSL https://get.livekit.io/cli | bash";
+      return {
+        command: "bash",
+        args: ["-o", "pipefail", "-c", script],
+        displayCommand: script
+      };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function installLiveKitCli(plan, runner = defaultLiveKitCommandRunner) {
+  return runner.interactive(plan.command, plan.args, { cwd: tmpdir2() });
+}
+function authenticateLiveKitCli(runner = defaultLiveKitCommandRunner) {
+  return runner.interactive("lk", ["cloud", "auth"], { cwd: tmpdir2() });
+}
+var LIVEKIT_INSTALL_GUIDE;
+var init_livekit_install = __esm({
+  "src/setup/livekit-install.ts"() {
+    "use strict";
+    init_livekit();
+    LIVEKIT_INSTALL_GUIDE = "https://docs.livekit.io/reference/developer-tools/livekit-cli/";
+  }
+});
+
+// src/setup/redaction.ts
+function maskSecret(value) {
+  const normalized = value.trim();
+  if (normalized.length <= 4) {
+    return "\u2022\u2022\u2022\u2022";
+  }
+  return `\u2022\u2022\u2022\u2022${normalized.slice(-4)}`;
+}
+var SENSITIVE_ASSIGNMENT, SENSITIVE_QUERY, BEARER_TOKEN, SecretRedactor;
+var init_redaction = __esm({
+  "src/setup/redaction.ts"() {
+    "use strict";
+    SENSITIVE_ASSIGNMENT = /\b(authorization|auth[_-]?code|code[_-]?verifier|access[_-]?token|refresh[_-]?token|api[_-]?key|api[_-]?secret|password|secret)\b(\s*[:=]\s*)(["']?)([^\s,"'&}]+)\3/giu;
+    SENSITIVE_QUERY = /([?&](?:auth_code|code_verifier|access_token|refresh_token|api_key|api_secret)=)[^&#\s]+/giu;
+    BEARER_TOKEN = /\bBearer\s+[A-Za-z\d._~+/=-]+/giu;
+    SecretRedactor = class {
+      #values = /* @__PURE__ */ new Set();
+      add(...values) {
+        for (const value of values) {
+          const trimmed = value?.trim();
+          if (trimmed !== void 0 && trimmed.length >= 4) {
+            this.#values.add(trimmed);
+          }
+        }
+      }
+      redact(value) {
+        let redacted = value;
+        for (const secret of [...this.#values].sort(
+          (left, right) => right.length - left.length
+        )) {
+          redacted = redacted.replaceAll(secret, "[REDACTED]");
+        }
+        return redacted.replace(BEARER_TOKEN, "Bearer [REDACTED]").replace(SENSITIVE_QUERY, "$1[REDACTED]").replace(SENSITIVE_ASSIGNMENT, "$1$2$3[REDACTED]$3");
+      }
+      error(error, fallback) {
+        const message = error instanceof Error ? error.message : fallback;
+        return new Error(this.redact(message), { cause: error });
+      }
+    };
+  }
+});
+
+// src/setup/success-page.ts
+var successPage;
+var init_success_page = __esm({
+  "src/setup/success-page.ts"() {
+    "use strict";
+    successPage = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="referrer" content="no-referrer" />
+    <title>Spatius authorization complete</title>
+    <style>
+      :root { color-scheme: light; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: #151131; background: #f7f5f1; }
+      * { box-sizing: border-box; }
+      body { margin: 0; min-height: 100vh; min-height: 100svh; display: flex; flex-direction: column; background: radial-gradient(ellipse at 50% 38%, #eae6f3 0, transparent 58%); }
+      a { color: inherit; text-decoration: none; }
+      a:focus-visible { outline: 3px solid #6363a7; outline-offset: 5px; }
+      header, footer { width: min(100% - 48px, 1120px); margin-inline: auto; display: flex; align-items: center; justify-content: space-between; gap: 20px; padding-block: 28px; }
+      .brand { font-size: 24px; font-weight: 650; letter-spacing: -.9px; }
+      .brand { display: inline-flex; align-items: center; gap: 8px; }
+      .eyebrow { font: 11px ui-monospace, SFMono-Regular, Consolas, monospace; letter-spacing: .12em; text-transform: uppercase; color: #636174; }
+      main { flex: 1; display: grid; place-items: center; padding: 48px 24px; }
+      .card { width: min(100%, 620px); padding: 48px; background: #ffffffed; border: 1px solid #e8e4ee; border-radius: 24px; box-shadow: 0 24px 80px -32px #30234d30; }
+      .check { display: grid; place-items: center; width: 52px; height: 52px; border: 1px solid #dcd7ed; border-radius: 50%; background: #f1eef8; color: #6363a7; margin-bottom: 28px; }
+      .check svg { width: 24px; height: 24px; }
+      h1 { font-size: clamp(30px, 5vw, 42px); font-weight: 550; letter-spacing: -.045em; line-height: 1.15; margin: 12px 0 16px; }
+      .description { color: #636174; line-height: 1.7; font-size: 15px; margin: 0; max-width: 420px; }
+      .terminal { display: flex; align-items: center; gap: 16px; padding: 20px; margin: 28px 0 32px; background: #f7f5f9; border: 1px solid #e8e4ee; border-radius: 12px; }
+      .terminal-icon { font: 20px ui-monospace, SFMono-Regular, Consolas, monospace; color: #6363a7; }
+      .terminal strong { display: block; font-size: 14px; font-weight: 600; }
+      .terminal p { margin: 5px 0 0; font-size: 13px; color: #636174; line-height: 1.5; }
+      nav { border-top: 1px solid #eeebf1; padding-top: 24px; }
+      nav .eyebrow { display: block; margin-bottom: 14px; }
+      .links { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }
+      .links a { display: flex; align-items: center; justify-content: space-between; gap: 8px; min-height: 46px; padding: 12px 14px; border: 1px solid #e8e4ee; border-radius: 9px; font-size: 13px; font-weight: 550; }
+      .links a:hover { background: #f1eef8; border-color: #bab2d4; }
+      .link-label { display: flex; align-items: center; gap: 10px; }
+      .links svg { width: 18px; height: 18px; flex-shrink: 0; fill: none; stroke: currentColor; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; color: #6363a7; }
+      .links .external-icon { width: 14px; height: 14px; }
+      footer { justify-content: flex-end; font-size: 12px; color: #636174; }
+      footer a:hover { color: #151131; text-decoration: underline; }
+      @media (max-width: 520px) {
+        header, footer { width: calc(100% - 40px); padding-block: 22px; }
+        main { padding: 20px; }
+        .card { padding: 28px 24px; border-radius: 18px; }
+        .links { grid-template-columns: 1fr; }
+        footer { flex-wrap: wrap; gap: 12px; }
+      }
+    </style>
+  </head>
+  <body>
+    <header>
+      <!-- Inline brand mark from spatius-site/src/assets/brand/spatius-logo-mark-black.svg. -->
+      <a class="brand" href="https://www.spatius.ai/" target="_blank" rel="noopener noreferrer"><svg width="24" height="20" aria-hidden="true" viewBox="0 0 265 220" fill="none" xmlns="http://www.w3.org/2000/svg"><g clip-path="url(#clip0_279_158)"><path d="M178.56 7.19C182.19 8.35 184.62 11.78 184.62 15.59V39.43C184.62 44.17 180.77 48 176.06 48H151.07C148.71 48 146.57 48.96 145.02 50.5C144.92 50.6 144.82 50.69 144.73 50.8C143.35 52.33 142.5 54.35 142.5 56.56V94.22C142.5 98.94 138.66 102.78 133.94 102.78H108.96C104.22 102.78 100.4 106.62 100.4 111.34V149C100.4 153.74 96.56 157.57 91.84 157.57H66.86C62.12 157.57 58.29 161.41 58.29 166.14V188.47C58.29 195.77 49.94 199.95 44.12 195.55C17.04 175.04 0 145.2 0 111.99C0 50.13 59.1 0 132 0C148.41 0 164.11 2.53999 178.59 7.17999L178.56 7.19Z" fill="currentColor"/><path d="M230.22 59.4799V98.2699C230.22 103.15 226.27 107.09 221.4 107.09H195.68C190.8 107.09 186.86 111.04 186.86 115.91V154.7C186.86 159.58 182.9 163.52 178.04 163.52H152.31C149.89 163.52 147.67 164.52 146.08 166.1C145.98 166.2 145.88 166.3 145.78 166.41C144.35 167.98 143.49 170.06 143.49 172.34V211.13C143.49 216.01 139.54 219.95 134.67 219.95H108.95C104.07 219.95 100.13 216 100.13 211.13V172.34C100.13 167.46 104.08 163.52 108.95 163.52H134.67C139.55 163.52 143.49 159.57 143.49 154.7V115.91C143.49 115.62 143.49 115.35 143.53 115.06C143.53 114.93 143.55 114.81 143.57 114.67C143.57 114.55 143.6 114.42 143.63 114.29C143.63 114.23 143.65 114.18 143.66 114.12C143.68 114 143.72 113.88 143.75 113.77C143.77 113.66 143.81 113.55 143.84 113.43C143.92 113.18 144.01 112.91 144.11 112.67C144.19 112.46 144.28 112.26 144.36 112.07C144.36 112.05 144.38 112.04 144.38 112.03C144.44 111.92 144.49 111.81 144.56 111.7C144.73 111.39 144.93 111.08 145.12 110.79C145.21 110.67 145.29 110.55 145.39 110.44C145.51 110.27 145.64 110.12 145.79 109.96C145.89 109.85 145.99 109.75 146.09 109.65C146.29 109.45 146.5 109.26 146.71 109.07C146.93 108.89 147.15 108.73 147.38 108.56C147.61 108.41 147.86 108.26 148.1 108.12C148.34 107.99 148.6 107.87 148.85 107.75C149.12 107.63 149.38 107.53 149.66 107.45C149.87 107.38 150.08 107.33 150.29 107.28C150.5 107.22 150.72 107.18 150.94 107.15C151.12 107.13 151.29 107.11 151.47 107.08H178.02C182.89 107.08 186.84 103.13 186.84 98.2599V59.4699C186.84 54.5899 190.79 50.6499 195.66 50.6499H221.38C226.26 50.6499 230.2 54.5999 230.2 59.4699H230.21L230.22 59.4799Z" fill="currentColor"/><path d="M264.34 122.11V154.32C264.34 158.37 261.07 161.64 257.02 161.64H235.66C231.61 161.64 228.34 164.91 228.34 168.96V201.16C228.34 205.21 225.07 208.49 221.02 208.49H199.66C195.61 208.49 192.34 205.22 192.34 201.16V168.96C192.34 164.91 195.61 161.64 199.66 161.64H221.02C225.07 161.64 228.34 158.37 228.34 154.32V122.11C228.34 118.06 231.61 114.79 235.66 114.79H257.02C261.07 114.79 264.34 118.06 264.34 122.11Z" fill="currentColor"/></g><defs><clipPath id="clip0_279_158"><rect width="265" height="220" fill="white"/></clipPath></defs></svg>Spatius</a>
+    </header>
+    <main>
+      <section class="card" aria-labelledby="success-title">
+        <div class="check" aria-hidden="true"><svg viewBox="0 0 24 24" fill="none"><path d="m5 12 4 4L19 6" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" /></svg></div>
+        <span class="eyebrow">You're connected</span>
+        <h1 id="success-title">Authorization complete.</h1>
+        <p class="description">Your next idea starts here. Spatius is ready to help you bring it to life.</p>
+        <div class="terminal">
+          <span class="terminal-icon" aria-hidden="true">&gt;_</span>
+          <div><strong>Continue in your terminal</strong><p>You can close this tab and finish your project setup.</p></div>
+        </div>
+        <nav aria-label="Spatius resources">
+          <span class="eyebrow">While you're building</span>
+          <div class="links">
+            <a href="https://docs.spatius.ai/" target="_blank" rel="noopener noreferrer"><span class="link-label"><svg aria-hidden="true" viewBox="0 0 24 24"><path d="M12 5v16M12 5C9 3 5 3 2 4v15c3-1 7-1 10 2 3-3 7-3 10-2V4c-3-1-7-1-10 1Z" /></svg>Documentation</span><svg class="external-icon" aria-hidden="true" viewBox="0 0 24 24"><path d="M14 3h7v7m0-7L10 14M10 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5" /></svg></a>
+            <a href="https://app.spatius.ai" target="_blank" rel="noopener noreferrer"><span class="link-label"><svg aria-hidden="true" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="3" /><path d="M3 9h18M9 9v12" /></svg>Open Studio</span><svg class="external-icon" aria-hidden="true" viewBox="0 0 24 24"><path d="M14 3h7v7m0-7L10 14M10 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5" /></svg></a>
+            <a href="https://github.com/spatius-ai" target="_blank" rel="noopener noreferrer"><span class="link-label"><svg aria-hidden="true" viewBox="0 0 24 24"><path d="m8 7-5 5 5 5m8-10 5 5-5 5m-3-13-2 16" /></svg>GitHub</span><svg class="external-icon" aria-hidden="true" viewBox="0 0 24 24"><path d="M14 3h7v7m0-7L10 14M10 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5" /></svg></a>
+            <a href="https://discord.gg/9HGhZfHZh9" target="_blank" rel="noopener noreferrer"><span class="link-label"><svg aria-hidden="true" viewBox="0 0 24 24"><path d="M21 11a8 8 0 0 1-8 8H8l-5 3V7a4 4 0 0 1 4-4h6a8 8 0 0 1 8 8Z" /><path d="M7 10h10M7 14h6" /></svg>Join our Discord</span><svg class="external-icon" aria-hidden="true" viewBox="0 0 24 24"><path d="M14 3h7v7m0-7L10 14M10 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5" /></svg></a>
+          </div>
+        </nav>
+      </section>
+    </main>
+    <footer><a href="https://www.spatius.ai/" target="_blank" rel="noopener noreferrer">Explore Spatius \u2197</a></footer>
+  </body>
+</html>`;
+  }
+});
+
+// src/setup/spatius-api.ts
+function diagnosticRoute(path) {
+  return path.replace(/\/apps\/[^/]+/u, "/apps/{appId}");
+}
+function apiError(payload, httpStatus, method, path) {
+  const errors = payload.errors;
+  const hasErrors = Array.isArray(errors) && errors.length > 0;
+  const raw = hasErrors ? errors[0] : payload.error;
+  if (!hasErrors && (raw === void 0 || raw === null)) return void 0;
+  const error = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const code = typeof error.code === "string" && Object.hasOwn(knownApiStatuses, error.code) ? error.code : "API_ERROR";
+  const suppliedStatus = typeof error.status === "number" ? error.status : typeof error.status === "string" && /^\d{3}$/u.test(error.status) ? Number(error.status) : void 0;
+  const status = suppliedStatus !== void 0 && Number.isInteger(suppliedStatus) && suppliedStatus >= 400 && suppliedStatus <= 599 ? suppliedStatus : knownApiStatuses[code] ?? (httpStatus >= 400 ? httpStatus : 500);
+  return new SpatiusHttpError(status, method, path, {
+    apiCode: code,
+    httpStatus,
+    missingFrontendUrl: code === "INTERNAL_SERVER_ERROR" && error.detail === "server open-platform frontend URL is not configured"
+  });
+}
+function object(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Spatius returned an invalid ${label} response.`);
+  }
+  return value;
+}
+function field(value, camelCase, snakeCase) {
+  return value[camelCase] ?? value[snakeCase];
+}
+function requiredString(value, camelCase, snakeCase = camelCase) {
+  const result = field(value, camelCase, snakeCase);
+  if (typeof result !== "string" || result.trim() === "") {
+    throw new Error(`Spatius returned a response without ${camelCase}.`);
+  }
+  return result.trim();
+}
+function optionalString(value, camelCase, snakeCase = camelCase) {
+  const result = field(value, camelCase, snakeCase);
+  return typeof result === "string" && result.trim() !== "" ? result.trim() : void 0;
+}
+function optionalNumber(value, camelCase, snakeCase = camelCase) {
+  const result = field(value, camelCase, snakeCase);
+  return typeof result === "number" && Number.isFinite(result) ? result : void 0;
+}
+function arrayField(value, camelCase, snakeCase) {
+  const result = field(value, camelCase, snakeCase);
+  if (!Array.isArray(result)) return [];
+  const values = [];
+  for (const entry of result) values.push(entry);
+  return values;
+}
+function nextPageToken(value) {
+  const paginationValue = value.pagination;
+  if (paginationValue === null || typeof paginationValue !== "object" || Array.isArray(paginationValue)) {
+    return void 0;
+  }
+  return optionalString(
+    paginationValue,
+    "nextPageToken",
+    "next_page_token"
+  );
+}
+function parseTokenSet(value, refreshTokenFallback) {
+  const refreshToken = optionalString(value, "refreshToken", "refresh_token") ?? refreshTokenFallback;
+  if (refreshToken === void 0) {
+    throw new Error("Spatius returned a response without refreshToken.");
+  }
+  return {
+    accessToken: requiredString(value, "accessToken", "access_token"),
+    refreshToken
+  };
+}
+function parseApiKey(value) {
+  return {
+    apiKey: requiredString(value, "apiKey", "api_key"),
+    ...optionalString(value, "createdAt", "created_at") === void 0 ? {} : { createdAt: optionalString(value, "createdAt", "created_at") }
+  };
+}
+var SPATIUS_CONSOLE_BASE_URL, knownApiStatuses, SpatiusHttpError, SpatiusApiClient, SpatiusAuthenticatedSession;
+var init_spatius_api = __esm({
+  "src/setup/spatius-api.ts"() {
+    "use strict";
+    SPATIUS_CONSOLE_BASE_URL = "https://api.studio.spatius.ai";
+    knownApiStatuses = {
+      BAD_REQUEST: 400,
+      INVALID_ARGUMENT: 400,
+      FAILED_PRECONDITION: 400,
+      UNAUTHORIZED: 401,
+      PAYMENT_REQUIRED: 402,
+      FORBIDDEN: 403,
+      PERMISSION_DENIED: 403,
+      NOT_FOUND: 404,
+      TIMEOUT: 408,
+      ALREADY_EXISTS: 409,
+      FAILED_DEPENDENCY: 424,
+      QUOTA_EXCEEDED: 429,
+      INTERNAL_SERVER_ERROR: 500,
+      UNIMPLEMENTED: 501,
+      UNAVAILABLE: 503,
+      unauthorized: 401,
+      forbidden: 403,
+      invalid_request: 400,
+      not_found: 404,
+      internal_error: 500
+    };
+    SpatiusHttpError = class extends Error {
+      status;
+      httpStatus;
+      apiCode;
+      constructor(status, method, path, options = {}) {
+        const httpStatus = options.httpStatus ?? status;
+        super(
+          `Spatius request ${method} ${diagnosticRoute(path)} failed (HTTP ${String(httpStatus)}${options.apiCode === void 0 ? "" : `, API ${String(status)} ${options.apiCode}`}).` + (options.missingFrontendUrl === true ? " The Spatius console server is missing SERVER_OPEN_PLATFORM_FRONTEND_URL. Configure it with the Studio URL in the console deployment, then retry." : "")
+        );
+        this.name = "SpatiusHttpError";
+        this.status = status;
+        this.httpStatus = httpStatus;
+        this.apiCode = options.apiCode;
+      }
+    };
+    SpatiusApiClient = class {
+      #baseUrl;
+      #fetch;
+      #onDiagnostic;
+      constructor(baseUrl = SPATIUS_CONSOLE_BASE_URL, fetchImplementation = fetch, onDiagnostic) {
+        this.#baseUrl = baseUrl.replace(/\/+$/u, "");
+        this.#fetch = fetchImplementation;
+        this.#onDiagnostic = onDiagnostic;
+      }
+      async #request(path, {
+        accessToken,
+        appCredentials,
+        body,
+        method = "GET",
+        query
+      } = {}) {
+        const startedAt = performance.now();
+        const report = (details) => {
+          this.#onDiagnostic?.({
+            method,
+            route: diagnosticRoute(path),
+            durationMs: Math.round(performance.now() - startedAt),
+            ...details
+          });
+        };
+        const url = new URL(`${this.#baseUrl}${path}`);
+        if (query !== void 0) {
+          url.search = query.toString();
+        }
+        const headers = new Headers({ Accept: "application/json" });
+        if (body !== void 0) {
+          headers.set("Content-Type", "application/json");
+        }
+        if (accessToken !== void 0) {
+          headers.set("Authorization", `Bearer ${accessToken}`);
+        }
+        if (appCredentials !== void 0) {
+          headers.set("X-App-ID", appCredentials.appId);
+          headers.set("X-API-Key", appCredentials.apiKey);
+        }
+        let response;
+        try {
+          response = await this.#fetch(url, {
+            ...body === void 0 ? {} : { body: JSON.stringify(body) },
+            headers,
+            method,
+            redirect: "error",
+            signal: AbortSignal.timeout(3e4)
+          });
+        } catch {
+          report({ outcome: "network-error" });
+          throw new Error(
+            `Could not reach the Spatius API for ${method} ${diagnosticRoute(path)}.`
+          );
+        }
+        if (response.status === 204) {
+          report({ outcome: "response", httpStatus: response.status });
+          return {};
+        }
+        let payload;
+        try {
+          const contents = await response.text();
+          payload = contents.trim() === "" ? {} : object(JSON.parse(contents), "API");
+        } catch {
+          report({ outcome: "invalid-response", httpStatus: response.status });
+          if (!response.ok)
+            throw new SpatiusHttpError(response.status, method, path);
+          throw new Error(
+            `Spatius returned an invalid JSON object response for ${method} ${diagnosticRoute(path)}.`
+          );
+        }
+        const error = apiError(payload, response.status, method, path);
+        report({
+          outcome: "response",
+          httpStatus: response.status,
+          ...error === void 0 ? {} : { apiStatus: error.status, apiCode: error.apiCode }
+        });
+        if (error !== void 0) throw error;
+        if (!response.ok) throw new SpatiusHttpError(response.status, method, path);
+        return payload;
+      }
+      async createAuthSession(input) {
+        const response = await this.#request("/v1/cli/auth/sessions", {
+          body: {
+            clientName: "create-spatius-app",
+            codeChallenge: input.codeChallenge,
+            codeChallengeMethod: "CLI_AUTH_CODE_CHALLENGE_METHOD_S256",
+            redirectUri: input.redirectUri,
+            state: input.state
+          },
+          method: "POST"
+        });
+        return {
+          authRequestId: requiredString(
+            response,
+            "authRequestId",
+            "auth_request_id"
+          ),
+          authorizeUrl: requiredString(response, "authorizeUrl", "authorize_url"),
+          ...optionalString(response, "expiresAt", "expires_at") === void 0 ? {} : { expiresAt: optionalString(response, "expiresAt", "expires_at") },
+          ...optionalNumber(response, "expiresIn", "expires_in") === void 0 ? {} : { expiresIn: optionalNumber(response, "expiresIn", "expires_in") }
+        };
+      }
+      async exchangeAuthCode(input) {
+        const response = await this.#request("/v1/cli/auth/token", {
+          body: {
+            authCode: input.authCode,
+            authRequestId: input.authRequestId,
+            codeVerifier: input.codeVerifier
+          },
+          method: "POST"
+        });
+        return parseTokenSet(object(response.token, "token"));
+      }
+      async refresh(refreshToken) {
+        const response = await this.#request("/v1/cli/auth/token:refresh", {
+          body: { refreshToken },
+          method: "POST"
+        });
+        return parseTokenSet(object(response.token, "token"), refreshToken);
+      }
+      async revoke(tokens) {
+        await this.#request("/v1/cli/auth/token:revoke", {
+          body: {
+            accessToken: tokens.accessToken,
+            refreshToken: tokens.refreshToken
+          },
+          method: "POST"
+        });
+      }
+      async listApps(accessToken) {
+        const results = [];
+        let pageToken;
+        const seen = /* @__PURE__ */ new Set();
+        do {
+          const query = new URLSearchParams({ "pagination.pageSize": "100" });
+          if (pageToken !== void 0) {
+            query.set("pagination.pageToken", pageToken);
+          }
+          const response = await this.#request("/v1/apps", {
+            accessToken,
+            query
+          });
+          for (const raw of arrayField(response, "apps", "apps")) {
+            const app = object(raw, "app");
+            results.push({
+              appId: requiredString(app, "appId", "app_id"),
+              ...optionalString(app, "createdAt", "created_at") === void 0 ? {} : { createdAt: optionalString(app, "createdAt", "created_at") },
+              name: optionalString(app, "name") ?? "Unnamed app"
+            });
+          }
+          pageToken = nextPageToken(response);
+          if (pageToken !== void 0 && seen.has(pageToken)) break;
+          if (pageToken !== void 0) seen.add(pageToken);
+        } while (pageToken !== void 0);
+        return results;
+      }
+      async createApp(accessToken, name) {
+        const response = await this.#request("/v1/apps", {
+          accessToken,
+          body: { name },
+          method: "POST"
+        });
+        return {
+          appId: requiredString(response, "appId", "app_id"),
+          name
+        };
+      }
+      async listApiKeys(accessToken, appId) {
+        const results = [];
+        let pageToken;
+        const seen = /* @__PURE__ */ new Set();
+        do {
+          const query = new URLSearchParams({ "pagination.pageSize": "100" });
+          if (pageToken !== void 0) {
+            query.set("pagination.pageToken", pageToken);
+          }
+          const path = `/v1/apps/${encodeURIComponent(appId)}/api-keys`;
+          const response = await this.#request(path, { accessToken, query });
+          for (const raw of arrayField(response, "apiKeys", "api_keys")) {
+            results.push(parseApiKey(object(raw, "API key")));
+          }
+          pageToken = nextPageToken(response);
+          if (pageToken !== void 0 && seen.has(pageToken)) break;
+          if (pageToken !== void 0) seen.add(pageToken);
+        } while (pageToken !== void 0);
+        return results;
+      }
+      async createApiKey(accessToken, appId) {
+        const path = `/v1/apps/${encodeURIComponent(appId)}/api-keys`;
+        const response = await this.#request(path, {
+          accessToken,
+          body: { appId },
+          method: "POST"
+        });
+        return parseApiKey(object(field(response, "apiKey", "api_key"), "API key"));
+      }
+      async listPublicAvatars(accessToken) {
+        const results = [];
+        let pageToken;
+        const seen = /* @__PURE__ */ new Set();
+        do {
+          const query = new URLSearchParams({ "pagination.pageSize": "100" });
+          if (pageToken !== void 0) {
+            query.set("pagination.pageToken", pageToken);
+          }
+          const response = await this.#request("/v2/console/public-avatars", {
+            accessToken,
+            query
+          });
+          for (const raw of arrayField(
+            response,
+            "publicAvatars",
+            "public_avatars"
+          )) {
+            const avatar = object(raw, "public avatar");
+            results.push({
+              id: requiredString(avatar, "id"),
+              name: optionalString(avatar, "name") ?? "Unnamed avatar",
+              source: "public",
+              backgroundUrl: optionalString(
+                avatar,
+                "backgroundImageUrl",
+                "background_image_url"
+              )
+            });
+          }
+          pageToken = nextPageToken(response);
+          if (pageToken !== void 0 && seen.has(pageToken)) break;
+          if (pageToken !== void 0) seen.add(pageToken);
+        } while (pageToken !== void 0);
+        return results;
+      }
+      async listPersonalAvatars(appId, apiKey) {
+        const results = [];
+        let pageToken;
+        const seen = /* @__PURE__ */ new Set();
+        do {
+          const query = new URLSearchParams({ "pagination.pageSize": "100" });
+          if (pageToken !== void 0) {
+            query.set("pagination.pageToken", pageToken);
+          }
+          const response = await this.#request("/v1/open/avatars", {
+            appCredentials: { apiKey, appId },
+            query
+          });
+          for (const raw of arrayField(response, "avatars", "avatars")) {
+            const avatar = object(raw, "personal avatar");
+            results.push({
+              id: requiredString(avatar, "id"),
+              name: optionalString(avatar, "name") ?? "Unnamed avatar",
+              source: "personal"
+            });
+          }
+          pageToken = nextPageToken(response);
+          if (pageToken !== void 0 && seen.has(pageToken)) break;
+          if (pageToken !== void 0) seen.add(pageToken);
+        } while (pageToken !== void 0);
+        return results;
+      }
+    };
+    SpatiusAuthenticatedSession = class {
+      #client;
+      #tokens;
+      constructor(client, tokens) {
+        this.#client = client;
+        this.#tokens = tokens;
+      }
+      async authorized(operation) {
+        try {
+          return await operation(this.#tokens.accessToken);
+        } catch (error) {
+          if (!(error instanceof SpatiusHttpError) || error.status !== 401) {
+            throw error;
+          }
+          this.#tokens = await this.#client.refresh(this.#tokens.refreshToken);
+          return operation(this.#tokens.accessToken);
+        }
+      }
+      revoke() {
+        return this.#client.revoke(this.#tokens);
+      }
+    };
+  }
+});
+
+// src/setup/spatius-auth.ts
+import { execFile as execFile2 } from "child_process";
+import { createHash, randomBytes } from "crypto";
+import { createServer } from "http";
+import { promisify } from "util";
+function base64Url(value) {
+  return value.toString("base64url");
+}
+function createPkceMaterial(random = randomBytes) {
+  const verifier = base64Url(random(32));
+  return {
+    challenge: base64Url(createHash("sha256").update(verifier).digest()),
+    state: base64Url(random(18)),
+    verifier
+  };
+}
+function validateSpatiusCallback(requestUrl, redirectUri, expectedState, expectedRequestId) {
+  const url = new URL(requestUrl, redirectUri);
+  if (url.pathname !== callbackPath) {
+    throw new Error("The Spatius callback used an unexpected path.");
+  }
+  const providerError = url.searchParams.get("error");
+  if (providerError !== null) {
+    const safeCode = providerError.replace(/[^A-Za-z\d_.-]/gu, "").slice(0, 80);
+    throw new Error(
+      safeCode === "" ? "Spatius authorization was declined." : `Spatius authorization was declined (${safeCode}).`
+    );
+  }
+  if (url.searchParams.get("state") !== expectedState) {
+    throw new Error("The Spatius callback state did not match.");
+  }
+  const authRequestId = url.searchParams.get("auth_request_id")?.trim();
+  if (authRequestId !== expectedRequestId) {
+    throw new Error("The Spatius callback request ID did not match.");
+  }
+  const authCode = url.searchParams.get("auth_code")?.trim();
+  if (authCode === void 0 || authCode === "") {
+    throw new Error(
+      "The Spatius callback did not include an authorization code."
+    );
+  }
+  return { authCode, authRequestId };
+}
+function closeServer(server) {
+  return new Promise((resolvePromise) => {
+    server.close(() => resolvePromise());
+    server.closeAllConnections();
+  });
+}
+async function createLoopbackCallbackServer() {
+  let expectation;
+  let redirectUri = "";
+  const server = createServer((request, response) => {
+    if (request.method !== "GET" || request.url === void 0) {
+      response.writeHead(404).end("Not found");
+      return;
+    }
+    const requestUrl = new URL(request.url, redirectUri);
+    if (requestUrl.pathname !== callbackPath || expectation === void 0) {
+      response.writeHead(404).end("Not found");
+      return;
+    }
+    const current = expectation;
+    expectation = void 0;
+    try {
+      const result = validateSpatiusCallback(
+        request.url,
+        redirectUri,
+        current.expectedState,
+        current.expectedRequestId
+      );
+      response.writeHead(200, {
+        "Cache-Control": "no-store",
+        "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'",
+        "Content-Type": "text/html; charset=utf-8",
+        "Referrer-Policy": "no-referrer"
+      }).end(successPage);
+      current.resolve(result);
+    } catch (error) {
+      response.writeHead(400, {
+        "Cache-Control": "no-store",
+        "Content-Type": "text/plain; charset=utf-8"
+      }).end("Authorization could not be completed. Return to the terminal.");
+      current.reject(
+        error instanceof Error ? error : new Error("The Spatius callback was invalid.")
+      );
+    }
+  });
+  await new Promise((resolvePromise, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolvePromise();
+    });
+  });
+  const address = server.address();
+  redirectUri = `http://127.0.0.1:${String(address.port)}${callbackPath}`;
+  return {
+    close: () => closeServer(server),
+    redirectUri,
+    waitForCallback: ({ expectedRequestId, expectedState, timeoutMs }) => new Promise((resolvePromise, reject) => {
+      if (expectation !== void 0) {
+        reject(new Error("A Spatius callback is already pending."));
+        return;
+      }
+      const timeout = setTimeout(() => {
+        expectation = void 0;
+        reject(new Error("Timed out waiting for Spatius authorization."));
+      }, timeoutMs);
+      expectation = {
+        expectedRequestId,
+        expectedState,
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        },
+        resolve: (result) => {
+          clearTimeout(timeout);
+          resolvePromise(result);
+        }
+      };
+    })
+  };
+}
+async function openSystemBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "rundll32.exe" : "xdg-open";
+  const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+  try {
+    await execFileAsync(command, args, {
+      timeout: 1e4,
+      windowsHide: true
+    });
+  } catch {
+    throw new Error("The browser could not be opened automatically.");
+  }
+}
+function sessionTimeoutMs(response, now, maximumMs) {
+  const candidates = [maximumMs];
+  if (response.expiresIn !== void 0 && response.expiresIn > 0) {
+    candidates.push(response.expiresIn * 1e3);
+  }
+  if (response.expiresAt !== void 0) {
+    const expiresAt = Date.parse(response.expiresAt);
+    if (Number.isFinite(expiresAt)) {
+      candidates.push(Math.max(1, expiresAt - now()));
+    }
+  }
+  return Math.max(1, Math.min(...candidates.filter((value) => value > 0)));
+}
+function validateAuthorizationUrl(value) {
+  const url = new URL(value);
+  const loopbackHost = ["127.0.0.1", "[::1]", "localhost"].includes(
+    url.hostname
+  );
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopbackHost) || url.username !== "" || url.password !== "") {
+    throw new Error("Spatius returned an unsafe authorization URL.");
+  }
+  return value;
+}
+async function loginToSpatius({
+  callbackServerFactory = createLoopbackCallbackServer,
+  client,
+  maximumWaitMs = 5 * 6e4,
+  now = Date.now,
+  onAuthorizationUrl,
+  onBrowserOpenFailure,
+  openBrowser = openSystemBrowser,
+  redactor = new SecretRedactor()
+}) {
+  const callback = await callbackServerFactory();
+  const pkce = createPkceMaterial();
+  redactor.add(pkce.verifier, pkce.state);
+  try {
+    const auth = await client.createAuthSession({
+      codeChallenge: pkce.challenge,
+      redirectUri: callback.redirectUri,
+      state: pkce.state
+    });
+    const authorizationUrl = validateAuthorizationUrl(auth.authorizeUrl);
+    onAuthorizationUrl(authorizationUrl);
+    const callbackResult = callback.waitForCallback({
+      expectedRequestId: auth.authRequestId,
+      expectedState: pkce.state,
+      timeoutMs: sessionTimeoutMs(auth, now, maximumWaitMs)
+    });
+    void callbackResult.catch(() => void 0);
+    try {
+      await openBrowser(authorizationUrl);
+    } catch (error) {
+      onBrowserOpenFailure?.(
+        error instanceof Error ? error : new Error("The browser could not be opened automatically.")
+      );
+    }
+    const result = await callbackResult;
+    redactor.add(result.authCode);
+    const tokens = await client.exchangeAuthCode({
+      authCode: result.authCode,
+      authRequestId: result.authRequestId,
+      codeVerifier: pkce.verifier
+    });
+    redactor.add(tokens.accessToken, tokens.refreshToken);
+    return new SpatiusAuthenticatedSession(client, tokens);
+  } finally {
+    await callback.close().catch(() => void 0);
+  }
+}
+var execFileAsync, callbackPath;
+var init_spatius_auth = __esm({
+  "src/setup/spatius-auth.ts"() {
+    "use strict";
+    init_redaction();
+    init_success_page();
+    init_spatius_api();
+    execFileAsync = promisify(execFile2);
+    callbackPath = "/callback";
+  }
+});
+
+// src/setup/spatius-resources.ts
+function combineAvatars(publicAvatars, personalAvatars) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const avatar of publicAvatars) {
+    byId.set(avatar.id, avatar);
+  }
+  for (const avatar of personalAvatars) {
+    byId.set(avatar.id, { ...byId.get(avatar.id), ...avatar });
+  }
+  return [...byId.values()];
+}
+function dateLabel(value) {
+  if (value === void 0) return "creation date unavailable";
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? "creation date unavailable" : `created ${date.toISOString().slice(0, 10)}`;
+}
+function apiKeyLabel(key) {
+  return `${maskSecret(key.apiKey)} \xB7 ${dateLabel(key.createdAt)}`;
+}
+function assertResourceId(value, label) {
+  const normalized = value.trim();
+  if (isPlaceholderValue(normalized)) {
+    throw new Error(`${label} must be a non-placeholder value.`);
+  }
+  return normalized;
+}
+async function createApiKey(session, client, app, prompts, redactor) {
+  const confirmed = await prompts.confirm(
+    `Create a new API key for ${app.name} (${app.appId})?`,
+    false
+  );
+  if (!confirmed) {
+    throw new PromptCancelledError("Credential setup was cancelled.");
+  }
+  const key = await session.authorized(
+    (accessToken) => client.createApiKey(accessToken, app.appId)
+  );
+  redactor.add(key.apiKey);
+  return { apiKey: key.apiKey, app };
+}
+async function selectExistingAppKey(session, client, app, prompts, redactor) {
+  const keys = await session.authorized(
+    (accessToken) => client.listApiKeys(accessToken, app.appId)
+  );
+  redactor.add(...keys.map((key2) => key2.apiKey));
+  const options = [
+    ...keys.map((key2, index2) => ({
+      label: apiKeyLabel(key2),
+      value: `key-${String(index2)}`
+    })),
+    {
+      hint: "Creates a new secret after confirmation",
+      label: "Create a new API key for this app",
+      value: "create-key"
+    }
+  ];
+  const selection = await prompts.choose(
+    `Which API key should ${app.name} use?`,
+    options,
+    keys.length > 0 ? "key-0" : "create-key"
+  );
+  if (selection === "create-key") {
+    return createApiKey(session, client, app, prompts, redactor);
+  }
+  const index = Number.parseInt(selection.slice("key-".length), 10);
+  const key = keys[index];
+  if (key === void 0) {
+    throw new Error("The selected Spatius API key is no longer available.");
+  }
+  return { apiKey: key.apiKey, app };
+}
+async function createAppAndKey(session, client, projectName, prompts, redactor) {
+  const requestedName = await prompts.input("Name for the new Spatius app", {
+    initialValue: projectName,
+    placeholder: projectName
+  });
+  const name = requestedName.trim();
+  if (name === "" || name.length > 128) {
+    throw new Error(
+      "The Spatius app name must be between 1 and 128 characters."
+    );
+  }
+  const confirmed = await prompts.confirm(
+    `Create the Spatius app "${name}" and its first API key?`,
+    false
+  );
+  if (!confirmed) {
+    throw new PromptCancelledError("Credential setup was cancelled.");
+  }
+  const app = await session.authorized(
+    (accessToken) => client.createApp(accessToken, name)
+  );
+  try {
+    const key = await session.authorized(
+      (accessToken) => client.createApiKey(accessToken, app.appId)
+    );
+    redactor.add(key.apiKey);
+    return { apiKey: key.apiKey, app };
+  } catch (error) {
+    throw new Error(
+      `The Spatius app was created with ID ${app.appId}, but its API key could not be created. Rerun setup and select that app to create a key.`,
+      { cause: error }
+    );
+  }
+}
+async function selectAppAndKey(session, client, apps, projectName, prompts, redactor) {
+  const options = [
+    ...apps.map((app2, index2) => ({
+      hint: app2.appId,
+      label: app2.name,
+      value: `app-${String(index2)}`
+    })),
+    {
+      hint: "Creates remote resources only after confirmation",
+      label: "Create a new Spatius app and API key",
+      value: "create-app"
+    }
+  ];
+  const selection = await prompts.choose(
+    "Which Spatius app should this project use?",
+    options,
+    apps.length > 0 ? "app-0" : "create-app"
+  );
+  if (selection === "create-app") {
+    return createAppAndKey(session, client, projectName, prompts, redactor);
+  }
+  const index = Number.parseInt(selection.slice("app-".length), 10);
+  const app = apps[index];
+  if (app === void 0) {
+    throw new Error("The selected Spatius app is no longer available.");
+  }
+  return selectExistingAppKey(session, client, app, prompts, redactor);
+}
+async function selectAvatar(publicAvatars, personalAvatars, prompts) {
+  const avatars = combineAvatars(publicAvatars, personalAvatars);
+  const options = [
+    ...avatars.map((avatar2, index2) => ({
+      hint: avatar2.id,
+      label: `${avatar2.name} (${avatar2.source})`,
+      value: `avatar-${String(index2)}`
+    })),
+    {
+      hint: "Use an avatar ID not shown in the lists",
+      label: "Enter an avatar ID manually",
+      value: "manual-avatar"
+    }
+  ];
+  const selection = await prompts.choose(
+    "Which avatar should the demo dispatch?",
+    options,
+    avatars.length > 0 ? "avatar-0" : "manual-avatar"
+  );
+  if (selection === "manual-avatar") {
+    return {
+      avatarId: assertResourceId(
+        await prompts.input("Spatius avatar ID"),
+        "SPATIUS_AVATAR_ID"
+      )
+    };
+  }
+  const index = Number.parseInt(selection.slice("avatar-".length), 10);
+  const avatar = avatars[index];
+  if (avatar === void 0) {
+    throw new Error("The selected Spatius avatar is no longer available.");
+  }
+  return {
+    avatarId: avatar.id,
+    ...avatar.backgroundUrl ? { backgroundUrl: avatar.backgroundUrl } : {}
+  };
+}
+async function selectSpatiusResources({
+  client,
+  onWarning,
+  projectName,
+  prompts,
+  redactor,
+  session
+}) {
+  const [apps, publicAvatars] = await session.authorized(
+    (accessToken) => Promise.all([
+      client.listApps(accessToken),
+      client.listPublicAvatars(accessToken)
+    ])
+  );
+  const selected = await selectAppAndKey(
+    session,
+    client,
+    apps,
+    projectName,
+    prompts,
+    redactor
+  );
+  let personalAvatars = [];
+  try {
+    personalAvatars = await client.listPersonalAvatars(
+      selected.app.appId,
+      selected.apiKey
+    );
+  } catch {
+    onWarning(
+      "Personal avatars could not be loaded; continuing with the public avatar library."
+    );
+  }
+  const avatar = await selectAvatar(publicAvatars, personalAvatars, prompts);
+  return {
+    apiKey: selected.apiKey,
+    appId: selected.app.appId,
+    ...avatar
+  };
+}
+var init_spatius_resources = __esm({
+  "src/setup/spatius-resources.ts"() {
+    "use strict";
+    init_errors();
+    init_environment();
+    init_redaction();
+  }
+});
+
+// src/setup/wizard.ts
+var wizard_exports = {};
+__export(wizard_exports, {
+  runCredentialSetup: () => runCredentialSetup
+});
+import { basename as basename2 } from "path";
+async function collectManualLiveKitCredentials(prompts) {
+  const url = validateLiveKitUrl(
+    await prompts.input("LiveKit URL", {
+      placeholder: "wss://your-project.livekit.cloud"
+    })
+  );
+  const apiKey = await prompts.password("LiveKit API key");
+  const apiSecret = await prompts.password("LiveKit API secret");
+  return validateCredentialBundle({
+    liveKit: { apiKey, apiSecret, url },
+    spatius: {
+      apiKey: "validation-only",
+      appId: "validation-only",
+      avatarId: "validation-only"
+    }
+  }).liveKit;
+}
+async function collectLiveKitCredentials(prompts, dependencies, onStatus, onWarning) {
+  let probe = await dependencies.probeLiveKit();
+  let useCli = false;
+  while (true) {
+    if (!probe.available) {
+      const update = probe.reason === "incompatible";
+      onWarning(
+        update ? "The installed LiveKit CLI needs an update to support `lk app env`." : "LiveKit CLI was not found on PATH. It is needed for browser-based setup."
+      );
+      const plan = await dependencies.planLiveKitInstall(update);
+      onStatus(
+        plan === void 0 ? `Install or update LiveKit CLI, then check again: ${LIVEKIT_INSTALL_GUIDE}` : `${update ? "Update" : "Install"} command: ${plan.displayCommand}`
+      );
+      const action = await prompts.choose(
+        "Connect your LiveKit project",
+        [
+          ...plan === void 0 ? [] : [
+            {
+              label: `${update ? "Update" : "Install"} LiveKit CLI and connect`,
+              value: "install",
+              hint: "Recommended; runs the command shown above"
+            }
+          ],
+          { label: "I've installed it \u2014 check again", value: "retry" },
+          { label: "Enter credentials manually", value: "manual" },
+          { label: "Set up later", value: "skip" }
+        ],
+        plan === void 0 ? "manual" : "install"
+      );
+      if (action === "skip") return void 0;
+      if (action === "manual") return collectManualLiveKitCredentials(prompts);
+      if (action === "install" && plan !== void 0) {
+        try {
+          onStatus(`${update ? "Updating" : "Installing"} LiveKit CLI\u2026`);
+          await dependencies.installLiveKit(plan);
+        } catch (error) {
+          if (error instanceof PromptCancelledError) throw error;
+          onWarning(
+            "LiveKit CLI installation did not complete. Retry, enter credentials manually, or set up later."
+          );
+          continue;
+        }
+      }
+      probe = await dependencies.probeLiveKit();
+      if (!probe.available) {
+        onWarning(
+          "A compatible lk is still unavailable in this terminal. If installation changed PATH, open a new terminal and run create-spatius-app setup . --interactive from your project."
+        );
+        continue;
+      }
+      onStatus("LiveKit CLI is ready.");
+      useCli = true;
+    }
+    const source = useCli ? "cli" : await prompts.choose(
+      "How should LiveKit credentials be configured?",
+      [
+        {
+          hint: probe.version === void 0 ? "Recommended; uses `lk app env`" : `Recommended; lk ${probe.version}`,
+          label: "Use the LiveKit CLI",
+          value: "cli"
+        },
+        {
+          hint: "Opens LiveKit in your browser using `lk cloud auth`",
+          label: "Connect another LiveKit project",
+          value: "connect"
+        },
+        {
+          hint: "Values are entered with secret masking",
+          label: "Enter credentials manually",
+          value: "manual"
+        },
+        { label: "Set up later", value: "skip" }
+      ],
+      "cli"
+    );
+    if (source === "skip") return void 0;
+    if (source === "manual") return collectManualLiveKitCredentials(prompts);
+    try {
+      if (source === "connect") {
+        onStatus(
+          "Opening LiveKit in your browser. Sign in and select a project."
+        );
+        await dependencies.authenticateLiveKit();
+      }
+      onStatus(
+        "Starting the LiveKit project credential flow\u2026 Follow the LiveKit prompts to select a linked project or sign in through your browser."
+      );
+      return await dependencies.loadLiveKitCredentials();
+    } catch (error) {
+      if (error instanceof PromptCancelledError) throw error;
+      onWarning(
+        "The LiveKit CLI flow did not complete or returned invalid credentials."
+      );
+      const action = await prompts.choose(
+        "How should LiveKit setup continue?",
+        [
+          { label: "Retry LiveKit connection", value: "retry" },
+          { label: "Enter credentials manually", value: "manual" },
+          { label: "Set up later", value: "skip" }
+        ],
+        "manual"
+      );
+      if (action === "skip") return void 0;
+      if (action === "manual") return collectManualLiveKitCredentials(prompts);
+      useCli = false;
+    }
+  }
+}
+async function collectManualSpatiusCredentials(prompts) {
+  return {
+    apiKey: await prompts.password("Spatius API key"),
+    appId: await prompts.password("Spatius app ID"),
+    avatarId: await prompts.password("Spatius avatar ID")
+  };
+}
+async function collectBrowserSpatiusCredentials(prompts, projectName, client, dependencies, redactor, onStatus, onWarning) {
+  let session;
+  try {
+    session = await dependencies.loginToSpatius({
+      client,
+      onAuthorizationUrl: (url) => {
+        onStatus(`Approve Spatius access in your browser:
+${url}`);
+      },
+      onBrowserOpenFailure: () => {
+        onWarning(
+          "The browser could not be opened automatically. Use the printed authorization URL."
+        );
+      },
+      redactor
+    });
+    return await dependencies.selectSpatiusResources({
+      client,
+      onWarning,
+      projectName,
+      prompts,
+      redactor,
+      session
+    });
+  } finally {
+    if (session !== void 0) {
+      await session.revoke().catch(() => {
+        onWarning(
+          "The temporary Spatius CLI session could not be revoked automatically. No session token was stored locally."
+        );
+      });
+    }
+  }
+}
+async function collectSpatiusCredentials(prompts, projectName, client, dependencies, redactor, onStatus, onWarning) {
+  const source = await prompts.choose(
+    "How should Spatius credentials be configured?",
+    [
+      {
+        hint: "Recommended; login is temporary and browser-approved",
+        label: "Sign in with Spatius Studio",
+        value: "browser"
+      },
+      {
+        hint: "Values are entered with secret masking",
+        label: "Enter credentials manually",
+        value: "manual"
+      }
+    ],
+    "browser"
+  );
+  if (source === "manual") {
+    return collectManualSpatiusCredentials(prompts);
+  }
+  try {
+    return await collectBrowserSpatiusCredentials(
+      prompts,
+      projectName,
+      client,
+      dependencies,
+      redactor,
+      onStatus,
+      onWarning
+    );
+  } catch (error) {
+    if (error instanceof PromptCancelledError) {
+      throw error;
+    }
+    const detail = redactor.redact(
+      error instanceof Error ? error.message : "Unknown provider error."
+    );
+    onWarning(`Spatius browser setup did not complete: ${detail}`);
+    const useManual = await prompts.confirm(
+      "Enter Spatius credentials manually instead?",
+      true
+    );
+    if (!useManual) {
+      throw new PromptCancelledError("Credential setup was cancelled.");
+    }
+    return collectManualSpatiusCredentials(prompts);
+  }
+}
+async function confirmReplacement(state, prompts, onWarning) {
+  if (state.status === "complete") {
+    const keep = await prompts.confirm(
+      "A complete, consistent local credential configuration already exists. Keep it?",
+      true
+    );
+    if (keep) return false;
+  } else if (state.hasManagedValues) {
+    onWarning(
+      state.status === "inconsistent" ? "The Worker and agent credential files contain inconsistent managed values." : "The local credential files contain only part of the required configuration."
+    );
+  } else {
+    return true;
+  }
+  return prompts.confirm(
+    "Replace the existing managed credential values? Unrelated variables and comments will be preserved.",
+    false
+  );
+}
+function defaultClient(onDiagnostic) {
+  const testBaseUrl = process.env.NODE_ENV === "test" ? process.env.CREATE_SPATIUS_APP_TEST_SPATIUS_BASE_URL : void 0;
+  return new SpatiusApiClient(
+    testBaseUrl ?? SPATIUS_CONSOLE_BASE_URL,
+    fetch,
+    onDiagnostic
+  );
+}
+async function runCredentialSetup({
+  dependencies = {},
+  onDiagnostic,
+  onStatus = () => void 0,
+  onWarning = () => void 0,
+  projectName,
+  prompts,
+  targetDirectory
+}) {
+  const validateProject = dependencies.validateProject ?? assertSpatiusProject;
+  const readState = dependencies.readState ?? readCredentialFileState;
+  const readExamples = dependencies.readExamples ?? readCredentialExamples;
+  const writeFiles = dependencies.writeFiles ?? writeCredentialFilesAtomically;
+  const setupDependencies = {
+    authenticateLiveKit: dependencies.authenticateLiveKit ?? authenticateLiveKitCli,
+    installLiveKit: dependencies.installLiveKit ?? installLiveKitCli,
+    planLiveKitInstall: dependencies.planLiveKitInstall ?? planLiveKitInstall,
+    createSpatiusClient: dependencies.createSpatiusClient ?? (() => defaultClient(onDiagnostic)),
+    loadLiveKitCredentials: dependencies.loadLiveKitCredentials ?? (() => loadLiveKitCredentialsWithCli()),
+    loginToSpatius: dependencies.loginToSpatius ?? ((options) => loginToSpatius({
+      ...options,
+      ...process.env.NODE_ENV === "test" && process.env.CREATE_SPATIUS_APP_TEST_NO_BROWSER === "1" ? { openBrowser: () => Promise.resolve() } : {}
+    })),
+    probeLiveKit: dependencies.probeLiveKit ?? (() => probeLiveKitCli()),
+    selectSpatiusResources: dependencies.selectSpatiusResources ?? selectSpatiusResources
+  };
+  await validateProject(targetDirectory);
+  const state = await readState(targetDirectory);
+  const shouldReplace = await confirmReplacement(state, prompts, onWarning);
+  if (!shouldReplace) {
+    onStatus("Existing local credentials were left unchanged.");
+    return "unchanged";
+  }
+  const redactor = new SecretRedactor();
+  const liveKit = await collectLiveKitCredentials(
+    prompts,
+    setupDependencies,
+    onStatus,
+    onWarning
+  );
+  if (liveKit === void 0) {
+    onStatus(
+      "Credential setup deferred. Run create-spatius-app setup . --interactive from your project when ready."
+    );
+    return "unchanged";
+  }
+  redactor.add(liveKit.apiKey, liveKit.apiSecret);
+  const spatius = await collectSpatiusCredentials(
+    prompts,
+    projectName ?? basename2(targetDirectory),
+    setupDependencies.createSpatiusClient(),
+    setupDependencies,
+    redactor,
+    onStatus,
+    onWarning
+  );
+  redactor.add(spatius.apiKey);
+  const existingVoice = parseDotenv(state.worker ?? "").get(
+    "CARTESIA_VOICE_ID"
+  );
+  const initialVoice = CHARACTER_VOICES.find((voice2) => voice2.voiceId === existingVoice) ?? CHARACTER_VOICES[0];
+  const characterStyle = await prompts.choose(
+    "Which character style should the voice match for your selected avatar?",
+    CHARACTER_VOICES.map(({ value, label, hint }) => ({ value, label, hint })),
+    initialVoice.value
+  );
+  const voice = CHARACTER_VOICES.find(
+    (option) => option.value === characterStyle
+  );
+  if (!voice)
+    throw new Error("Choose a feminine or masculine character voice.");
+  const credentials = validateCredentialBundle({
+    voiceId: voice.voiceId,
+    liveKit,
+    spatius
+  });
+  const examples = await readExamples(targetDirectory);
+  const rendered = buildCredentialFileContents(state, examples, credentials);
+  await writeFiles(targetDirectory, rendered);
+  onStatus("Saved .dev.vars and agent/.env.local for local development only.");
+  return "configured";
+}
+var init_wizard = __esm({
+  "src/setup/wizard.ts"() {
+    "use strict";
+    init_errors();
+    init_voices();
+    init_environment();
+    init_livekit();
+    init_livekit_install();
+    init_project();
+    init_redaction();
+    init_spatius_auth();
+    init_spatius_api();
+    init_spatius_resources();
+  }
+});
+
+// src/templates.ts
+init_errors();
+import { fileURLToPath } from "url";
+
+// src/templates/cloudflare-livekit/index.ts
+init_errors();
+init_package_managers();
+init_project();
+
+// src/templates/cloudflare-livekit/configure.ts
+init_package_managers();
+import { randomUUID } from "crypto";
+import { readFile, writeFile } from "fs/promises";
+import { basename, join as join2 } from "path";
+function toValidPackageName(value) {
+  const normalized = value.trim().toLowerCase().replace(/\s+/gu, "-").replace(/^[._-]+/u, "").replace(/[^a-z\d~._-]+/gu, "-").replace(/-+/gu, "-").slice(0, 214).replace(/-$/u, "");
+  return normalized === "" ? "spatius-app" : normalized;
+}
+function managerDescription(name, version) {
+  return version === void 0 || version === "unknown" ? name : `${name} ${version}`;
+}
+function npmRequiresScriptAllowlist(version) {
+  const major = Number.parseInt(version?.split(".")[0] ?? "", 10);
+  return Number.isFinite(major) && major >= 12;
+}
+function createReplacements(packageManagers, platform) {
+  const javascript = packageManagers.javascript;
+  const python = packageManagers.python;
+  return /* @__PURE__ */ new Map([
+    [
+      "{{SPATIUS_JAVASCRIPT_PACKAGE_MANAGER}}",
+      managerDescription(javascript.name, javascript.version)
+    ],
+    [
+      "{{SPATIUS_PYTHON_PACKAGE_MANAGER}}",
+      managerDescription(python.name, python.version)
+    ],
+    [
+      "__SPATIUS_JAVASCRIPT_INSTALL_COMMAND__",
+      javascriptInstallCommand(javascript.name)
+    ],
+    [
+      "__SPATIUS_PYTHON_INSTALL_COMMANDS__",
+      pythonInstallCommands(python, platform).join("\n")
+    ],
+    [
+      "__SPATIUS_PYTHON_INSTALL_SUMMARY__",
+      pythonInstallCommands(python, platform).join(" && ")
+    ],
+    ["__SPATIUS_DEV_COMMAND__", javascriptRunCommand(javascript.name, "dev")],
+    [
+      "__SPATIUS_WEB_DEV_COMMAND__",
+      javascriptRunCommand(javascript.name, "dev:web")
+    ],
+    [
+      "__SPATIUS_CHECK_COMMAND__",
+      javascriptRunCommand(javascript.name, "check")
+    ],
+    [
+      "__SPATIUS_AGENT_CHECK_COMMAND__",
+      javascriptRunCommand(javascript.name, "agent:check")
+    ],
+    [
+      "__SPATIUS_AGENT_DEV_COMMAND__",
+      javascriptRunCommand(javascript.name, "agent:dev")
+    ],
+    [
+      "__SPATIUS_CF_TYPEGEN_COMMAND__",
+      javascriptRunCommand(javascript.name, "cf-typegen")
+    ],
+    [
+      "__SPATIUS_DEPLOY_COMMAND__",
+      javascriptRunCommand(javascript.name, "deploy")
+    ],
+    [
+      "__SPATIUS_WRANGLER_LOGIN_COMMAND__",
+      javascriptRunCommand(javascript.name, "wrangler -- login")
+    ],
+    [
+      "__SPATIUS_WRANGLER_API_KEY_COMMAND__",
+      javascriptRunCommand(
+        javascript.name,
+        "wrangler -- secret put LIVEKIT_API_KEY"
+      )
+    ],
+    [
+      "__SPATIUS_WRANGLER_API_SECRET_COMMAND__",
+      javascriptRunCommand(
+        javascript.name,
+        "wrangler -- secret put LIVEKIT_API_SECRET"
+      )
+    ]
+  ]);
+}
+async function renderFile(path, replacements) {
+  let contents = await readFile(path, "utf8");
+  for (const [token, replacement] of replacements) {
+    contents = contents.replaceAll(token, replacement);
+  }
+  await writeFile(path, contents);
+}
+async function configureGeneratedTemplate(targetDirectory, {
+  packageManagers,
+  platform = process.platform,
+  projectName = basename(targetDirectory)
+}) {
+  const packagePath = join2(targetDirectory, "package.json");
+  const packageContents = await readFile(packagePath, "utf8");
+  const metadata = JSON.parse(packageContents);
+  const javascript = packageManagers.javascript;
+  const run = (script) => javascriptRunCommand(javascript.name, script);
+  metadata.name = toValidPackageName(projectName);
+  if (javascript.version === void 0 || javascript.version === "unknown") {
+    delete metadata.packageManager;
+  } else {
+    metadata.packageManager = `${javascript.name}@${javascript.version}`;
+  }
+  metadata.scripts.check = [
+    "format:check",
+    "lint",
+    "typecheck",
+    "test",
+    "test:dev",
+    "build"
+  ].map(run).join(" && ");
+  metadata.scripts.deploy = `${run("build")} && wrangler deploy`;
+  metadata.scripts.dev = `concurrently --kill-others --names web,agent "${run("dev:web")}" "${run("agent:dev")}"`;
+  if (javascript.name === "npm" && npmRequiresScriptAllowlist(javascript.version)) {
+    metadata.allowScripts = {
+      "core-js": true,
+      esbuild: true,
+      workerd: true
+    };
+    delete metadata.trustedDependencies;
+  } else if (javascript.name === "bun") {
+    metadata.trustedDependencies = ["core-js", "esbuild", "workerd"];
+    delete metadata.allowScripts;
+  } else {
+    delete metadata.allowScripts;
+    delete metadata.trustedDependencies;
+  }
+  await writeFile(packagePath, `${JSON.stringify(metadata, void 0, 2)}
+`);
+  if (javascript.name === "npm") {
+    const packageLockPath = join2(targetDirectory, "package-lock.json");
+    const packageLock = JSON.parse(
+      await readFile(packageLockPath, "utf8")
+    );
+    packageLock.name = metadata.name;
+    if (packageLock.packages?.[""] !== void 0) {
+      packageLock.packages[""].name = metadata.name;
+    }
+    await writeFile(
+      packageLockPath,
+      `${JSON.stringify(packageLock, void 0, 2)}
+`
+    );
+  }
+  const replacements = createReplacements(packageManagers, platform);
+  const agentReplacements = /* @__PURE__ */ new Map([
+    ["spatius-agent", `spatius-agent-${randomUUID()}`]
+  ]);
+  await Promise.all(
+    [
+      ".dev.vars.example",
+      "wrangler.jsonc",
+      "agent/src/agent.py",
+      "agent/README.md",
+      "worker/index.test.ts"
+    ].map(
+      async (relativePath) => renderFile(join2(targetDirectory, relativePath), agentReplacements)
+    )
+  );
+  await Promise.all(
+    ["README.md", "AGENTS.md", "agent/README.md"].map(
+      async (relativePath) => renderFile(join2(targetDirectory, relativePath), replacements)
+    )
+  );
+}
+
+// src/templates/cloudflare-livekit/install.ts
+init_package_managers();
+import { posix, win32 } from "path";
+function commandStep(command, args, cwd, displayCommand, label) {
+  return {
+    args: [...command.argsPrefix, ...args],
+    command: command.command,
+    cwd,
+    displayCommand,
+    label
+  };
+}
+function createInstallPlan(targetDirectory, packageManagers, platform = process.platform) {
+  const path = platform === "win32" ? win32 : posix;
+  const javascript = packageManagers.javascript;
+  const python = packageManagers.python;
+  const steps = [
+    commandStep(
+      javascript.command,
+      ["install"],
+      targetDirectory,
+      javascriptInstallCommand(javascript.name),
+      `Installing JavaScript dependencies with ${javascript.name}`
+    )
+  ];
+  if (python.name === "uv") {
+    steps.push(
+      commandStep(
+        python.command,
+        ["sync", "--directory", "agent", "--extra", "dev"],
+        targetDirectory,
+        pythonInstallCommands(python, platform)[0],
+        "Installing Python dependencies with uv"
+      )
+    );
+    return steps;
+  }
+  const runtime = python.pythonRuntime;
+  if (runtime === void 0) {
+    throw new Error("pip was selected without a Python runtime.");
+  }
+  const displayedCommands = pythonInstallCommands(python, platform);
+  steps.push(
+    commandStep(
+      runtime,
+      ["-m", "venv", "agent/.venv"],
+      targetDirectory,
+      displayedCommands[0],
+      "Creating the Python virtual environment"
+    )
+  );
+  const virtualEnvironmentPython = platform === "win32" ? path.join(targetDirectory, "agent", ".venv", "Scripts", "python.exe") : path.join(targetDirectory, "agent", ".venv", "bin", "python");
+  steps.push({
+    args: ["-m", "pip", "install", "-e", ".[dev]"],
+    command: virtualEnvironmentPython,
+    cwd: path.join(targetDirectory, "agent"),
+    displayCommand: displayedCommands[1],
+    label: "Installing Python dependencies with pip"
+  });
+  return steps;
+}
+
+// src/templates/cloudflare-livekit/index.ts
+var aliases = {
+  "dev.vars.example": ".dev.vars.example",
+  dockerignore: ".dockerignore",
+  "env.example": ".env.example",
+  gitignore: ".gitignore",
+  npmrc: ".npmrc",
+  prettierignore: ".prettierignore",
+  "python-version": ".python-version",
+  "Dockerfile.pip": "Dockerfile",
+  "Dockerfile.uv": "Dockerfile"
+};
+var cloudflareLivekitTemplate = {
+  id: "cloudflare-livekit",
+  directory: "templates/cloudflare-livekit",
+  description: "Create a React, Cloudflare Workers, and LiveKit Agents application.",
+  components: [
+    "- web/       React + Spatius AvatarKit",
+    "- worker/    Cloudflare token and dispatch API",
+    "- agent/     Python LiveKit agent"
+  ],
+  includeFile(path, configuration) {
+    const javascript = configuration?.packageManagers.javascript.name ?? "pnpm";
+    const python = configuration?.packageManagers.python.name ?? "uv";
+    if (path === "package-lock.json") return javascript === "npm";
+    if (["npmrc", "pnpm-lock.yaml", "pnpm-workspace.yaml"].includes(path)) {
+      return javascript === "pnpm";
+    }
+    if (path === "agent/uv.lock" || path === "agent/Dockerfile.uv") {
+      return python === "uv";
+    }
+    if (path === "agent/Dockerfile.pip") return python === "pip";
+    return true;
+  },
+  mapFile(path) {
+    return path.split("/").map((segment) => aliases[segment] ?? segment).join("/");
+  },
+  configure: configureGeneratedTemplate,
+  createInstallPlan,
+  nextSteps({
+    credentialsConfigured = false,
+    dependenciesInstalled,
+    javascriptPackageManager,
+    platform,
+    pythonPackageManager
+  }) {
+    return [
+      ...dependenciesInstalled ? [] : [
+        javascriptInstallCommand(javascriptPackageManager),
+        ...pythonInstallCommands(pythonPackageManager, platform)
+      ],
+      ...credentialsConfigured ? [] : ["npx create-spatius-app setup . --interactive"],
+      javascriptRunCommand(javascriptPackageManager, "dev")
+    ];
+  },
+  setup: {
+    async recognizes(directory) {
+      try {
+        await assertSpatiusProject(directory);
+        return true;
+      } catch (error) {
+        if (error instanceof CliError && error.code === "INVALID_ARGUMENT") {
+          return false;
+        }
+        throw error;
+      }
+    },
+    async run(options) {
+      const { runCredentialSetup: runCredentialSetup2 } = await Promise.resolve().then(() => (init_wizard(), wizard_exports));
+      return runCredentialSetup2(options);
+    }
+  },
+  verification: [
+    { javascript: "pnpm", python: "uv", scripts: ["check", "agent:check"] },
+    { javascript: "npm", python: "pip", scripts: ["check", "agent:check"] }
+  ]
+};
+
+// src/scaffold.ts
+init_errors();
+import { constants } from "fs";
+import { copyFile, lstat as lstat4, mkdir, readdir as readdir2, rm as rm3 } from "fs/promises";
+import { basename as basename3, dirname, isAbsolute, join as join5, win32 as win322 } from "path";
+
+// src/project-directory.ts
+init_errors();
+import { homedir } from "os";
+import { lstat as lstat3, readdir } from "fs/promises";
+import { parse, resolve } from "path";
+function normalizeTargetDirectory(input, currentWorkingDirectory = process.cwd()) {
+  return resolve(currentWorkingDirectory, input);
+}
+function assertSafeTargetDirectory(targetDirectory, homeDirectory = homedir()) {
+  const normalizedTarget = resolve(targetDirectory);
+  if (normalizedTarget === parse(normalizedTarget).root) {
+    throw new CliError(
+      "UNSAFE_TARGET",
+      "Refusing to create a project at the filesystem root.",
+      {
+        exitCode: EXIT_CODES.invalidArgument,
+        path: normalizedTarget,
+        recovery: "Choose a dedicated project directory."
+      }
+    );
+  }
+  if (normalizedTarget === resolve(homeDirectory)) {
+    throw new CliError(
+      "UNSAFE_TARGET",
+      "Refusing to create a project directly in the home directory.",
+      {
+        exitCode: EXIT_CODES.invalidArgument,
+        path: normalizedTarget,
+        recovery: "Choose a dedicated project directory inside your home directory."
+      }
+    );
+  }
+}
+async function inspectTargetDirectory(targetDirectory) {
+  try {
+    const stats = await lstat3(targetDirectory);
+    if (!stats.isDirectory() || stats.isSymbolicLink()) {
+      return "not-a-directory";
+    }
+    const entries = await readdir(targetDirectory);
+    return entries.length === 0 ? "empty-directory" : "non-empty-directory";
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return "missing";
+    }
+    throw error;
+  }
+}
+async function assertTargetDirectoryAvailable(targetDirectory) {
+  assertSafeTargetDirectory(targetDirectory);
+  const state = await inspectTargetDirectory(targetDirectory);
+  if (state === "not-a-directory") {
+    throw new CliError(
+      "TARGET_NOT_DIRECTORY",
+      `The target path is not a directory: ${targetDirectory}`,
+      {
+        exitCode: EXIT_CODES.targetConflict,
+        path: targetDirectory,
+        recovery: "Choose a path that is missing or is an empty directory."
+      }
+    );
+  }
+  if (state === "non-empty-directory") {
+    throw new CliError(
+      "TARGET_NOT_EMPTY",
+      `The target directory is not empty: ${targetDirectory}
+Choose a new directory or remove its contents first.`,
+      {
+        exitCode: EXIT_CODES.targetConflict,
+        path: targetDirectory,
+        recovery: "Choose an empty directory or remove its contents first."
+      }
+    );
+  }
+  return state;
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/scaffold.ts
+var defaultCopyEntry = async (source, destination) => {
+  await copyFile(source, destination, constants.COPYFILE_EXCL);
+};
+var ignoredTemplateEntries = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  ".npmignore",
+  ".pytest_cache",
+  ".ruff_cache",
+  ".venv",
+  ".wrangler",
+  "__pycache__",
+  "coverage",
+  "dist",
+  "node_modules",
+  "test-results",
+  "playwright-report"
+]);
+function shouldIgnoreTemplateEntry(entry) {
+  return ignoredTemplateEntries.has(entry) || /\.py[cod]$/u.test(entry) || /^\.(?:env|dev\.vars)(?:\.|$)/u.test(entry) && !entry.endsWith(".example");
+}
+function assertRelativeDestination(path) {
+  if (isAbsolute(path) || win322.isAbsolute(path) || path.includes("\\") || path.includes(":") || path.includes("\0") || path.split("/").some((segment) => ["", ".", ".."].includes(segment))) {
+    throw new Error("Template file mappings must stay inside the project.");
+  }
+}
+async function listTemplateFiles(templateDirectory, template, configuration, relativeDirectory = "") {
+  const entries = await readdir2(join5(templateDirectory, relativeDirectory), {
+    withFileTypes: true
+  });
+  const files = [];
+  for (const entry of entries) {
+    if (shouldIgnoreTemplateEntry(entry.name)) continue;
+    const source = [relativeDirectory, entry.name].filter(Boolean).join("/");
+    if (!template.includeFile(source, configuration)) continue;
+    if (entry.isSymbolicLink()) {
+      throw new Error("Bundled templates must not contain symbolic links.");
+    }
+    if (entry.isDirectory()) {
+      files.push(
+        ...await listTemplateFiles(
+          templateDirectory,
+          template,
+          configuration,
+          source
+        )
+      );
+    } else if (entry.isFile()) {
+      const destination = template.mapFile(source);
+      assertRelativeDestination(destination);
+      files.push({ source, destination });
+    } else {
+      throw new Error("Bundled templates must contain regular files.");
+    }
+  }
+  return files;
+}
+async function createScaffoldPlan({
+  configuration,
+  targetDirectory: targetDirectoryInput,
+  template = getTemplate(),
+  templateDirectory = resolveTemplateDirectory(template)
+}) {
+  const targetDirectory = normalizeTargetDirectory(targetDirectoryInput);
+  const targetState = await assertTargetDirectoryAvailable(targetDirectory);
+  let entries;
+  try {
+    const root = await lstat4(templateDirectory);
+    if (!root.isDirectory() || root.isSymbolicLink()) {
+      throw new Error("The template must be a regular directory.");
+    }
+    entries = await listTemplateFiles(
+      templateDirectory,
+      template,
+      configuration
+    );
+    const destinations = /* @__PURE__ */ new Set();
+    const directories = /* @__PURE__ */ new Map();
+    for (const { destination } of entries) {
+      const key = destination.toLowerCase();
+      if (destinations.has(key) || directories.has(key)) {
+        throw new Error("Template file mappings collide.");
+      }
+      destinations.add(key);
+      const segments = destination.split("/");
+      for (let index = 1; index < segments.length; index++) {
+        const parent = segments.slice(0, index).join("/");
+        const parentKey = parent.toLowerCase();
+        if (destinations.has(parentKey))
+          throw new Error("Template file mappings collide.");
+        const existingParent = directories.get(parentKey);
+        if (existingParent !== void 0 && existingParent !== parent) {
+          throw new Error(
+            "Template directory mappings use inconsistent casing."
+          );
+        }
+        directories.set(parentKey, parent);
+      }
+    }
+  } catch (error) {
+    throw new CliError(
+      "TEMPLATE_NOT_FOUND",
+      "The bundled project template could not be loaded at " + templateDirectory + ": " + (error instanceof Error ? error.message : "unknown filesystem error"),
+      {
+        exitCode: EXIT_CODES.filesystem,
+        path: templateDirectory,
+        recovery: "Reinstall create-spatius-app and try again."
+      }
+    );
+  }
+  if (entries.length === 0) {
+    throw new CliError(
+      "TEMPLATE_NOT_FOUND",
+      "The bundled project template is empty.",
+      {
+        exitCode: EXIT_CODES.filesystem,
+        path: templateDirectory,
+        recovery: "Reinstall create-spatius-app and try again."
+      }
+    );
+  }
+  entries.sort(
+    (left, right) => left.destination < right.destination ? -1 : left.destination > right.destination ? 1 : 0
+  );
+  return {
+    entries,
+    files: entries.map((entry) => entry.destination),
+    targetDirectory,
+    targetState,
+    templateDirectory
+  };
+}
+async function rollback(targetDirectory, targetCreated, createdPaths) {
+  if (targetCreated) {
+    await rm3(targetDirectory, { force: true, recursive: true });
+    return;
+  }
+  for (const path of [...createdPaths].reverse()) {
+    await rm3(path, { force: true, recursive: true });
+  }
+}
+async function scaffoldProject({
+  configuration,
+  copyEntry = defaultCopyEntry,
+  targetDirectory: targetDirectoryInput,
+  template = getTemplate(),
+  templateDirectory = resolveTemplateDirectory(template)
+}) {
+  const plan = await createScaffoldPlan({
+    configuration,
+    targetDirectory: targetDirectoryInput,
+    template,
+    templateDirectory
+  });
+  const { targetDirectory } = plan;
+  const createdPaths = [];
+  const createdDirectories = /* @__PURE__ */ new Set([targetDirectory]);
+  let targetCreated = false;
+  async function createParent(directory) {
+    if (createdDirectories.has(directory)) return;
+    await createParent(dirname(directory));
+    await mkdir(directory);
+    createdPaths.push(directory);
+    createdDirectories.add(directory);
+  }
+  try {
+    const targetState = await assertTargetDirectoryAvailable(targetDirectory);
+    if (targetState === "missing") {
+      await mkdir(dirname(targetDirectory), { recursive: true });
+      await mkdir(targetDirectory);
+      targetCreated = true;
+    }
+    for (const entry of plan.entries) {
+      const source = join5(templateDirectory, entry.source);
+      const destination = join5(targetDirectory, entry.destination);
+      const stats = await lstat4(source);
+      if (!stats.isFile() || stats.isSymbolicLink()) {
+        throw new Error("A template source is no longer a regular file.");
+      }
+      await createParent(dirname(destination));
+      createdPaths.push(destination);
+      await copyEntry(source, destination);
+    }
+    if (configuration !== void 0) {
+      await template.configure(targetDirectory, configuration);
+    }
+  } catch (error) {
+    await rollback(targetDirectory, targetCreated, createdPaths).catch(
+      () => void 0
+    );
+    throw new CliError(
+      "FILESYSTEM_ERROR",
+      "Could not create " + basename3(targetDirectory) + ": " + (error instanceof Error ? error.message : "unknown filesystem error"),
+      {
+        exitCode: EXIT_CODES.filesystem,
+        path: targetDirectory,
+        recovery: "Check filesystem permissions and try again."
+      }
+    );
+  }
+  return { files: plan.files, targetDirectory };
+}
+
+// src/templates.ts
+init_package_managers();
+var DEFAULT_TEMPLATE_ID = "cloudflare-livekit";
+var templateRegistry = {
+  [DEFAULT_TEMPLATE_ID]: cloudflareLivekitTemplate
+};
+function getTemplate(id = DEFAULT_TEMPLATE_ID) {
+  return templateRegistry[id];
+}
+function resolveTemplateDirectory(template = getTemplate()) {
+  return fileURLToPath(new URL(`../${template.directory}/`, import.meta.url));
+}
+async function resolveProjectTemplate(targetDirectory, templates = Object.values(templateRegistry)) {
+  const matches = [];
+  for (const template of templates) {
+    if (await template.setup.recognizes(targetDirectory))
+      matches.push(template);
+  }
+  if (matches.length !== 1) {
+    throw new CliError(
+      "INVALID_ARGUMENT",
+      matches.length === 0 ? "The target is not a compatible create-spatius-app project." : "The target matches more than one create-spatius-app template.",
+      {
+        exitCode: EXIT_CODES.invalidArgument,
+        path: targetDirectory,
+        recovery: "Run this command from a generated project, or pass its directory explicitly."
+      }
+    );
+  }
+  return matches[0];
+}
+export {
+  DEFAULT_TEMPLATE_ID,
+  createProcessInvocation,
+  createScaffoldPlan,
+  getTemplate,
+  resolveProjectTemplate,
+  resolveTemplateDirectory,
+  scaffoldProject,
+  selectJavaScriptPackageManager,
+  selectPythonPackageManager,
+  templateRegistry
+};
+//# sourceMappingURL=templates.js.map