@remotedraw/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,2985 @@
+import { existsSync, readFileSync } from "node:fs";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+import { emitKeypressEvents } from "node:readline";
+import { createInterface } from "node:readline/promises";
+import { createWizardTerminal, runSetupWizard, } from "./setup-wizard.js";
+import { assertEnvCanAcceptProvisioning, currentCliAccount, globalConfigPath, loginToRemoteDraw, logoutFromRemoteDraw, provisionRemoteDrawProject, remoteDrawApiBaseUrl, writeProvisionedProjectSetup, } from "./cloud.js";
+const packageMetadata = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+export const CLI_VERSION = typeof packageMetadata.version === "string"
+    ? packageMetadata.version
+    : "unknown";
+const targetChoices = ["web", "desktop", "ios", "headless"];
+const senderChoices = [
+    "remotedraw-ios",
+    "embedded-web",
+    "own-ios",
+    "headless",
+];
+const sdkChoices = ["react", "svelte", "js", "swift", "headless"];
+const presetChoices = [
+    "signature",
+    "initials",
+    "approval",
+    "sketch",
+    "photoMarkup",
+    "pdfMarkup",
+    "mapMarkup",
+    "screenMarkup",
+    "designReview",
+    "pointer",
+];
+const exampleChoices = [
+    "react-ios",
+    "react-owned-sender",
+    "raw-http",
+    "ios-owned-sender",
+];
+const packageManagerChoices = ["npm", "pnpm", "yarn", "bun"];
+const apiEndpointChoices = ["deployment", "local"];
+export function createNodeRuntime() {
+    const cwd = process.cwd();
+    const env = cliEnvironmentForWorkspace(cwd, process.env);
+    return {
+        cwd,
+        env,
+        isInteractive: Boolean(process.stdin.isTTY && process.stderr.isTTY),
+        exists: existsSync,
+        readFile: async (filePath) => {
+            return await readFile(filePath, "utf8");
+        },
+        writeFile,
+        writePrivateFile: async (filePath, contents) => {
+            await writeFile(filePath, contents, { encoding: "utf8", mode: 0o600 });
+        },
+        mkdir: async (dirPath) => {
+            await mkdir(dirPath, { recursive: true });
+        },
+        chmod,
+        fetch: globalThis.fetch.bind(globalThis),
+        openUrl: openExternalUrl,
+        notify(message) {
+            process.stderr.write(`${message}\n`);
+        },
+        prompts: createTerminalPrompter(process.stdin, process.stderr),
+        wizardTerminal: process.stdin.isTTY && process.stdout.isTTY
+            ? createWizardTerminal(process.stdin, process.stdout, env)
+            : undefined,
+    };
+}
+export function cliEnvironmentForWorkspace(cwd, env, exists = existsSync) {
+    if (env.REMOTEDRAW_API_BASE_URL || !env.CONVEX_SITE_URL)
+        return env;
+    const isRemoteDrawSourceWorkspace = exists(path.join(cwd, "convex/http.ts")) &&
+        exists(path.join(cwd, "packages/cli/src/index.ts"));
+    return isRemoteDrawSourceWorkspace
+        ? { ...env, REMOTEDRAW_API_BASE_URL: env.CONVEX_SITE_URL }
+        : env;
+}
+async function openExternalUrl(url) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        throw new Error("Only HTTP(S) URLs can be opened.");
+    }
+    const [command, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["cmd", ["/c", "start", "", url]]
+            : ["xdg-open", [url]];
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        child.once("error", reject);
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+    });
+}
+function createTerminalPrompter(input, output) {
+    return {
+        intro(title) {
+            output.write(`\n${style("bold", title)}\n`);
+        },
+        async text(options) {
+            const rl = createInterface({ input, output, terminal: true });
+            try {
+                while (true) {
+                    const defaultText = options.defaultValue == null
+                        ? ""
+                        : ` ${style("dim", `(${options.defaultValue})`)}`;
+                    const answer = await rl.question(`${style("cyan", "?")} ${options.message}${defaultText}: `);
+                    const value = answer.trim() || options.defaultValue || "";
+                    const validationError = options.validate?.(value);
+                    if (validationError == null)
+                        return value;
+                    output.write(`${style("dim", validationError)}\n`);
+                }
+            }
+            finally {
+                rl.close();
+            }
+        },
+        async select(options) {
+            return await terminalSelect(input, output, options);
+        },
+    };
+}
+function terminalSelect(input, output, options) {
+    if (options.choices.length === 0) {
+        throw new Error(`No choices available for ${options.message}.`);
+    }
+    if (!input.isTTY || !output.isTTY || !input.setRawMode) {
+        throw new Error("Interactive setup requires a TTY.");
+    }
+    const defaultIndex = Math.max(0, options.choices.findIndex((choiceOption) => choiceOption.value === options.defaultValue));
+    let selectedIndex = defaultIndex;
+    let renderedLines = 0;
+    const wasRaw = input.isRaw === true;
+    const wasFlowing = input.readableFlowing === true;
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            input.off("keypress", onKeypress);
+            if (!wasRaw)
+                input.setRawMode?.(false);
+            if (!wasFlowing)
+                input.pause();
+        };
+        const finish = () => {
+            const selected = options.choices[selectedIndex];
+            cleanup();
+            clearRendered(output, renderedLines);
+            output.write(`${style("cyan", "?")} ${options.message} ${style("green", selected.label)}\n`);
+            resolve(selected.value);
+        };
+        const fail = () => {
+            cleanup();
+            clearRendered(output, renderedLines);
+            output.write("\n");
+            reject(new Error("Prompt cancelled."));
+        };
+        const render = () => {
+            clearRendered(output, renderedLines);
+            const lines = selectPromptLines(options, selectedIndex);
+            output.write(`${lines.join("\n")}\n`);
+            renderedLines = lines.length;
+        };
+        function onKeypress(_inputText, key) {
+            if (key.sequence === "\u0003" || (key.ctrl && key.name === "c")) {
+                fail();
+                return;
+            }
+            if (key.name === "return" || key.name === "enter") {
+                finish();
+                return;
+            }
+            if (key.name === "down" || key.name === "j") {
+                selectedIndex = (selectedIndex + 1) % options.choices.length;
+                render();
+                return;
+            }
+            if (key.name === "up" || key.name === "k") {
+                selectedIndex =
+                    (selectedIndex - 1 + options.choices.length) % options.choices.length;
+                render();
+            }
+        }
+        emitKeypressEvents(input);
+        input.setRawMode(true);
+        input.resume();
+        input.on("keypress", onKeypress);
+        render();
+    });
+}
+function selectPromptLines(options, selectedIndex) {
+    const lines = [`${style("cyan", "?")} ${options.message}`];
+    if (options.helperText)
+        lines.push(style("dim", options.helperText));
+    for (const [index, choiceOption] of options.choices.entries()) {
+        const selected = index === selectedIndex;
+        const label = selected
+            ? style("bold", choiceOption.label)
+            : choiceOption.label;
+        const hint = choiceOption.hint ? ` ${style("dim", choiceOption.hint)}` : "";
+        lines.push(`${selected ? ">" : " "} ${label}${hint}`);
+    }
+    lines.push(style("dim", "Use up/down arrows, then Enter."));
+    return lines;
+}
+function clearRendered(output, lineCount) {
+    if (lineCount > 0)
+        output.write(`\x1b[${lineCount}F\x1b[0J`);
+}
+function style(kind, value) {
+    const codes = {
+        bold: "\x1b[1m",
+        cyan: "\x1b[36m",
+        dim: "\x1b[2m",
+        green: "\x1b[32m",
+    };
+    return `${codes[kind]}${value}\x1b[0m`;
+}
+export async function runCli(args, runtime = createNodeRuntime()) {
+    try {
+        const command = args[0];
+        const commandArgs = args.slice(1);
+        if (command == null) {
+            if (runtime.wizardTerminal) {
+                return await setupWizardCommand(runtime);
+            }
+            return ok(mainHelpText());
+        }
+        if (command === "--help" || command === "-h") {
+            return ok(mainHelpText());
+        }
+        if (command === "--version" || command === "-v") {
+            return ok(`${CLI_VERSION}\n`);
+        }
+        switch (command) {
+            case "guide":
+                return ok(guideText());
+            case "options":
+                return optionsCommand(commandArgs);
+            case "login":
+                return await loginCommand(commandArgs, runtime);
+            case "logout":
+                return await logoutCommand(commandArgs, runtime);
+            case "whoami":
+                return await whoamiCommand(commandArgs, runtime);
+            case "new":
+                return await newCommand(commandArgs, runtime);
+            case "init":
+                return await initCommand(commandArgs, runtime);
+            case "doctor":
+                return await doctorCommand(commandArgs, runtime);
+            case "dev":
+                return await devCommand(commandArgs, runtime);
+            case "create-input":
+                return await createInputCommand(commandArgs, runtime);
+            case "examples":
+                return await examplesCommand(commandArgs, runtime);
+            case "agent":
+                return await agentCommand(commandArgs, runtime);
+            default:
+                return requestedJsonOutput(args)
+                    ? jsonFailure(command, new Error(`Unknown command "${command}". Run remotedraw --help.`))
+                    : fail(`Unknown command "${command}". Run remotedraw --help.`);
+        }
+    }
+    catch (error) {
+        return requestedJsonOutput(args)
+            ? jsonFailure(args[0] ?? "help", error)
+            : fail(errorMessage(error));
+    }
+}
+async function setupWizardCommand(runtime) {
+    const terminal = runtime.wizardTerminal;
+    if (!terminal)
+        return ok(mainHelpText());
+    if (!cloudSetupDisabled(runtime)) {
+        const apiBaseUrl = remoteDrawApiBaseUrl(runtime.env);
+        await loginToRemoteDraw(runtime, apiBaseUrl);
+    }
+    const result = await runSetupWizard({
+        definition: projectSetupDefinition(),
+        terminal,
+        execute: async (values) => {
+            const plan = planFromWizardValues(values);
+            const outputDir = path.resolve(runtime.cwd, plan.slug);
+            await assertProjectFilesWritable(newProjectFiles(plan), outputDir, runtime, false, false);
+            const provisioning = await maybeProvisionProject(plan, outputDir, runtime, { force: false, dryRun: false, offline: cloudSetupDisabled(runtime) });
+            await createRemoteDrawProject(plan, outputDir, runtime);
+            if (provisioning) {
+                await writeProvisionedProjectSetup(runtime, outputDir, provisioning, false);
+            }
+            return {
+                path: outputDir,
+                nextCommand: `cd ${shellQuote(outputDir)} && ${installCommand(plan.packageManager)}`,
+            };
+        },
+    });
+    return { exitCode: result.exitCode, stdout: "" };
+}
+function ok(stdout) {
+    return { exitCode: 0, stdout: ensureTrailingNewline(stdout) };
+}
+function jsonResult(value, exitCode = 0) {
+    return {
+        exitCode,
+        stdout: `${JSON.stringify(value, null, 2)}\n`,
+    };
+}
+function jsonFailure(command, error) {
+    const message = errorMessage(error);
+    const code = message.includes("required")
+        ? "MISSING_ARGUMENT"
+        : message.includes(" requires ") || message.includes("only supported")
+            ? "INVALID_COMBINATION"
+            : message.startsWith("Unknown") || message.startsWith("Expected")
+                ? "INVALID_ARGUMENT"
+                : message.startsWith("Refusing to overwrite")
+                    ? "FILE_CONFLICT"
+                    : message.includes("logged in")
+                        ? "AUTH_REQUIRED"
+                        : "COMMAND_FAILED";
+    return jsonResult({ ok: false, command, error: { code, message } }, 1);
+}
+function requestedJsonOutput(args) {
+    return args.some((argument, index) => argument === "--format=json" ||
+        (argument === "--format" && args[index + 1] === "json"));
+}
+function outputFormat(parsed) {
+    return choice(readString(parsed, "format") ?? "text", ["text", "json"], "format");
+}
+function fail(message) {
+    return { exitCode: 1, stdout: "", stderr: ensureTrailingNewline(message) };
+}
+function ensureTrailingNewline(value) {
+    return value.endsWith("\n") ? value : `${value}\n`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function mainHelpText() {
+    return [
+        "RemoteDraw CLI",
+        "",
+        "Usage:",
+        "  remotedraw <command> [options]",
+        "",
+        "Commands:",
+        "  guide          Choose an integration path and SDK.",
+        "  options        Print setup choices and compatibility metadata.",
+        "  login          Authorize this computer through the dashboard.",
+        "  logout         Revoke and remove this computer's CLI credential.",
+        "  whoami         Show the signed-in RemoteDraw account.",
+        "  new            Create a new app with RemoteDraw starter code.",
+        "  init           Add RemoteDraw starter code to an existing project.",
+        "  dev            Print the local sandbox workflow for an integration.",
+        "  doctor         Check project config, packages, and environment variables.",
+        "  create-input   Create or print a test input request payload.",
+        "  examples       List or install example projects.",
+        "  agent          Print or install the RemoteDraw agent skill.",
+        "",
+        "Start here:",
+        "  remotedraw guide",
+        "  remotedraw login",
+        "  remotedraw new",
+        "  remotedraw new --app-name MijnApp --target web --sender remotedraw-ios --sdk react",
+        "  remotedraw init --target web --sender embedded-web --sdk react",
+    ].join("\n");
+}
+function optionsCommand(args) {
+    const parsed = parseArgs(args, {
+        values: ["format"],
+        booleans: ["help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(optionsHelpText());
+    const catalog = agentOptionCatalog();
+    if (outputFormat(parsed) === "json")
+        return jsonResult(catalog);
+    return ok([
+        "RemoteDraw setup options",
+        "",
+        ...catalog.fields.flatMap((field) => [
+            `${field.label} (${field.flag})`,
+            ...field.options.map((option) => `  ${option.value}: ${option.details.summary}`),
+            "",
+        ]),
+        "For machine-readable metadata: remotedraw options --format json",
+    ].join("\n"));
+}
+function guideText() {
+    return [
+        "RemoteDraw integration guide",
+        "",
+        "Choose the surface your customer already has:",
+        "  Web app receiver + RemoteDraw iOS app sender",
+        "    remotedraw init --target web --sender remotedraw-ios --sdk react --preset signature",
+        "",
+        "  Web app receiver + your own web sender UI",
+        "    remotedraw init --target web --sender embedded-web --sdk react --preset sketch",
+        "",
+        "  Svelte app receiver + RemoteDraw iOS app sender",
+        "    remotedraw init --target web --sender remotedraw-ios --sdk svelte --preset signature",
+        "",
+        "  Desktop app receiver with raw HTTP",
+        "    remotedraw init --target desktop --sender remotedraw-ios --sdk js --preset sketch",
+        "",
+        "  Your own iOS sender app",
+        "    remotedraw init --target ios --sender own-ios --sdk swift --preset sketch",
+        "",
+        "API keys stay on trusted backend code. Receivers get receiver tokens, senders get join URLs or sender tokens.",
+        "remotedraw new and init create a dashboard project, mint a project-scoped development API key, and write it to .env.local by default.",
+        "Use --offline when you intentionally want local scaffolding only.",
+    ].join("\n");
+}
+async function loginCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: ["api-base-url", "device-name"],
+        booleans: ["force", "no-open", "help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(loginHelpText());
+    const apiBaseUrl = remoteDrawApiBaseUrl(runtime.env, readString(parsed, "api-base-url"));
+    const deviceName = readString(parsed, "device-name");
+    const result = await loginToRemoteDraw(runtime, apiBaseUrl, {
+        force: parsed.booleans.has("force"),
+        openBrowser: !parsed.booleans.has("no-open"),
+        ...(deviceName == null ? {} : { deviceName }),
+    });
+    return ok([
+        result.alreadyLoggedIn
+            ? "Already logged in."
+            : "RemoteDraw login complete.",
+        accountSummary(result.account),
+        `Credential: ${globalConfigPath(runtime)}`,
+    ].join("\n"));
+}
+async function logoutCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: ["api-base-url"],
+        booleans: ["help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(logoutHelpText());
+    const apiBaseUrl = remoteDrawApiBaseUrl(runtime.env, readString(parsed, "api-base-url"));
+    const result = await logoutFromRemoteDraw(runtime, apiBaseUrl);
+    return ok(result.hadCredential
+        ? `Logged out from ${apiBaseUrl}.`
+        : `No stored credential for ${apiBaseUrl}.`);
+}
+async function whoamiCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: ["api-base-url"],
+        booleans: ["help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(whoamiHelpText());
+    const apiBaseUrl = remoteDrawApiBaseUrl(runtime.env, readString(parsed, "api-base-url"));
+    const account = await currentCliAccount(runtime, apiBaseUrl);
+    if (!account) {
+        return fail(`Not logged in to ${apiBaseUrl}. Run remotedraw login.`);
+    }
+    return ok([accountSummary(account), `API: ${apiBaseUrl}`].join("\n"));
+}
+function accountSummary(account) {
+    const identity = account.email || account.name || "RemoteDraw user";
+    return `${identity} (${account.tenantSlug})`;
+}
+async function newCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: [
+            "app-name",
+            "path",
+            "target",
+            "sender",
+            "sdk",
+            "preset",
+            "api-base-url",
+            "package-manager",
+            "format",
+        ],
+        booleans: ["force", "dry-run", "offline", "non-interactive", "help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(newHelpText());
+    const format = outputFormat(parsed);
+    const plan = !parsed.booleans.has("non-interactive") &&
+        shouldPromptForNewProject(parsed, runtime)
+        ? await promptForNewProject(parsed, runtime)
+        : planFromArgs(parsed, {
+            appNameRequired: true,
+            defaultAppName: "RemoteDraw app",
+        });
+    const outputDir = resolveOutputDir(runtime.cwd, parsed, plan.slug);
+    const dryRun = parsed.booleans.has("dry-run");
+    const force = parsed.booleans.has("force");
+    const offline = parsed.booleans.has("offline") || cloudSetupDisabled(runtime);
+    const commandRuntime = parsed.booleans.has("non-interactive")
+        ? { ...runtime, isInteractive: false }
+        : runtime;
+    await assertProjectFilesWritable(newProjectFiles(plan), outputDir, runtime, dryRun, force);
+    const provisioning = await maybeProvisionProject(plan, outputDir, commandRuntime, { dryRun, force, offline });
+    const written = await createRemoteDrawProject(plan, outputDir, runtime, {
+        dryRun,
+        force,
+    });
+    if (provisioning) {
+        await writeProvisionedProjectSetup(runtime, outputDir, provisioning, force);
+        written.push(".env.local", ".gitignore cloud secret rule");
+    }
+    return format === "json"
+        ? jsonResult(scaffoldJsonResult("new", plan, outputDir, written, parsed, provisioning, offline, dryRun))
+        : ok(scaffoldSummary("Created", plan, outputDir, written, dryRun) +
+            cloudSetupSummary(provisioning, offline, dryRun));
+}
+export async function createRemoteDrawProject(plan, outputDir, runtime, options = {}) {
+    validatePlan(plan);
+    return await writeProjectFiles(newProjectFiles(plan), outputDir, runtime, {
+        dryRun: options.dryRun ?? false,
+        force: options.force ?? false,
+    });
+}
+async function initCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: [
+            "app-name",
+            "path",
+            "target",
+            "sender",
+            "sdk",
+            "preset",
+            "api-base-url",
+            "package-manager",
+            "format",
+        ],
+        booleans: ["force", "dry-run", "offline", "non-interactive", "help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(initHelpText());
+    const format = outputFormat(parsed);
+    const outputDir = resolveOutputDir(runtime.cwd, parsed);
+    const defaultAppName = path.basename(outputDir);
+    const plan = planFromArgs(parsed, {
+        appNameRequired: false,
+        defaultAppName,
+    });
+    const dryRun = parsed.booleans.has("dry-run");
+    const force = parsed.booleans.has("force");
+    const offline = parsed.booleans.has("offline") || cloudSetupDisabled(runtime);
+    const commandRuntime = parsed.booleans.has("non-interactive")
+        ? { ...runtime, isInteractive: false }
+        : runtime;
+    const files = initProjectFiles(plan, await hasPackageJson(outputDir, runtime));
+    await assertProjectFilesWritable(files, outputDir, runtime, dryRun, force);
+    const provisioning = await maybeProvisionProject(plan, outputDir, commandRuntime, { dryRun, force, offline });
+    const written = await writeProjectFiles(files, outputDir, runtime, {
+        dryRun,
+        force,
+    });
+    if (!dryRun)
+        await updatePackageJson(outputDir, plan, runtime);
+    if (dryRun)
+        written.push("package.json dependency check");
+    if (provisioning) {
+        await writeProvisionedProjectSetup(runtime, outputDir, provisioning, force);
+        written.push(".env.local", ".gitignore cloud secret rule");
+    }
+    return format === "json"
+        ? jsonResult(scaffoldJsonResult("init", plan, outputDir, written, parsed, provisioning, offline, dryRun))
+        : ok(scaffoldSummary("Initialized", plan, outputDir, written, dryRun) +
+            cloudSetupSummary(provisioning, offline, dryRun));
+}
+function cloudSetupDisabled(runtime) {
+    return runtime.env.REMOTEDRAW_CLI_OFFLINE === "1";
+}
+async function maybeProvisionProject(plan, outputDir, runtime, options) {
+    if (options.dryRun || options.offline)
+        return undefined;
+    const apiBaseUrl = remoteDrawApiBaseUrl(runtime.env, plan.apiBaseUrl);
+    await assertEnvCanAcceptProvisioning(runtime, outputDir, apiBaseUrl, options.force);
+    const provisioning = await provisionRemoteDrawProject(runtime, apiBaseUrl, {
+        name: plan.appName,
+        keyName: `${plan.appName} development`,
+    });
+    plan.apiBaseUrl = provisioning.apiBaseUrl;
+    return provisioning;
+}
+function cloudSetupSummary(provisioning, offline, dryRun) {
+    if (dryRun)
+        return "";
+    if (offline) {
+        return "\n\nCloud setup skipped (--offline). Run remotedraw init later to create a dashboard project.";
+    }
+    if (!provisioning)
+        return "";
+    return [
+        "",
+        "",
+        `Dashboard project: ${provisioning.project.dashboardUrl}`,
+        "Development API key: written to .env.local (server-side only)",
+        `Project ID: ${provisioning.project.id}`,
+    ].join("\n");
+}
+const DOCTOR_PROBE_TIMEOUT_MS = 8_000;
+function probeFailureMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function probeApiHealth(runtime, apiBaseUrl) {
+    if (!runtime.fetch) {
+        return { ok: false, message: "this runtime cannot make network requests" };
+    }
+    try {
+        const response = await runtime.fetch(`${apiBaseUrl}/health`, {
+            method: "GET",
+            signal: AbortSignal.timeout(DOCTOR_PROBE_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            return { ok: false, message: `HTTP ${response.status}` };
+        }
+        return { ok: true, message: "ok" };
+    }
+    catch (error) {
+        return { ok: false, message: probeFailureMessage(error) };
+    }
+}
+/**
+ * Validates the key with a read-only call. `/v1/sessions/list` needs only
+ * `sessions:read` and creates nothing, so doctor never consumes a credit to
+ * tell a developer their key works.
+ */
+async function probeApiKey(runtime, apiBaseUrl, apiKey) {
+    if (!runtime.fetch) {
+        return { ok: false, message: "This runtime cannot make network requests." };
+    }
+    try {
+        const response = await runtime.fetch(`${apiBaseUrl}/v1/sessions/list`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ limit: 1 }),
+            signal: AbortSignal.timeout(DOCTOR_PROBE_TIMEOUT_MS),
+        });
+        const raw = await response.text();
+        let payload;
+        try {
+            payload = raw ? JSON.parse(raw) : {};
+        }
+        catch {
+            return {
+                ok: false,
+                message: `Deployment returned a non-JSON response (HTTP ${response.status}).`,
+            };
+        }
+        if (!response.ok) {
+            const message = typeof payload === "object" &&
+                payload !== null &&
+                "error" in payload &&
+                typeof payload.error?.message ===
+                    "string"
+                ? payload.error.message
+                : `Deployment rejected the key (HTTP ${response.status}).`;
+            return { ok: false, message };
+        }
+        const items = typeof payload === "object" && payload !== null && "items" in payload
+            ? payload.items
+            : undefined;
+        return { ok: true, sessionCount: Array.isArray(items) ? items.length : 0 };
+    }
+    catch (error) {
+        return { ok: false, message: probeFailureMessage(error) };
+    }
+}
+async function doctorCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: ["path", "format"],
+        booleans: ["help", "offline"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(doctorHelpText());
+    const format = outputFormat(parsed);
+    const offline = parsed.booleans.has("offline") ||
+        runtime.env.REMOTEDRAW_CLI_OFFLINE === "1";
+    const dir = resolveOutputDir(runtime.cwd, parsed);
+    const projectEnv = await environmentForProject(dir, runtime);
+    const configPath = path.join(dir, "remotedraw.config.json");
+    const packagePath = path.join(dir, "package.json");
+    const envApiBaseUrl = projectEnv.REMOTEDRAW_API_BASE_URL;
+    const normalizedEnvApiBaseUrl = envApiBaseUrl == null || !isHttpOrigin(envApiBaseUrl)
+        ? undefined
+        : normalizedOrigin(envApiBaseUrl);
+    const envApiKey = projectEnv.REMOTEDRAW_API_KEY;
+    const lines = ["RemoteDraw doctor", ""];
+    const checks = [];
+    const addCheck = (state, label, message) => {
+        checks.push({ state, label, message });
+        lines.push(statusLine(state, label, message));
+    };
+    const hasConfig = await runtime.exists(configPath);
+    addCheck(hasConfig ? "ok" : "warn", "remotedraw.config.json", hasConfig
+        ? "Project is linked to a local integration profile."
+        : "Run remotedraw init to create one.");
+    const packageJson = (await runtime.exists(packagePath))
+        ? await readJsonFile(packagePath, runtime)
+        : null;
+    addCheck(packageJson ? "ok" : "warn", "package.json", packageJson
+        ? "Package metadata found."
+        : "No package.json found in this directory.");
+    const config = hasConfig ? await readJsonFile(configPath, runtime) : null;
+    const sdk = stringFromRecord(config, "sdk");
+    if (sdk === "react") {
+        addCheck(hasDependency(packageJson, "@remotedraw/react") ? "ok" : "warn", "@remotedraw/react", hasDependency(packageJson, "@remotedraw/react")
+            ? "React SDK dependency is installed in package.json."
+            : "Install @remotedraw/react or rerun remotedraw init.");
+    }
+    addCheck(normalizedEnvApiBaseUrl ? "ok" : "warn", "REMOTEDRAW_API_BASE_URL", normalizedEnvApiBaseUrl
+        ? `Using ${normalizedEnvApiBaseUrl}.`
+        : "Set this to your Convex site origin, for example https://<deployment>.convex.site.");
+    addCheck(envApiKey?.startsWith("rd_sk_") ? "ok" : "warn", "REMOTEDRAW_API_KEY", envApiKey?.startsWith("rd_sk_")
+        ? "Server-side API key shape looks correct."
+        : "Keep an rd_sk_... key in backend secrets only.");
+    // The checks above only prove the strings look right. A revoked key, a URL
+    // pointing at the wrong deployment, and an exhausted credit balance all pass
+    // them, so doctor also asks the deployment itself.
+    if (offline) {
+        addCheck("warn", "deployment", "Skipped network checks (--offline). Rerun without --offline to verify the key against the deployment.");
+    }
+    else if (!normalizedEnvApiBaseUrl) {
+        addCheck("warn", "deployment", "Skipped network checks because REMOTEDRAW_API_BASE_URL is not set.");
+    }
+    else {
+        const health = await probeApiHealth(runtime, normalizedEnvApiBaseUrl);
+        addCheck(health.ok ? "ok" : "error", "deployment reachable", health.ok
+            ? `${normalizedEnvApiBaseUrl} answered /health.`
+            : `${normalizedEnvApiBaseUrl} did not answer /health: ${health.message}`);
+        if (!envApiKey?.startsWith("rd_sk_")) {
+            addCheck("warn", "API key accepted", "Skipped because no rd_sk_... key was found in this project's environment.");
+        }
+        else if (!health.ok) {
+            addCheck("warn", "API key accepted", "Skipped because the deployment did not answer.");
+        }
+        else {
+            const probe = await probeApiKey(runtime, normalizedEnvApiBaseUrl, envApiKey);
+            addCheck(probe.ok ? "ok" : "error", "API key accepted", probe.ok
+                ? `Key is live. ${probe.sessionCount} recent API ${probe.sessionCount === 1 ? "session" : "sessions"} visible.`
+                : probe.message);
+        }
+    }
+    return format === "json"
+        ? jsonResult({
+            ok: true,
+            command: "doctor",
+            directory: dir,
+            healthy: checks.every((check) => check.state === "ok"),
+            checks,
+        })
+        : ok(lines.join("\n"));
+}
+async function devCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: ["api-base-url", "path"],
+        booleans: ["help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(devHelpText());
+    const dir = resolveOutputDir(runtime.cwd, parsed);
+    const projectEnv = await environmentForProject(dir, runtime);
+    const apiBaseUrl = readString(parsed, "api-base-url") ??
+        projectEnv.REMOTEDRAW_API_BASE_URL ??
+        "http://localhost:3210";
+    return ok([
+        "RemoteDraw local development workflow",
+        "",
+        `API base URL: ${apiBaseUrl}`,
+        "",
+        "1. Start the RemoteDraw API/web service for local testing.",
+        "   Inside this repository: bun run dev:codex",
+        "",
+        "2. Start your app's dev server.",
+        "   Use the package manager and dev script generated by remotedraw new/init.",
+        "",
+        "3. Create a test input request from trusted backend code.",
+        `   remotedraw create-input --preset signature --api-base-url ${apiBaseUrl}`,
+        "",
+        "4. Show the returned HTTPS joinUrl in your receiver UI.",
+        "   Use the RemoteDraw iOS app for remotedraw-ios sender flows, or EmbeddedSender for owned web sender flows.",
+    ].join("\n"));
+}
+async function createInputCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: [
+            "preset",
+            "label",
+            "external-id",
+            "api-base-url",
+            "api-key",
+            "expires-in-ms",
+        ],
+        booleans: ["json", "curl", "execute", "help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(createInputHelpText());
+    const projectEnv = await environmentForProject(runtime.cwd, runtime);
+    const preset = choice(readString(parsed, "preset") ?? "signature", presetChoices, "preset");
+    const apiBaseUrl = readString(parsed, "api-base-url") ??
+        projectEnv.REMOTEDRAW_API_BASE_URL ??
+        "https://<deployment>.convex.site";
+    const payload = createSessionPayload({
+        preset,
+        label: readString(parsed, "label") ?? labelForPreset(preset),
+        externalId: readString(parsed, "external-id") ?? `cli-${preset}`,
+        expiresInMs: optionalInteger(readString(parsed, "expires-in-ms")),
+    });
+    if (parsed.booleans.has("execute")) {
+        const apiKey = readString(parsed, "api-key") ?? projectEnv.REMOTEDRAW_API_KEY;
+        if (!runtime.fetch)
+            throw new Error("This runtime cannot execute HTTP requests.");
+        if (!apiKey?.startsWith("rd_sk_")) {
+            throw new Error("create-input --execute requires --api-key or REMOTEDRAW_API_KEY with an rd_sk_... server key.");
+        }
+        const response = await runtime.fetch(`${normalizedOrigin(apiBaseUrl)}/v1/sessions`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        const text = await response.text();
+        if (!response.ok)
+            throw new Error(text || `RemoteDraw API returned ${response.status}.`);
+        return ok(text);
+    }
+    if (parsed.booleans.has("json")) {
+        return ok(JSON.stringify(payload, null, 2));
+    }
+    return ok([
+        "RemoteDraw test input request",
+        "",
+        "Create this from trusted backend code. Do not run API-key requests in a browser client.",
+        "",
+        curlForCreateInput(apiBaseUrl, payload),
+        "",
+        "Use --json to print only the request body or --execute to call the API with REMOTEDRAW_API_KEY.",
+    ].join("\n"));
+}
+async function examplesCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: ["install", "path", "app-name", "package-manager"],
+        booleans: ["list", "force", "dry-run", "help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(examplesHelpText());
+    const example = readString(parsed, "install");
+    if (example == null || parsed.booleans.has("list")) {
+        return ok([
+            "RemoteDraw examples",
+            "",
+            "  react-ios           Web receiver using the RemoteDraw iOS app as sender.",
+            "  react-owned-sender  Web receiver plus EmbeddedSender for owned web input.",
+            "  raw-http            Package-free backend/receiver/sender route fixtures.",
+            "  ios-owned-sender    Swift join-link and sender request helper starter.",
+            "",
+            "Install one:",
+            "  remotedraw examples --install react-ios --path ./remotedraw-react-ios",
+        ].join("\n"));
+    }
+    const installedExample = choice(example, exampleChoices, "example");
+    const defaults = planDefaultsForExample(installedExample);
+    const outputDir = resolveOutputDir(runtime.cwd, parsed, installedExample);
+    const plan = planFromArgs(parsed, {
+        appNameRequired: false,
+        defaultAppName: readString(parsed, "app-name") ?? titleCase(installedExample),
+        defaults,
+    });
+    const files = newProjectFiles(plan);
+    const dryRun = parsed.booleans.has("dry-run");
+    const written = await writeProjectFiles(files, outputDir, runtime, {
+        dryRun,
+        force: parsed.booleans.has("force"),
+    });
+    return ok(scaffoldSummary("Installed example", plan, outputDir, written, dryRun));
+}
+async function agentCommand(args, runtime) {
+    const parsed = parseArgs(args, {
+        values: ["path"],
+        booleans: ["print-skill", "dry-run", "force", "help"],
+    });
+    if (parsed.booleans.has("help"))
+        return ok(agentHelpText());
+    if (parsed.booleans.has("print-skill"))
+        return ok(agentSkillMarkdown());
+    const targetDir = readString(parsed, "path");
+    if (targetDir == null) {
+        return ok([
+            "RemoteDraw agent setup",
+            "",
+            "Use this when an AI coding agent needs to add RemoteDraw to a customer app.",
+            "",
+            "Print the skill:",
+            "  remotedraw agent --print-skill",
+            "",
+            "Install the skill file:",
+            "  remotedraw agent --path ~/.codex/skills/remotedraw",
+        ].join("\n"));
+    }
+    const outputDir = resolveAgentPath(targetDir, runtime);
+    const outputFile = path.join(outputDir, "SKILL.md");
+    if (!parsed.booleans.has("dry-run") &&
+        !parsed.booleans.has("force") &&
+        (await runtime.exists(outputFile))) {
+        throw new Error("SKILL.md already exists. Pass --force to replace it.");
+    }
+    if (!parsed.booleans.has("dry-run")) {
+        await runtime.mkdir(outputDir);
+        await runtime.writeFile(outputFile, agentSkillMarkdown());
+    }
+    return ok([
+        parsed.booleans.has("dry-run")
+            ? `Would write ${outputFile}`
+            : `Installed RemoteDraw agent skill at ${outputFile}`,
+        "",
+        "Next:",
+        "  Ask your agent to use the RemoteDraw skill before editing API, CLI, sender, receiver, or iOS integration code.",
+    ].join("\n"));
+}
+function newHelpText() {
+    return [
+        "Usage:",
+        "  remotedraw new",
+        "  remotedraw new --app-name <name> [options]",
+        "",
+        "Run without options for the interactive setup flow.",
+        "",
+        "Options:",
+        "  --path <dir>              Output directory. Defaults to an app-name slug.",
+        "  --target <kind>           web, desktop, ios, or headless.",
+        "  --sender <kind>           remotedraw-ios, embedded-web, own-ios, or headless.",
+        "  --sdk <kind>              react, svelte, js, swift, or headless.",
+        "  --preset <kind>           signature or sketch. Legacy API presets remain accepted for existing integrations.",
+        "  --package-manager <name>  npm, pnpm, yarn, or bun.",
+        "  --api-base-url <url>      Default API origin for generated config.",
+        "  --force                   Overwrite generated files and existing RemoteDraw .env.local values.",
+        "  --offline                 Scaffold locally without login, dashboard project, or API key creation.",
+        "  --non-interactive         Never prompt; fail when required input is missing.",
+        "  --format <text|json>      Human-readable or machine-readable result.",
+        "  --dry-run                 Print files that would be written.",
+    ].join("\n");
+}
+function initHelpText() {
+    return [
+        "Usage:",
+        "  remotedraw init [options]",
+        "",
+        "Options match remotedraw new. init writes remotedraw.config.json, .env.example, and src/remotedraw starter files into an existing project.",
+    ].join("\n");
+}
+function loginHelpText() {
+    return [
+        "Authorize the RemoteDraw CLI",
+        "",
+        "Usage:",
+        "  remotedraw login [--no-open] [--force] [--api-base-url <origin>]",
+        "",
+        "The browser confirms your account. A revocable CLI credential is stored in your user config directory, never in the project.",
+    ].join("\n");
+}
+function logoutHelpText() {
+    return [
+        "Revoke the RemoteDraw CLI credential",
+        "",
+        "Usage:",
+        "  remotedraw logout [--api-base-url <origin>]",
+    ].join("\n");
+}
+function whoamiHelpText() {
+    return [
+        "Show the active RemoteDraw CLI account",
+        "",
+        "Usage:",
+        "  remotedraw whoami [--api-base-url <origin>]",
+    ].join("\n");
+}
+function doctorHelpText() {
+    return [
+        "Usage:",
+        "  remotedraw doctor [--path <dir>] [--format text|json] [--offline]",
+        "",
+        "Checks local config, package.json dependencies, and the REMOTEDRAW_API_BASE_URL / REMOTEDRAW_API_KEY environment variables.",
+        "Then reaches the deployment: GET /health, and a free POST /v1/sessions/list to confirm the API key is live.",
+        "Pass --offline to skip the network checks.",
+    ].join("\n");
+}
+function optionsHelpText() {
+    return [
+        "Usage:",
+        "  remotedraw options [--format text|json]",
+        "",
+        "Prints every setup choice, compatibility rule, default, explanation, and documentation URL.",
+    ].join("\n");
+}
+function devHelpText() {
+    return [
+        "Usage:",
+        "  remotedraw dev [--api-base-url <url>]",
+        "",
+        "Prints the local test workflow for pairing, input request creation, and receiver rendering.",
+    ].join("\n");
+}
+function createInputHelpText() {
+    return [
+        "Usage:",
+        "  remotedraw create-input [--preset signature] [--json|--curl|--execute]",
+        "",
+        "Options:",
+        "  --preset <kind>       Session/input preset.",
+        "  --label <text>        Receiver target label.",
+        "  --external-id <id>    App-owned correlation id.",
+        "  --api-base-url <url>  RemoteDraw API origin.",
+        "  --api-key <key>       Server API key for --execute.",
+        "  --expires-in-ms <n>   Optional session TTL.",
+    ].join("\n");
+}
+function examplesHelpText() {
+    return [
+        "Usage:",
+        "  remotedraw examples [--list]",
+        "  remotedraw examples --install <example> --path <dir>",
+        "",
+        `Examples: ${exampleChoices.join(", ")}`,
+    ].join("\n");
+}
+function agentHelpText() {
+    return [
+        "Usage:",
+        "  remotedraw agent",
+        "  remotedraw agent --print-skill",
+        "  remotedraw agent --path <dir> [--force] [--dry-run]",
+        "",
+        "Writes a SKILL.md file that tells coding agents how to choose an SDK, use the CLI, keep API keys server-side, and verify RemoteDraw integrations.",
+    ].join("\n");
+}
+function parseArgs(args, allowed) {
+    const values = new Map();
+    const booleans = new Set();
+    const positionals = [];
+    const valueFlags = new Set(allowed.values);
+    const booleanFlags = new Set(allowed.booleans);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg == null)
+            continue;
+        if (!arg.startsWith("--")) {
+            positionals.push(arg);
+            continue;
+        }
+        const withoutPrefix = arg.slice(2);
+        const equalsIndex = withoutPrefix.indexOf("=");
+        const name = equalsIndex === -1 ? withoutPrefix : withoutPrefix.slice(0, equalsIndex);
+        const inlineValue = equalsIndex === -1 ? undefined : withoutPrefix.slice(equalsIndex + 1);
+        if (booleanFlags.has(name)) {
+            if (inlineValue != null) {
+                throw new Error(`--${name} does not accept a value.`);
+            }
+            booleans.add(name);
+            continue;
+        }
+        if (!valueFlags.has(name)) {
+            throw new Error(`Unsupported option "--${name}".`);
+        }
+        const value = inlineValue ?? args[index + 1];
+        if (value == null || value.startsWith("--")) {
+            throw new Error(`--${name} requires a value.`);
+        }
+        values.set(name, value);
+        if (inlineValue == null)
+            index += 1;
+    }
+    return { values, booleans, positionals };
+}
+function readString(parsed, name) {
+    const value = parsed.values.get(name);
+    return value == null || value.trim() === "" ? undefined : value.trim();
+}
+function optionalInteger(value) {
+    if (value == null)
+        return undefined;
+    const number = Number(value);
+    if (!Number.isInteger(number) || number <= 0) {
+        throw new Error("--expires-in-ms requires a positive integer.");
+    }
+    return number;
+}
+function shouldPromptForNewProject(parsed, runtime) {
+    if (!runtime.prompts || runtime.isInteractive !== true)
+        return false;
+    return ["app-name", "target", "sender", "sdk"].some((name) => readString(parsed, name) == null);
+}
+async function promptForNewProject(parsed, runtime) {
+    const prompts = runtime.prompts;
+    if (!prompts) {
+        return planFromArgs(parsed, {
+            appNameRequired: true,
+            defaultAppName: "RemoteDraw app",
+        });
+    }
+    await prompts.intro?.("RemoteDraw project setup");
+    const appName = readString(parsed, "app-name") ??
+        (await prompts.text({
+            message: "Project name",
+            defaultValue: "RemoteDraw App",
+            validate: validateProjectName,
+        }));
+    const target = readString(parsed, "target") == null
+        ? await prompts.select({
+            message: "Project type",
+            defaultValue: "web",
+            choices: targetPromptChoices(),
+        })
+        : choice(readString(parsed, "target"), targetChoices, "target");
+    const sender = readString(parsed, "sender") == null
+        ? await promptForSender(prompts, target)
+        : choice(readString(parsed, "sender"), senderChoices, "sender");
+    const sdk = readString(parsed, "sdk") == null
+        ? await promptForSdk(prompts, target, sender)
+        : choice(readString(parsed, "sdk"), sdkChoices, "sdk");
+    const preset = readString(parsed, "preset") == null
+        ? await prompts.select({
+            message: "Starter experience",
+            defaultValue: "signature",
+            choices: presetPromptChoices(),
+        })
+        : choice(readString(parsed, "preset"), presetChoices, "preset");
+    const packageManager = readString(parsed, "package-manager") == null
+        ? await prompts.select({
+            message: "Package manager",
+            defaultValue: "npm",
+            choices: packageManagerPromptChoices(),
+        })
+        : choice(readString(parsed, "package-manager"), packageManagerChoices, "package-manager");
+    const apiBaseUrl = readString(parsed, "api-base-url") ??
+        apiBaseUrlForEndpoint(await prompts.select({
+            message: "API endpoint",
+            helperText: "Use the placeholder unless you are wiring local dev now.",
+            defaultValue: "deployment",
+            choices: apiEndpointPromptChoices(),
+        }));
+    validatePlan({ target, sender, sdk });
+    return {
+        appName,
+        slug: slugify(appName),
+        target,
+        sender,
+        sdk,
+        preset,
+        apiBaseUrl,
+        packageManager,
+    };
+}
+function validateProjectName(value) {
+    return value.trim() === "" ? "Enter a project name." : undefined;
+}
+async function promptForSender(prompts, target) {
+    const choices = senderPromptChoices(target);
+    return await prompts.select({
+        message: "Phone sender",
+        helperText: "Choose where drawing input will run.",
+        defaultValue: defaultPromptValue(defaultSenderForTarget(target), choices),
+        choices,
+    });
+}
+async function promptForSdk(prompts, target, sender) {
+    const choices = sdkPromptChoices(target, sender);
+    return await prompts.select({
+        message: "UI framework / SDK",
+        helperText: "Pick the SDK that matches your receiver UI.",
+        defaultValue: defaultPromptValue(defaultSdkForChoices(target, sender), choices),
+        choices,
+    });
+}
+function defaultPromptValue(preferred, choices) {
+    return choices.some((choiceOption) => choiceOption.value === preferred)
+        ? preferred
+        : choices[0].value;
+}
+function targetPromptChoices() {
+    return [
+        { value: "web", label: "Web app" },
+        { value: "desktop", label: "Desktop or custom app" },
+        { value: "ios", label: "iOS sender app" },
+        { value: "headless", label: "Headless service" },
+    ];
+}
+const DOCS_INTEGRATION_PATHS = "https://docs.remotedraw.com/docs#paths";
+const DOCS_SDKS = "https://docs.remotedraw.com/docs/sdks#components";
+const DOCS_PAYLOADS = "https://docs.remotedraw.com/docs/api#payloads";
+const DOCS_ENDPOINTS = "https://docs.remotedraw.com/docs/api#endpoints";
+const DOCS_AUTH = "https://docs.remotedraw.com/docs/api#auth";
+const targetWizardDetails = {
+    web: {
+        summary: "Voor webapps met een tekenoppervlak in de browser.",
+        explanation: "Kies dit als je website of webapp de tekeningen toont. De telefoon kan de RemoteDraw-iOS-app of een ingebouwde webzender gebruiken.",
+        docsUrl: DOCS_INTEGRATION_PATHS,
+        docsLabel: "Webapp-docs openen",
+    },
+    desktop: {
+        summary: "Voor desktopapps en andere maatwerkinterfaces.",
+        explanation: "Kies dit voor Electron, Tauri, een native desktopapp of een bestaande niet-webinterface. Je koppelt de ontvanger via de JavaScript-client of HTTP-API.",
+        docsUrl: DOCS_INTEGRATION_PATHS,
+        docsLabel: "Desktop-docs openen",
+    },
+    ios: {
+        summary: "Voor een eigen iOS-app die als telefoonzender werkt.",
+        explanation: "Kies dit als je zelf de native tekenervaring, navigatie en vormgeving op de iPhone beheert. De wizard maakt Swift-helpers aan.",
+        docsUrl: DOCS_INTEGRATION_PATHS,
+        docsLabel: "iOS-docs openen",
+    },
+    headless: {
+        summary: "Voor backends, automatisering en diensten zonder interface.",
+        explanation: "Kies dit als je sessies en tekengegevens rechtstreeks via de HTTP-API verwerkt en geen standaard ontvanger- of zenderinterface nodig hebt.",
+        docsUrl: DOCS_ENDPOINTS,
+        docsLabel: "Headless-docs openen",
+    },
+};
+function wizardChoices(choices, details) {
+    return dutchWizardChoices(choices).map((choiceOption) => ({
+        ...choiceOption,
+        details: details[choiceOption.value],
+    }));
+}
+const senderWizardDetails = {
+    "remotedraw-ios": {
+        summary: "De officiële RemoteDraw-app is de tekenzender op de telefoon.",
+        explanation: "Dit is de snelste route. Je ontvanger toont een QR-code of deelnamelink; de RemoteDraw-iOS-app verzorgt de tekeninterface en synchronisatie.",
+        docsUrl: DOCS_INTEGRATION_PATHS,
+        docsLabel: "iOS-zenderdocs openen",
+    },
+    "embedded-web": {
+        summary: "Een webzender die onderdeel is van je eigen product.",
+        explanation: "Kies dit als je de telefooninterface zelf wilt vormgeven in React of een andere webstack. Je app verwerkt de deelnamelink en zenderstatus.",
+        docsUrl: DOCS_INTEGRATION_PATHS,
+        docsLabel: "Webzenderdocs openen",
+    },
+    "own-ios": {
+        summary: "Een native iOS-zender die je volledig zelf beheert.",
+        explanation: "Kies dit voor eigen navigatie, branding, pushberichten of app-routing. Je ontvangt Swift-helpers voor deelnamelinks en zenderverzoeken.",
+        docsUrl: DOCS_INTEGRATION_PATHS,
+        docsLabel: "Swift-zenderdocs openen",
+    },
+    headless: {
+        summary: "Een eigen zender zonder door RemoteDraw geleverde interface.",
+        explanation: "Kies dit als je rechtstreeks met de HTTP-zenderroutes werkt, bijvoorbeeld vanuit automatisering, hardware of een volledig eigen client.",
+        docsUrl: DOCS_ENDPOINTS,
+        docsLabel: "HTTP-zenderdocs openen",
+    },
+};
+const sdkWizardDetails = {
+    react: {
+        summary: "React-componenten voor koppeling, ontvanger en zender.",
+        explanation: "Kies dit voor React of Next.js. De starter gebruikt de componenten en hooks van @remotedraw/react voor sessiestatus en live tekeningen.",
+        docsUrl: DOCS_SDKS,
+        docsLabel: "React SDK-docs openen",
+    },
+    svelte: {
+        summary: "Een Svelte-store bovenop de frameworkvrije client.",
+        explanation: "Kies dit voor Svelte of SvelteKit. Je beheert zelf de markup en bindt sessie-, teken- en zenderstatus via de Svelte-store.",
+        docsUrl: DOCS_SDKS,
+        docsLabel: "Svelte SDK-docs openen",
+    },
+    js: {
+        summary: "Frameworkvrije JavaScript-clients en protocoltypen.",
+        explanation: "Kies dit voor desktopapps, andere webframeworks of maatwerkclients. De starter gebruikt fetch en de gedeelde RemoteDraw-contracten.",
+        docsUrl: DOCS_ENDPOINTS,
+        docsLabel: "JavaScript-docs openen",
+    },
+    swift: {
+        summary: "Native Swift-helpers voor een eigen iOS-zender.",
+        explanation: "Kies dit als je zender in Swift of SwiftUI bouwt. De starter bevat parsing van deelnamelinks en getypeerde zenderverzoeken.",
+        docsUrl: DOCS_SDKS,
+        docsLabel: "Swift SDK-docs openen",
+    },
+    headless: {
+        summary: "Alleen configuratie, zonder UI-pakket.",
+        explanation: "Kies dit als een andere taal of eigen client de HTTP-API aanroept. De wizard voegt geen frameworkafhankelijkheid toe.",
+        docsUrl: DOCS_ENDPOINTS,
+        docsLabel: "HTTP API-docs openen",
+    },
+};
+function senderPromptChoices(target) {
+    if (target === "ios") {
+        return [
+            {
+                value: "own-ios",
+                label: "Own iOS sender",
+                hint: "Use Swift join-link and sender request helpers.",
+            },
+        ];
+    }
+    if (target === "headless") {
+        return [
+            {
+                value: "headless",
+                label: "Headless/custom sender",
+                hint: "No hosted phone UI.",
+            },
+        ];
+    }
+    if (target === "desktop") {
+        return [
+            {
+                value: "remotedraw-ios",
+                label: "RemoteDraw iOS app",
+                hint: "Show a join URL or QR code from your receiver.",
+            },
+            {
+                value: "headless",
+                label: "Headless/custom sender",
+                hint: "Build directly on the HTTP sender routes.",
+            },
+        ];
+    }
+    return [
+        {
+            value: "remotedraw-ios",
+            label: "RemoteDraw iOS app",
+            hint: "Fastest path: scan the receiver QR code.",
+        },
+        {
+            value: "embedded-web",
+            label: "Own web sender",
+            hint: "Use a web sender component or raw sender helpers.",
+        },
+    ];
+}
+function sdkPromptChoices(target, sender) {
+    if (target === "ios" || sender === "own-ios") {
+        return [
+            {
+                value: "swift",
+                label: "Swift helpers",
+                hint: "For customer-owned iOS sender apps.",
+            },
+        ];
+    }
+    if (target === "headless" || sender === "headless") {
+        return [
+            {
+                value: "js",
+                label: "JavaScript client",
+                hint: "Framework-free HTTP clients and protocol types.",
+            },
+            {
+                value: "headless",
+                label: "Config only",
+                hint: "No UI package dependency.",
+            },
+        ];
+    }
+    if (target === "desktop") {
+        return [
+            {
+                value: "js",
+                label: "JavaScript client",
+                hint: "Framework-free HTTP clients and protocol types.",
+            },
+        ];
+    }
+    return [
+        {
+            value: "react",
+            label: "React SDK",
+            hint: "Receiver, pairing, and optional embedded sender components.",
+        },
+        {
+            value: "svelte",
+            label: "Svelte SDK",
+            hint: "Svelte receiver store plus shared HTTP clients.",
+        },
+        {
+            value: "js",
+            label: "No framework",
+            hint: "Framework-free clients and raw HTTP starter files.",
+        },
+    ];
+}
+function presetPromptChoices() {
+    return [
+        {
+            value: "signature",
+            label: "Signature strip",
+            hint: "Product-ready branded field with exact surface mapping.",
+        },
+        {
+            value: "sketch",
+            label: "Custom drawing surface",
+            hint: "Flexible normalized input for your own receiver UI.",
+        },
+    ];
+}
+function packageManagerPromptChoices() {
+    return packageManagerChoices.map((packageManager) => ({
+        value: packageManager,
+        label: packageManager,
+    }));
+}
+function apiEndpointPromptChoices() {
+    return [
+        {
+            value: "deployment",
+            label: "Deployment URL placeholder",
+            hint: "Fill in your Convex site origin later.",
+        },
+        {
+            value: "local",
+            label: "Local dev server",
+            hint: "Use http://localhost:3210.",
+        },
+    ];
+}
+const presetWizardDetails = {
+    signature: {
+        summary: "De productklare RemoteDraw-handtekeningstrook.",
+        explanation: "Kies dit voor de complete, merkbare SignatureStrip met een exact passend telefoonoppervlak. Je kunt logo, tekst, kleur en omliggende formulier-UI aanpassen.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Handtekeningdocs openen",
+    },
+    initials: {
+        summary: "Een klein tekenveld voor initialen.",
+        explanation: "Gebruik dit wanneer iemand op één of meerdere plekken korte initialen moet plaatsen, bijvoorbeeld bij documentcontrole.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Initialendocs openen",
+    },
+    approval: {
+        summary: "Vrije tekeninvoer voor een visueel akkoord.",
+        explanation: "Gebruik dit voor goedkeuringen waarbij een vink, paraaf of korte markering voldoende is en je workflow de status beheert.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Goedkeuringsdocs openen",
+    },
+    sketch: {
+        summary: "Genormaliseerde invoer voor een eigen ontvangeroppervlak.",
+        explanation: "Kies dit wanneer jouw product de foto, kaart, PDF, canvas of andere receiver-UI beheert. RemoteDraw levert de invoerprimitieven zonder een voorgeschreven componentontwerp.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Schetsdocs openen",
+    },
+    photoMarkup: {
+        summary: "Aantekeningen bovenop een foto.",
+        explanation: "Gebruik dit voor inspecties, feedback of aanwijzingen op beeldmateriaal. Je app levert de foto en bewaart de relatie met de tekeningen.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Fotoannotatiedocs openen",
+    },
+    pdfMarkup: {
+        summary: "Aantekeningen op een PDF-pagina.",
+        explanation: "Gebruik dit voor documentreview. Je app rendert de juiste pagina en koppelt RemoteDraw-coördinaten aan die vaste weergave.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "PDF-annotatiedocs openen",
+    },
+    mapMarkup: {
+        summary: "Tekeningen en aanwijzingen op een kaart.",
+        explanation: "Gebruik dit voor routes, locaties of ruimtelijke feedback. Je app beheert de kaart en viewport; RemoteDraw synchroniseert de invoer.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Kaartannotatiedocs openen",
+    },
+    screenMarkup: {
+        summary: "Aantekeningen op een scherm of applicatieweergave.",
+        explanation: "Gebruik dit voor support, demo's en UI-feedback. Je ontvanger levert het schermbeeld waarop de telefoonmarkeringen worden geprojecteerd.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Schermaantekeningdocs openen",
+    },
+    designReview: {
+        summary: "Gerichte visuele feedback op een ontwerp.",
+        explanation: "Gebruik dit voor ontwerpbeoordelingen met pijlen, vormen en vrije lijnen. Je product beheert opmerkingen, versies en besluitvorming.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Ontwerpbeoordelingsdocs openen",
+    },
+    pointer: {
+        summary: "Live aanwijzen zonder blijvende tekening.",
+        explanation: "Gebruik dit voor presentaties en begeleiding waarbij de telefoon als aanwijzer dient en beweging belangrijker is dan opgeslagen inkt.",
+        docsUrl: DOCS_PAYLOADS,
+        docsLabel: "Aanwijzerdocs openen",
+    },
+};
+const packageManagerWizardDetails = {
+    npm: {
+        summary: "De standaard package manager die met Node.js wordt geleverd.",
+        explanation: "Kies npm als je project package-lock.json gebruikt of geen voorkeur heeft. De wizard gebruikt npm voor installatie- en vervolgopdrachten.",
+        docsUrl: "https://docs.npmjs.com/",
+        docsLabel: "npm-docs openen",
+    },
+    pnpm: {
+        summary: "Een snelle package manager met een gedeelde pakketopslag.",
+        explanation: "Kies pnpm als je project pnpm-lock.yaml gebruikt, strikte dependency-isolatie wenst of al deel is van een pnpm-workspace.",
+        docsUrl: "https://pnpm.io/",
+        docsLabel: "pnpm-docs openen",
+    },
+    yarn: {
+        summary: "Een package manager met workspace- en Plug'n'Play-ondersteuning.",
+        explanation: "Kies Yarn als je project yarn.lock gebruikt. De wizard sluit aan op de bestaande Yarn-versie en projectconfiguratie.",
+        docsUrl: "https://yarnpkg.com/getting-started/usage",
+        docsLabel: "Yarn-docs openen",
+    },
+    bun: {
+        summary: "De snelle package manager die onderdeel is van de Bun-runtime.",
+        explanation: "Kies Bun als je project bun.lock gebruikt of Bun al inzet voor scripts, tests en installatie van dependencies.",
+        docsUrl: "https://bun.com/docs/pm/cli/install",
+        docsLabel: "Bun-docs openen",
+    },
+};
+const apiEndpointWizardDetails = {
+    deployment: {
+        summary: "Een tijdelijke URL die je later door je echte API-origin vervangt.",
+        explanation: "Kies dit voor een nieuw project dat nog niet aan een lokale server is gekoppeld. De gegenereerde configuratie bevat een duidelijke deployment-placeholder.",
+        docsUrl: DOCS_AUTH,
+        docsLabel: "Deploymentdocs openen",
+    },
+    local: {
+        summary: "Verbind met de lokale API op http://localhost:3210.",
+        explanation: "Kies dit wanneer je RemoteDraw lokaal draait en de ontvanger op dezelfde computer de ontwikkelserver kan bereiken.",
+        docsUrl: DOCS_AUTH,
+        docsLabel: "Lokale API-docs openen",
+    },
+};
+function agentOptionCatalog() {
+    const catalogOption = (choiceOption, compatibility) => ({
+        value: choiceOption.value,
+        label: choiceOption.label,
+        ...(choiceOption.hint ? { hint: choiceOption.hint } : {}),
+        details: choiceOption.details,
+        ...(compatibility ?? {}),
+    });
+    const targets = wizardChoices(targetPromptChoices(), targetWizardDetails);
+    const senders = senderChoices.map((value) => {
+        const compatibleTargets = targetChoices.filter((target) => senderPromptChoices(target).some((option) => option.value === value));
+        const prompt = compatibleTargets
+            .flatMap((target) => senderPromptChoices(target))
+            .find((option) => option.value === value);
+        return catalogOption(wizardChoices([prompt], senderWizardDetails)[0], {
+            compatibleTargets,
+        });
+    });
+    const sdks = sdkChoices.map((value) => {
+        const compatiblePlans = targetChoices.flatMap((target) => senderPromptChoices(target).flatMap((sender) => sdkPromptChoices(target, sender.value).some((option) => option.value === value)
+            ? [{ target, sender: sender.value }]
+            : []));
+        const firstPlan = compatiblePlans[0];
+        const prompt = sdkPromptChoices(firstPlan.target, firstPlan.sender).find((option) => option.value === value);
+        return catalogOption(wizardChoices([prompt], sdkWizardDetails)[0], {
+            compatiblePlans,
+        });
+    });
+    return {
+        ok: true,
+        command: "options",
+        schemaVersion: 1,
+        fields: [
+            {
+                key: "appName",
+                flag: "--app-name",
+                label: "Projectnaam",
+                kind: "text",
+                requiredFor: ["new"],
+                options: [],
+            },
+            {
+                key: "target",
+                flag: "--target",
+                label: "Projecttype",
+                kind: "select",
+                options: targets.map((option) => catalogOption(option)),
+            },
+            {
+                key: "sender",
+                flag: "--sender",
+                label: "Telefoonzender",
+                kind: "select",
+                options: senders,
+            },
+            {
+                key: "sdk",
+                flag: "--sdk",
+                label: "UI-framework / SDK",
+                kind: "select",
+                options: sdks,
+            },
+            {
+                key: "preset",
+                flag: "--preset",
+                label: "Startpunt",
+                kind: "select",
+                options: wizardChoices(presetPromptChoices(), presetWizardDetails).map((option) => catalogOption(option)),
+            },
+            {
+                key: "packageManager",
+                flag: "--package-manager",
+                label: "Pakketbeheerder",
+                kind: "select",
+                options: wizardChoices(packageManagerPromptChoices(), packageManagerWizardDetails).map((option) => catalogOption(option)),
+            },
+            {
+                key: "apiBaseUrl",
+                flag: "--api-base-url",
+                label: "API-eindpunt",
+                kind: "select",
+                options: wizardChoices(apiEndpointPromptChoices(), apiEndpointWizardDetails).map((option) => ({
+                    ...catalogOption(option),
+                    endpoint: option.value,
+                    value: apiBaseUrlForEndpoint(option.value),
+                })),
+            },
+        ],
+        defaults: {
+            target: "web",
+            senderByTarget: Object.fromEntries(targetChoices.map((target) => [target, defaultSenderForTarget(target)])),
+            sdkByTargetAndSender: Object.fromEntries(targetChoices.flatMap((target) => senderPromptChoices(target).map((sender) => [
+                `${target}:${sender.value}`,
+                defaultSdkForChoices(target, sender.value),
+            ]))),
+            preset: "signature",
+            packageManager: "npm",
+            apiBaseUrl: "https://<deployment>.convex.site",
+        },
+        safety: {
+            dryRunFlag: "--dry-run",
+            nonInteractiveFlag: "--non-interactive",
+            overwriteFlag: "--force",
+            localOnlyFlag: "--offline",
+        },
+    };
+}
+function apiBaseUrlForEndpoint(endpoint) {
+    if (endpoint === "local")
+        return "http://localhost:3210";
+    return "https://<deployment>.convex.site";
+}
+export function projectSetupDefinition() {
+    return {
+        defaults: {
+            appName: "RemoteDraw App",
+            target: "web",
+            sender: "remotedraw-ios",
+            sdk: "react",
+            preset: "signature",
+            packageManager: "npm",
+            apiEndpoint: "deployment",
+        },
+        fields: [
+            {
+                key: "appName",
+                label: "Projectnaam",
+                kind: "text",
+                validate: validateWizardProjectName,
+            },
+            {
+                key: "target",
+                label: "Projecttype",
+                kind: "select",
+                choices: () => wizardChoices(targetPromptChoices(), targetWizardDetails),
+            },
+            {
+                key: "sender",
+                label: "Telefoonzender",
+                kind: "select",
+                choices: (values) => wizardChoices(senderPromptChoices(choice(values.target, targetChoices, "target")), senderWizardDetails),
+            },
+            {
+                key: "sdk",
+                label: "UI-framework / SDK",
+                kind: "select",
+                choices: (values) => wizardChoices(sdkPromptChoices(choice(values.target, targetChoices, "target"), choice(values.sender, senderChoices, "sender")), sdkWizardDetails),
+            },
+            {
+                key: "preset",
+                label: "Startpunt",
+                kind: "select",
+                choices: () => wizardChoices(presetPromptChoices(), presetWizardDetails),
+            },
+            {
+                key: "packageManager",
+                label: "Pakketbeheerder",
+                kind: "select",
+                choices: () => wizardChoices(packageManagerPromptChoices(), packageManagerWizardDetails),
+            },
+            {
+                key: "apiEndpoint",
+                label: "API-eindpunt",
+                kind: "select",
+                choices: () => wizardChoices(apiEndpointPromptChoices(), apiEndpointWizardDetails),
+            },
+        ],
+        normalize(values, changed) {
+            const next = { ...values };
+            const target = choice(next.target, targetChoices, "target");
+            const availableSenders = senderPromptChoices(target);
+            if (changed === "target" ||
+                !availableSenders.some((item) => item.value === next.sender)) {
+                next.sender = defaultPromptValue(defaultSenderForTarget(target), availableSenders);
+            }
+            const sender = choice(next.sender, senderChoices, "sender");
+            const availableSdks = sdkPromptChoices(target, sender);
+            if (changed === "target" ||
+                changed === "sender" ||
+                !availableSdks.some((item) => item.value === next.sdk)) {
+                next.sdk = defaultPromptValue(defaultSdkForChoices(target, sender), availableSdks);
+            }
+            return next;
+        },
+        review(values) {
+            const plan = planFromWizardValues(values);
+            return [
+                ["Project", plan.appName],
+                ["Map", plan.slug],
+                ["Projecttype", plan.target],
+                ["Telefoonzender", plan.sender],
+                ["SDK", plan.sdk],
+                ["Startpunt", plan.preset],
+                ["Pakketbeheerder", plan.packageManager],
+                ["API-eindpunt", plan.apiBaseUrl],
+            ];
+        },
+    };
+}
+function validateWizardProjectName(value) {
+    return value.trim() === "" ? "Voer een projectnaam in." : undefined;
+}
+const dutchWizardText = {
+    "Web app": "Webapp",
+    "Desktop or custom app": "Desktop- of maatwerkapp",
+    "iOS sender app": "iOS-zenderapp",
+    "Headless service": "Headless-service",
+    "Own iOS sender": "Eigen iOS-zender",
+    "Use Swift join-link and sender request helpers.": "Gebruik Swift-helpers voor deelnamelinks en zenderverzoeken.",
+    "Headless/custom sender": "Headless- of maatwerkzender",
+    "No hosted phone UI.": "Geen gehoste telefooninterface.",
+    "RemoteDraw iOS app": "RemoteDraw-iOS-app",
+    "Show a join URL or QR code from your receiver.": "Toon vanuit je ontvanger een deelname-URL of QR-code.",
+    "Build directly on the HTTP sender routes.": "Bouw rechtstreeks op de HTTP-zenderroutes.",
+    "Fastest path: scan the receiver QR code.": "Snelste route: scan de QR-code van de ontvanger.",
+    "Own web sender": "Eigen webzender",
+    "Use a web sender component or raw sender helpers.": "Gebruik een webzendercomponent of losse zenderhelpers.",
+    "Swift helpers": "Swift-helpers",
+    "For customer-owned iOS sender apps.": "Voor iOS-zenderapps in eigen beheer.",
+    "JavaScript client": "JavaScript-client",
+    "Framework-free HTTP clients and protocol types.": "Frameworkvrije HTTP-clients en protocoltypen.",
+    "Config only": "Alleen configuratie",
+    "No UI package dependency.": "Geen afhankelijkheid van een UI-pakket.",
+    "Receiver, pairing, and optional embedded sender components.": "Componenten voor ontvanger, koppeling en optionele ingebouwde zender.",
+    "Svelte receiver store plus shared HTTP clients.": "Svelte-store voor de ontvanger met gedeelde HTTP-clients.",
+    "No framework": "Geen framework",
+    "Framework-free clients and raw HTTP starter files.": "Frameworkvrije clients en kale HTTP-startbestanden.",
+    "Signature strip": "Handtekeningstrook",
+    "Product-ready branded field with exact surface mapping.": "Productklaar merkveld met exacte oppervlaktekoppeling.",
+    "Custom drawing surface": "Eigen tekenoppervlak",
+    "Flexible normalized input for your own receiver UI.": "Flexibele genormaliseerde invoer voor je eigen ontvanger-UI.",
+    Signature: "Handtekening",
+    Initials: "Initialen",
+    Approval: "Goedkeuring",
+    Sketch: "Schets",
+    "Photo markup": "Fotoannotatie",
+    "PDF markup": "PDF-annotatie",
+    "Map markup": "Kaartannotatie",
+    "Screen markup": "Schermaantekening",
+    "Design review": "Ontwerpbeoordeling",
+    Pointer: "Aanwijzer",
+    "Deployment URL placeholder": "Tijdelijke deployment-URL",
+    "Fill in your Convex site origin later.": "Vul later de oorsprong van je Convex-site in.",
+    "Local dev server": "Lokale ontwikkelserver",
+    "Use http://localhost:3210.": "Gebruik http://localhost:3210.",
+};
+function dutchWizardChoices(choices) {
+    return choices.map((choiceOption) => ({
+        ...choiceOption,
+        label: dutchWizardText[choiceOption.label] ?? choiceOption.label,
+        ...(choiceOption.hint == null
+            ? {}
+            : {
+                hint: dutchWizardText[choiceOption.hint] ?? choiceOption.hint,
+            }),
+    }));
+}
+function planFromWizardValues(values) {
+    const appName = values.appName.trim();
+    const target = choice(values.target, targetChoices, "target");
+    const sender = choice(values.sender, senderChoices, "sender");
+    const sdk = choice(values.sdk, sdkChoices, "sdk");
+    const plan = {
+        appName,
+        slug: slugify(appName),
+        target,
+        sender,
+        sdk,
+        preset: choice(values.preset, presetChoices, "preset"),
+        packageManager: choice(values.packageManager, packageManagerChoices, "package-manager"),
+        apiBaseUrl: apiBaseUrlForEndpoint(choice(values.apiEndpoint, apiEndpointChoices, "api endpoint")),
+    };
+    const nameError = validateProjectName(plan.appName);
+    if (nameError)
+        throw new Error(nameError);
+    validatePlan(plan);
+    return plan;
+}
+function planFromArgs(parsed, options) {
+    const appName = readString(parsed, "app-name") ??
+        options.defaults?.appName ??
+        options.defaultAppName;
+    if (options.appNameRequired && !readString(parsed, "app-name")) {
+        throw new Error("--app-name is required.");
+    }
+    const target = choice(readString(parsed, "target") ?? options.defaults?.target ?? "web", targetChoices, "target");
+    const sender = choice(readString(parsed, "sender") ??
+        options.defaults?.sender ??
+        defaultSenderForTarget(target), senderChoices, "sender");
+    const sdk = choice(readString(parsed, "sdk") ??
+        options.defaults?.sdk ??
+        defaultSdkForChoices(target, sender), sdkChoices, "sdk");
+    const preset = choice(readString(parsed, "preset") ?? options.defaults?.preset ?? "signature", presetChoices, "preset");
+    const packageManager = choice(readString(parsed, "package-manager") ??
+        options.defaults?.packageManager ??
+        "npm", packageManagerChoices, "package-manager");
+    const apiBaseUrl = readString(parsed, "api-base-url") ??
+        options.defaults?.apiBaseUrl ??
+        "https://<deployment>.convex.site";
+    validatePlan({ target, sender, sdk });
+    return {
+        appName,
+        slug: slugify(appName),
+        target,
+        sender,
+        sdk,
+        preset,
+        apiBaseUrl,
+        packageManager,
+    };
+}
+function defaultSenderForTarget(target) {
+    if (target === "ios")
+        return "own-ios";
+    if (target === "headless")
+        return "headless";
+    return "remotedraw-ios";
+}
+function defaultSdkForChoices(target, sender) {
+    if (target === "ios" || sender === "own-ios")
+        return "swift";
+    if (target === "headless" || sender === "headless")
+        return "js";
+    return "react";
+}
+function validatePlan(plan) {
+    if (plan.sender === "own-ios" && plan.sdk !== "swift") {
+        throw new Error("--sender own-ios requires --sdk swift.");
+    }
+    if (plan.sdk === "swift" && plan.sender !== "own-ios") {
+        throw new Error("--sdk swift is only supported with --sender own-ios.");
+    }
+    if (plan.target === "ios" && plan.sender !== "own-ios") {
+        throw new Error("--target ios requires --sender own-ios.");
+    }
+    if (plan.sender === "headless" && plan.sdk === "react") {
+        throw new Error("--sender headless requires --sdk js or --sdk headless.");
+    }
+}
+function choice(value, choices, label) {
+    if (choices.includes(value))
+        return value;
+    throw new Error(`Unknown ${label} "${value}". Expected one of: ${choices.join(", ")}.`);
+}
+function resolveOutputDir(cwd, parsed, fallback) {
+    const requestedPath = readString(parsed, "path") ?? parsed.positionals[0] ?? fallback ?? ".";
+    return path.resolve(cwd, requestedPath);
+}
+async function hasPackageJson(dir, runtime) {
+    return await runtime.exists(path.join(dir, "package.json"));
+}
+function newProjectFiles(plan) {
+    const files = initProjectFiles(plan, false);
+    files.set("README.md", generatedReadme(plan));
+    files.set("package.json", JSON.stringify(newPackageJson(plan), null, 2) + "\n");
+    files.set(".gitignore", "node_modules\ndist\n.env\n.env.local\n");
+    if (plan.sdk === "react") {
+        files.set("index.html", reactIndexHtml(plan));
+        files.set("src/main.tsx", reactMainTsx());
+        files.set("src/App.tsx", reactAppTsx(plan));
+        files.set("src/styles.css", reactStylesCss());
+        files.set("tsconfig.json", reactTsconfig());
+        files.set("vite.config.ts", reactViteConfig());
+    }
+    return files;
+}
+function initProjectFiles(plan, packageJsonAlreadyExists) {
+    const files = new Map();
+    files.set("remotedraw.config.json", JSON.stringify(configJson(plan), null, 2) + "\n");
+    files.set(".env.example", envExample(plan));
+    files.set("src/remotedraw/README.md", integrationReadme(plan));
+    if (!packageJsonAlreadyExists) {
+        files.set("package.json", JSON.stringify(initPackageJson(plan), null, 2) + "\n");
+    }
+    if (plan.sdk === "react") {
+        files.set("src/remotedraw/createRemoteDrawSession.ts", reactBackendSessionTs(plan));
+        files.set("src/remotedraw/RemoteDrawReceiver.tsx", reactReceiverTsx());
+        if (plan.sender === "embedded-web") {
+            files.set("src/remotedraw/RemoteDrawEmbeddedSender.tsx", reactEmbeddedSenderTsx());
+        }
+    }
+    else if (plan.sdk === "svelte") {
+        files.set("src/remotedraw/createRemoteDrawSession.ts", svelteBackendSessionTs(plan));
+        files.set("src/remotedraw/RemoteDrawReceiver.svelte", svelteReceiverSvelte());
+        if (plan.sender !== "remotedraw-ios") {
+            files.set("src/remotedraw/senderFlow.ts", rawHttpSenderTs());
+        }
+    }
+    else if (plan.sdk === "swift") {
+        files.set("src/remotedraw/RemoteDrawIntegration.swift", swiftIntegration(plan));
+    }
+    else {
+        files.set("src/remotedraw/createRemoteDrawSession.ts", rawHttpSessionTs(plan));
+        files.set("src/remotedraw/receiverPolling.ts", rawHttpReceiverTs());
+        if (plan.sender !== "remotedraw-ios") {
+            files.set("src/remotedraw/senderFlow.ts", rawHttpSenderTs());
+        }
+    }
+    return files;
+}
+async function writeProjectFiles(files, outputDir, runtime, options) {
+    const written = [];
+    await assertProjectFilesWritable(files, outputDir, runtime, options.dryRun, options.force);
+    for (const [relativePath, contents] of files) {
+        const targetPath = path.join(outputDir, relativePath);
+        written.push(relativePath);
+        if (options.dryRun)
+            continue;
+        await runtime.mkdir(path.dirname(targetPath));
+        await runtime.writeFile(targetPath, contents);
+    }
+    return written;
+}
+async function assertProjectFilesWritable(files, outputDir, runtime, dryRun, force) {
+    if (dryRun || force)
+        return;
+    for (const relativePath of files.keys()) {
+        if (await runtime.exists(path.join(outputDir, relativePath))) {
+            throw new Error(`Refusing to overwrite ${relativePath}. Pass --force to replace generated files.`);
+        }
+    }
+}
+async function updatePackageJson(outputDir, plan, runtime) {
+    const packagePath = path.join(outputDir, "package.json");
+    if (!(await runtime.exists(packagePath)))
+        return;
+    const packageJson = await readJsonFile(packagePath, runtime);
+    if (!isRecord(packageJson))
+        return;
+    const dependencies = ensureRecord(packageJson, "dependencies");
+    for (const [name, version] of Object.entries(dependenciesForPlan(plan))) {
+        if (dependencies[name] == null)
+            dependencies[name] = version;
+    }
+    await runtime.writeFile(packagePath, JSON.stringify(packageJson, null, 2) + "\n");
+}
+function ensureRecord(record, key) {
+    const value = record[key];
+    if (isRecord(value))
+        return value;
+    const next = {};
+    record[key] = next;
+    return next;
+}
+async function readJsonFile(filePath, runtime) {
+    return JSON.parse(await runtime.readFile(filePath));
+}
+async function environmentForProject(dir, runtime) {
+    const fromFiles = {};
+    for (const fileName of [".env", ".env.local"]) {
+        const filePath = path.join(dir, fileName);
+        if (!(await runtime.exists(filePath)))
+            continue;
+        Object.assign(fromFiles, parseEnvFile(await runtime.readFile(filePath)));
+    }
+    return { ...fromFiles, ...runtime.env };
+}
+function parseEnvFile(contents) {
+    const values = {};
+    for (const line of contents.split(/\r?\n/)) {
+        const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);
+        if (!match?.[1] || match[2] == null)
+            continue;
+        const raw = match[2].trim();
+        const quote = raw[0];
+        values[match[1]] =
+            (quote === '"' || quote === "'") && raw.endsWith(quote)
+                ? raw.slice(1, -1)
+                : raw.replace(/\s+#.*$/, "");
+    }
+    return values;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringFromRecord(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const child = value[key];
+    return typeof child === "string" ? child : undefined;
+}
+function hasDependency(packageJson, dependencyName) {
+    if (!isRecord(packageJson))
+        return false;
+    return (isRecord(packageJson.dependencies) &&
+        typeof packageJson.dependencies[dependencyName] === "string");
+}
+function dependenciesForPlan(plan) {
+    if (plan.sdk === "react") {
+        return {
+            "@remotedraw/react": "latest",
+            react: "^19.0.0",
+            "react-dom": "^19.0.0",
+        };
+    }
+    if (plan.sdk === "svelte") {
+        return {
+            "@remotedraw/svelte": "latest",
+        };
+    }
+    if (plan.sdk === "js") {
+        return {
+            "@remotedraw/protocol": "latest",
+        };
+    }
+    return {};
+}
+function newPackageJson(plan) {
+    const dependencies = dependenciesForPlan(plan);
+    if (plan.sdk === "react") {
+        return {
+            name: plan.slug,
+            private: true,
+            type: "module",
+            scripts: {
+                dev: "vite",
+                build: "tsc --noEmit && vite build",
+                preview: "vite preview",
+            },
+            dependencies,
+            devDependencies: {
+                "@types/react": "^19.0.0",
+                "@types/react-dom": "^19.0.0",
+                "@vitejs/plugin-react": "latest",
+                typescript: "^6.0.0",
+                vite: "latest",
+            },
+        };
+    }
+    return initPackageJson(plan);
+}
+function initPackageJson(plan) {
+    return {
+        name: plan.slug,
+        private: true,
+        type: "module",
+        scripts: {
+            dev: "remotedraw dev",
+            "remotedraw:doctor": "remotedraw doctor",
+            "remotedraw:create-input": "remotedraw create-input --preset " + plan.preset,
+        },
+        dependencies: dependenciesForPlan(plan),
+        devDependencies: {
+            typescript: "^6.0.0",
+        },
+    };
+}
+function configJson(plan) {
+    return {
+        $schema: "https://remotedraw.app/schemas/remotedraw.config.json",
+        appName: plan.appName,
+        environment: "dev",
+        target: plan.target,
+        sender: plan.sender,
+        sdk: plan.sdk,
+        preset: plan.preset,
+        apiBaseUrl: plan.apiBaseUrl,
+    };
+}
+function envExample(plan) {
+    return [
+        "# RemoteDraw API origin. Use your Convex site URL in production.",
+        `REMOTEDRAW_API_BASE_URL=${plan.apiBaseUrl}`,
+        "",
+        "# Non-secret dashboard project identifier. remotedraw new/init fills this in.",
+        "REMOTEDRAW_PROJECT_ID=replace_me",
+        "",
+        "# Server-side only. Never expose rd_sk_... keys to browsers or mobile clients.",
+        "REMOTEDRAW_API_KEY=rd_sk_replace_me",
+        "",
+    ].join("\n");
+}
+function generatedReadme(plan) {
+    return [
+        `# ${plan.appName}`,
+        "",
+        "RemoteDraw starter generated by the RemoteDraw CLI.",
+        "",
+        "## Next Steps",
+        "",
+        `1. Install packages with ${installCommand(plan.packageManager)}.`,
+        "2. Use the generated `.env.local`, or copy `.env.example` when setup was run with `--offline`.",
+        "3. Create RemoteDraw sessions from trusted backend code only.",
+        `4. Run ${devCommandForPackageManager(plan.packageManager)}.`,
+        plan.sender === "own-ios"
+            ? "5. Choose QR mode with the returned HTTPS `joinUrl`, or direct mode with `/v1/sessions/direct-sender` from backend code."
+            : "5. Render the returned HTTPS `joinUrl` in the receiver UI.",
+        "",
+        "See `src/remotedraw/README.md` for integration-specific notes.",
+    ].join("\n");
+}
+function integrationReadme(plan) {
+    return [
+        "# RemoteDraw Integration",
+        "",
+        `App: ${plan.appName}`,
+        `Target: ${plan.target}`,
+        `Sender: ${plan.sender}`,
+        `SDK: ${plan.sdk}`,
+        `Starter: ${plan.preset}`,
+        "",
+        "## Flow",
+        "",
+        "1. Your backend calls `POST /v1/sessions` with an `rd_sk_...` API key.",
+        "2. Your receiver renders the returned HTTPS `joinUrl` and stores only `receiverToken` client-side.",
+        plan.sender === "remotedraw-ios"
+            ? "3. The RemoteDraw iOS app scans or opens the join URL and exchanges the one-time join token."
+            : plan.sender === "own-ios"
+                ? "3. Your backend either sends a join URL to the app or creates a direct sender connection with `POST /v1/sessions/direct-sender`."
+                : "3. Your sender exchanges the one-time join token and receives a scoped sender token.",
+        "4. The sender streams draft input, commits durable strokes, and calls submit when done.",
+        "",
+        "API keys belong only in backend secrets. Join tokens, receiver tokens, and sender tokens are short-lived scoped credentials.",
+    ].join("\n");
+}
+function reactBackendSessionTs(plan) {
+    return [
+        'import { createHttpRemoteDrawApiClient } from "@remotedraw/react";',
+        'import type { CreateSessionRequest } from "@remotedraw/react";',
+        "",
+        "const apiBaseUrl = process.env.REMOTEDRAW_API_BASE_URL;",
+        "const apiKey = process.env.REMOTEDRAW_API_KEY;",
+        "",
+        "export function createRemoteDrawSessionRequest(): CreateSessionRequest {",
+        "  return " +
+            JSON.stringify(createSessionPayload({
+                preset: plan.preset,
+                label: labelForPreset(plan.preset),
+                externalId: `${plan.slug}-${plan.preset}`,
+            }), null, 2).replace(/\n/g, "\n  ") +
+            ";",
+        "}",
+        "",
+        "export async function createRemoteDrawSession() {",
+        "  if (!apiBaseUrl || !apiKey) {",
+        '    throw new Error("Set REMOTEDRAW_API_BASE_URL and REMOTEDRAW_API_KEY in backend secrets.");',
+        "  }",
+        "",
+        "  const client = createHttpRemoteDrawApiClient(apiBaseUrl, { apiKey });",
+        "  return await client.createSession(createRemoteDrawSessionRequest());",
+        "}",
+        "",
+    ].join("\n");
+}
+function reactReceiverTsx() {
+    return [
+        "import {",
+        "  RemoteDrawProvider,",
+        "  RemoteDrawReceiver,",
+        "  SubmissionStatus,",
+        "  createHttpReceiverClient,",
+        '} from "@remotedraw/react";',
+        'import type { CreateSessionResponse } from "@remotedraw/react";',
+        "",
+        "type RemoteDrawReceiverPanelProps = {",
+        "  apiBaseUrl: string;",
+        "  createdSession: CreateSessionResponse;",
+        "};",
+        "",
+        "export function RemoteDrawReceiverPanel({",
+        "  apiBaseUrl,",
+        "  createdSession,",
+        "}: RemoteDrawReceiverPanelProps) {",
+        "  const receiver = createHttpReceiverClient(apiBaseUrl);",
+        "",
+        "  return (",
+        "    <RemoteDrawProvider",
+        "      session={createdSession.session}",
+        "      receiverToken={createdSession.receiverToken}",
+        "      joinUrl={createdSession.joinUrl}",
+        "      joinUrls={createdSession.joinUrls}",
+        "      receiver={receiver}",
+        "    >",
+        '      <RemoteDrawReceiver aria-label="RemoteDraw receiver surface" />',
+        '      <SubmissionStatus metadataKeys={["externalId", "senderLabel"]} />',
+        "    </RemoteDrawProvider>",
+        "  );",
+        "}",
+        "",
+    ].join("\n");
+}
+function reactEmbeddedSenderTsx() {
+    return [
+        'import { EmbeddedSender, createHttpSenderClient } from "@remotedraw/react";',
+        "",
+        "type RemoteDrawEmbeddedSenderPanelProps = {",
+        "  apiBaseUrl: string;",
+        "  joinTokenOrUrl: string;",
+        "};",
+        "",
+        "export function RemoteDrawEmbeddedSenderPanel({",
+        "  apiBaseUrl,",
+        "  joinTokenOrUrl,",
+        "}: RemoteDrawEmbeddedSenderPanelProps) {",
+        "  return (",
+        "    <EmbeddedSender",
+        "      client={createHttpSenderClient(apiBaseUrl)}",
+        "      initialJoinToken={joinTokenOrUrl}",
+        "      autoJoin",
+        '      device={{ platform: "web", displayName: "Embedded sender" }}',
+        '      submitMetadata={{ senderLabel: "Embedded sender" }}',
+        '      submitLabel="Done"',
+        "    />",
+        "  );",
+        "}",
+        "",
+    ].join("\n");
+}
+function svelteBackendSessionTs(plan) {
+    return [
+        'import { createHttpRemoteDrawApiClient } from "@remotedraw/svelte";',
+        'import type { CreateSessionRequest } from "@remotedraw/svelte";',
+        "",
+        "const apiBaseUrl = process.env.REMOTEDRAW_API_BASE_URL;",
+        "const apiKey = process.env.REMOTEDRAW_API_KEY;",
+        "",
+        "export function createRemoteDrawSessionRequest(): CreateSessionRequest {",
+        "  return " +
+            JSON.stringify(createSessionPayload({
+                preset: plan.preset,
+                label: labelForPreset(plan.preset),
+                externalId: `${plan.slug}-${plan.preset}`,
+            }), null, 2).replace(/\n/g, "\n  ") +
+            ";",
+        "}",
+        "",
+        "export async function createRemoteDrawSession() {",
+        "  if (!apiBaseUrl || !apiKey) {",
+        '    throw new Error("Set REMOTEDRAW_API_BASE_URL and REMOTEDRAW_API_KEY in backend secrets.");',
+        "  }",
+        "",
+        "  const client = createHttpRemoteDrawApiClient(apiBaseUrl, { apiKey });",
+        "  return await client.createSession(createRemoteDrawSessionRequest());",
+        "}",
+        "",
+    ].join("\n");
+}
+function svelteReceiverSvelte() {
+    return [
+        '<script lang="ts">',
+        "  import {",
+        "    createHttpReceiverClient,",
+        "    createRemoteDrawReceiver,",
+        "    pointsToPath,",
+        "    SURFACE_SIZE,",
+        '  } from "@remotedraw/svelte";',
+        '  import type { CreateSessionResponse } from "@remotedraw/svelte";',
+        '  import { onDestroy } from "svelte";',
+        "",
+        "  export let apiBaseUrl: string;",
+        "  export let createdSession: CreateSessionResponse;",
+        "",
+        "  const receiver = createRemoteDrawReceiver({",
+        "    receiver: createHttpReceiverClient(apiBaseUrl),",
+        "    session: {",
+        "      ...createdSession.session,",
+        "      receiverToken: createdSession.receiverToken,",
+        "      joinUrl: createdSession.joinUrl,",
+        "      joinUrls: createdSession.joinUrls,",
+        "    },",
+        "  });",
+        "  receiver.start();",
+        "  onDestroy(() => receiver.stop());",
+        "</script>",
+        "",
+        "{#if $receiver.joinUrl}",
+        "  <p>Scan to pair: <a href={$receiver.joinUrl}>{$receiver.joinUrl}</a></p>",
+        "{/if}",
+        "",
+        '<svg viewBox={`0 0 ${SURFACE_SIZE} ${SURFACE_SIZE}`} role="img" aria-label="RemoteDraw receiver surface">',
+        "  {#each $receiver.drawings as drawing (drawing.id)}",
+        '    <path d={pointsToPath(drawing.points)} fill="none" stroke="#151512" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" />',
+        "  {/each}",
+        "  {#each $receiver.drafts as draft (draft.id)}",
+        '    <path d={pointsToPath(draft.points)} fill="none" stroke="#1f7a8c" stroke-width="6" stroke-dasharray="16 14" opacity="0.6" stroke-linecap="round" stroke-linejoin="round" />',
+        "  {/each}",
+        "</svg>",
+        "",
+    ].join("\n");
+}
+function rawHttpSessionTs(plan) {
+    return [
+        "const apiBaseUrl = process.env.REMOTEDRAW_API_BASE_URL;",
+        "const apiKey = process.env.REMOTEDRAW_API_KEY;",
+        "",
+        "export function createRemoteDrawSessionRequest() {",
+        "  return " +
+            JSON.stringify(createSessionPayload({
+                preset: plan.preset,
+                label: labelForPreset(plan.preset),
+                externalId: `${plan.slug}-${plan.preset}`,
+            }), null, 2).replace(/\n/g, "\n  ") +
+            ";",
+        "}",
+        "",
+        "export async function createRemoteDrawSession() {",
+        "  if (!apiBaseUrl || !apiKey) {",
+        '    throw new Error("Set REMOTEDRAW_API_BASE_URL and REMOTEDRAW_API_KEY in backend secrets.");',
+        "  }",
+        "",
+        "  const response = await fetch(`${apiBaseUrl}/v1/sessions`, {",
+        '    method: "POST",',
+        "    headers: {",
+        "      Authorization: `Bearer ${apiKey}`,",
+        '      "Content-Type": "application/json",',
+        "    },",
+        "    body: JSON.stringify(createRemoteDrawSessionRequest()),",
+        "  });",
+        "  if (!response.ok) throw new Error(await response.text());",
+        "  return await response.json();",
+        "}",
+        "",
+    ].join("\n");
+}
+function rawHttpReceiverTs() {
+    return [
+        "type CreatedRemoteDrawSession = {",
+        "  session: { id: string };",
+        "  receiverToken: string;",
+        "};",
+        "",
+        "export async function readRemoteDrawReceiverState(",
+        "  apiBaseUrl: string,",
+        "  createdSession: CreatedRemoteDrawSession,",
+        ") {",
+        "  const body = {",
+        "    sessionId: createdSession.session.id,",
+        "    receiverToken: createdSession.receiverToken,",
+        "  };",
+        "",
+        "  const post = async (path: string) => {",
+        "    const response = await fetch(`${apiBaseUrl}${path}`, {",
+        '      method: "POST",',
+        '      headers: { "Content-Type": "application/json" },',
+        "      body: JSON.stringify(body),",
+        "    });",
+        "    if (!response.ok) throw new Error(await response.text());",
+        "    return await response.json();",
+        "  };",
+        "",
+        "  const [session, drawings, drafts, senders] = await Promise.all([",
+        '    post("/v1/receiver/session"),',
+        '    post("/v1/receiver/drawings"),',
+        '    post("/v1/receiver/drafts"),',
+        '    post("/v1/receiver/senders"),',
+        "  ]);",
+        "",
+        "  return { session, drawings, drafts, senders };",
+        "}",
+        "",
+    ].join("\n");
+}
+function rawHttpSenderTs() {
+    return [
+        "export async function joinRemoteDrawSender(apiBaseUrl: string, joinToken: string) {",
+        "  const response = await fetch(`${apiBaseUrl}/v1/join`, {",
+        '    method: "POST",',
+        '    headers: { "Content-Type": "application/json" },',
+        "    body: JSON.stringify({",
+        "      joinToken,",
+        '      device: { platform: "web", displayName: "Owned sender" },',
+        "    }),",
+        "  });",
+        "  if (!response.ok) throw new Error(await response.text());",
+        "  return await response.json();",
+        "}",
+        "",
+        "export async function commitRemoteDrawStroke(apiBaseUrl: string, senderToken: string) {",
+        "  const response = await fetch(`${apiBaseUrl}/v1/sender/commit`, {",
+        '    method: "POST",',
+        '    headers: { "Content-Type": "application/json" },',
+        "    body: JSON.stringify({",
+        "      senderToken,",
+        "      clientStrokeId: crypto.randomUUID(),",
+        "      sequence: 1,",
+        '      pointerType: "touch",',
+        '      tool: "freehand",',
+        "      points: [",
+        "        { x: 0.2, y: 0.25, t: 0 },",
+        "        { x: 0.5, y: 0.5, t: 24 },",
+        "        { x: 0.78, y: 0.62, t: 48 },",
+        "      ],",
+        "      occurredAt: Date.now(),",
+        "    }),",
+        "  });",
+        "  if (!response.ok) throw new Error(await response.text());",
+        "  return await response.json();",
+        "}",
+        "",
+    ].join("\n");
+}
+function swiftIntegration(plan) {
+    return [
+        "import Foundation",
+        "",
+        "struct RemoteDrawJoinLink {",
+        "  let token: String",
+        "  let webURL: URL?",
+        "}",
+        "",
+        "enum RemoteDrawJoinLinkParser {",
+        "  static func parse(_ input: String) -> RemoteDrawJoinLink? {",
+        "    let trimmed = input.trimmingCharacters(in: .whitespacesAndNewlines)",
+        '    if trimmed.hasPrefix("rd_join_") {',
+        "      return RemoteDrawJoinLink(token: trimmed, webURL: nil)",
+        "    }",
+        "    guard let components = URLComponents(string: trimmed) else { return nil }",
+        '    let token = components.queryItems?.first(where: { $0.name == "token" })?.value',
+        '    guard let token, token.hasPrefix("rd_join_") else { return nil }',
+        "    return RemoteDrawJoinLink(token: token, webURL: components.url)",
+        "  }",
+        "}",
+        "",
+        "struct RemoteDrawJoinRequest: Encodable {",
+        "  let joinToken: String",
+        "  let device: Device",
+        "",
+        "  struct Device: Encodable {",
+        '    let platform = "ios"',
+        `    let displayName = "${plan.appName}"`,
+        "  }",
+        "}",
+        "",
+    ].join("\n");
+}
+function reactIndexHtml(plan) {
+    return [
+        "<!doctype html>",
+        '<html lang="en">',
+        "  <head>",
+        '    <meta charset="UTF-8" />',
+        '    <meta name="viewport" content="width=device-width, initial-scale=1.0" />',
+        `    <title>${escapeHtml(plan.appName)}</title>`,
+        "  </head>",
+        "  <body>",
+        '    <div id="root"></div>',
+        '    <script type="module" src="/src/main.tsx"></script>',
+        "  </body>",
+        "</html>",
+        "",
+    ].join("\n");
+}
+function reactMainTsx() {
+    return [
+        'import React from "react";',
+        'import { createRoot } from "react-dom/client";',
+        'import { App } from "./App";',
+        'import "./styles.css";',
+        "",
+        'createRoot(document.getElementById("root")!).render(',
+        "  <React.StrictMode>",
+        "    <App />",
+        "  </React.StrictMode>,",
+        ");",
+        "",
+    ].join("\n");
+}
+function reactAppTsx(plan) {
+    return [
+        "export function App() {",
+        "  return (",
+        '    <main className="shell">',
+        '      <section className="intro">',
+        `        <h1>${escapeText(plan.appName)}</h1>`,
+        "        <p>",
+        "          Create a RemoteDraw session from your backend, pass the returned",
+        "          session object to <code>RemoteDrawReceiverPanel</code>, and show the",
+        "          HTTPS join URL to the phone sender.",
+        "        </p>",
+        "      </section>",
+        "    </main>",
+        "  );",
+        "}",
+        "",
+    ].join("\n");
+}
+function reactStylesCss() {
+    return [
+        ":root {",
+        "  color: #1f2937;",
+        "  background: #f7f7f4;",
+        '  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;',
+        "}",
+        "",
+        "body {",
+        "  margin: 0;",
+        "}",
+        "",
+        ".shell {",
+        "  min-height: 100vh;",
+        "  display: grid;",
+        "  place-items: center;",
+        "  padding: 32px;",
+        "}",
+        "",
+        ".intro {",
+        "  max-width: 680px;",
+        "}",
+        "",
+        ".intro h1 {",
+        "  margin: 0 0 16px;",
+        "  font-size: 40px;",
+        "}",
+        "",
+        ".intro p {",
+        "  margin: 0;",
+        "  color: #4b5563;",
+        "  line-height: 1.6;",
+        "}",
+        "",
+    ].join("\n");
+}
+function reactTsconfig() {
+    return [
+        "{",
+        '  "compilerOptions": {',
+        '    "target": "ES2022",',
+        '    "useDefineForClassFields": true,',
+        '    "lib": ["ES2022", "DOM", "DOM.Iterable"],',
+        '    "allowJs": false,',
+        '    "skipLibCheck": true,',
+        '    "esModuleInterop": true,',
+        '    "allowSyntheticDefaultImports": true,',
+        '    "strict": true,',
+        '    "module": "ESNext",',
+        '    "moduleResolution": "Bundler",',
+        '    "resolveJsonModule": true,',
+        '    "isolatedModules": true,',
+        '    "noEmit": true,',
+        '    "jsx": "react-jsx"',
+        "  },",
+        '  "include": ["src"]',
+        "}",
+        "",
+    ].join("\n");
+}
+function reactViteConfig() {
+    return [
+        'import react from "@vitejs/plugin-react";',
+        'import { defineConfig } from "vite";',
+        "",
+        "export default defineConfig({",
+        "  plugins: [react()],",
+        "});",
+        "",
+    ].join("\n");
+}
+export function createSessionPayload(options) {
+    const descriptor = descriptorForPreset(options.preset, options.label);
+    return {
+        externalId: options.externalId,
+        markupPreset: options.preset,
+        target: {
+            kind: targetKindForPreset(options.preset),
+            label: options.label,
+            ...(options.preset === "signature"
+                ? {
+                    inputMapping: "surface",
+                    coordinateSpace: { width: 1600, height: 500 },
+                }
+                : options.preset === "initials"
+                    ? {
+                        inputMapping: "surface",
+                        coordinateSpace: { width: 800, height: 500 },
+                    }
+                    : {}),
+            metadata: {
+                descriptor,
+            },
+        },
+        ...(options.expiresInMs == null
+            ? {}
+            : { expiresInMs: options.expiresInMs }),
+    };
+}
+function descriptorForPreset(preset, label) {
+    if (preset === "signature" || preset === "initials") {
+        return {
+            version: 1,
+            privacy: "metadata-only",
+            surfaceRole: "field",
+            inputIntent: preset,
+            label,
+            components: [
+                {
+                    id: preset,
+                    role: "field",
+                    inputIntent: preset,
+                    required: true,
+                    bounds: { minX: 0.1, minY: 0.68, maxX: 0.9, maxY: 0.86 },
+                },
+            ],
+            phoneHints: {
+                preferredLayout: "signature-pad",
+                preferredTool: "freehand",
+                primaryActionLabel: "Submit",
+                showUndo: true,
+                showClear: true,
+            },
+        };
+    }
+    if (preset === "approval") {
+        return {
+            version: 1,
+            privacy: "metadata-only",
+            surfaceRole: "field",
+            inputIntent: "approval",
+            label,
+            phoneHints: {
+                preferredLayout: "approval-pad",
+                preferredTool: "point",
+                primaryActionLabel: "Approve",
+            },
+        };
+    }
+    return {
+        version: 1,
+        privacy: "metadata-only",
+        surfaceRole: surfaceRoleForPreset(preset),
+        inputIntent: preset === "pointer" ? "point" : "annotate",
+        label,
+        phoneHints: {
+            preferredLayout: preset === "pointer" ? "pointing-pad" : "annotation-pad",
+            preferredTool: preset === "pointer" ? "point" : "freehand",
+            primaryActionLabel: "Done",
+            showUndo: true,
+            showClear: true,
+        },
+    };
+}
+function targetKindForPreset(preset) {
+    if (preset === "signature" ||
+        preset === "initials" ||
+        preset === "approval") {
+        return "field";
+    }
+    if (preset === "photoMarkup" || preset === "designReview")
+        return "image";
+    if (preset === "pdfMarkup")
+        return "pdf";
+    if (preset === "mapMarkup")
+        return "map";
+    if (preset === "screenMarkup" || preset === "pointer")
+        return "screen";
+    return "svg";
+}
+function surfaceRoleForPreset(preset) {
+    if (preset === "photoMarkup" || preset === "designReview")
+        return "image";
+    if (preset === "mapMarkup")
+        return "map";
+    if (preset === "screenMarkup" || preset === "pointer")
+        return "screen";
+    if (preset === "sketch")
+        return "canvas";
+    return "document";
+}
+function labelForPreset(preset) {
+    const labels = {
+        signature: "Customer signature",
+        initials: "Customer initials",
+        approval: "Quick approval",
+        sketch: "Sketch input",
+        photoMarkup: "Photo annotation",
+        pdfMarkup: "PDF annotation",
+        mapMarkup: "Map annotation",
+        screenMarkup: "Screen annotation",
+        designReview: "Design review",
+        pointer: "Pointer input",
+    };
+    return labels[preset];
+}
+function curlForCreateInput(apiBaseUrl, payload) {
+    return [
+        "curl -sS",
+        "-X POST",
+        shellQuote(`${printableApiBaseUrl(apiBaseUrl)}/v1/sessions`),
+        "-H 'Authorization: Bearer <REMOTEDRAW_API_KEY>'",
+        "-H 'Content-Type: application/json'",
+        "--data",
+        shellQuote(JSON.stringify(payload)),
+    ].join(" ");
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\"'\"'`)}'`;
+}
+function normalizedOrigin(value) {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        throw new Error("Expected an HTTP(S) API base URL.");
+    }
+    if (parsed.pathname !== "/" || parsed.search || parsed.hash) {
+        throw new Error("Expected API base URL to be an origin without a path, query, or hash.");
+    }
+    return parsed.origin;
+}
+function printableApiBaseUrl(value) {
+    if (value.includes("<"))
+        return value.trim().replace(/\/+$/, "");
+    return normalizedOrigin(value);
+}
+function resolveAgentPath(value, runtime) {
+    if (value === "~")
+        return runtime.env.HOME ?? value;
+    if (value.startsWith("~/")) {
+        const home = runtime.env.HOME;
+        if (home == null) {
+            throw new Error("Cannot expand ~ because HOME is not set.");
+        }
+        return path.join(home, value.slice(2));
+    }
+    return path.resolve(runtime.cwd, value);
+}
+export function agentSkillMarkdown() {
+    return [
+        "---",
+        "name: remotedraw",
+        "description: Add RemoteDraw phone input to customer apps with the RemoteDraw CLI, public API, React SDK, raw HTTP, or customer-owned iOS sender flow.",
+        "---",
+        "",
+        "# RemoteDraw Agent Skill",
+        "",
+        "Use this skill when a user asks to create, initialize, debug, or review a RemoteDraw integration.",
+        "",
+        "## Decision Flow",
+        "",
+        "1. Identify the receiver surface: web app, desktop app, iOS app, or headless/backend workflow.",
+        "2. Identify the sender surface: RemoteDraw iOS app, embedded web sender, customer-owned iOS sender, or raw/headless sender.",
+        "3. Pick the SDK path:",
+        "   - React SDK: web receiver and optional embedded web sender.",
+        "   - Plain JavaScript/raw HTTP: non-React web, desktop, backend, or custom clients.",
+        "   - Swift: customer-owned iOS sender apps.",
+        "4. Pick a supported starter: signature for the product-ready SignatureStrip, or sketch for a receiver UI owned by the integrating app. Configure target kind and descriptors directly for photos, PDFs, maps, screens, and other custom surfaces.",
+        "",
+        "## CLI First",
+        "",
+        "Read the machine-readable option catalog before choosing a plan:",
+        "",
+        "```sh",
+        "remotedraw options --format json",
+        "```",
+        "",
+        "Initialize a project with the closest supported path:",
+        "",
+        "```sh",
+        "remotedraw init --target web --sender remotedraw-ios --sdk react --preset signature",
+        "remotedraw init --target web --sender embedded-web --sdk react --preset sketch",
+        "remotedraw init --target desktop --sender remotedraw-ios --sdk js --preset sketch",
+        "remotedraw init --target ios --sender own-ios --sdk swift --preset sketch",
+        "```",
+        "",
+        "By default, new/init create the dashboard project and a project-scoped development API key, then write REMOTEDRAW_API_BASE_URL, REMOTEDRAW_PROJECT_ID, and REMOTEDRAW_API_KEY to a gitignored .env.local. Use --offline only when cloud setup is intentionally out of scope.",
+        "",
+        "Agents must use explicit non-interactive dry runs before changing a project:",
+        "",
+        "```sh",
+        "remotedraw init --non-interactive --offline --dry-run --format json --target web --sender remotedraw-ios --sdk react --preset signature --package-manager npm",
+        "# Inspect plan, files, defaultsApplied, and warnings before applying.",
+        "remotedraw init --non-interactive --offline --format json --target web --sender remotedraw-ios --sdk react --preset signature --package-manager npm",
+        "remotedraw doctor --format json",
+        "remotedraw create-input --preset signature --json",
+        "```",
+        "",
+        "Do not use the interactive wizard, synthesize arrow-key input, or scrape human-formatted output. If receiver, sender, or preset intent is ambiguous, ask the user instead of guessing. Never pass --force unless overwrite scope was explicitly approved.",
+        "",
+        "## Security Rules",
+        "",
+        "- Keep `rd_sk_...` API keys in trusted backend secrets only.",
+        "- Keep the account-level `rd_cli_...` credential in the user config directory; never copy it into a project. Use REMOTEDRAW_CLI_TOKEN only as an explicitly managed CI secret.",
+        "- Never place API keys in browser bundles, mobile clients, screenshots, logs, or generated examples.",
+        "- Public clients should receive only `joinUrl`, `joinToken`, `receiverToken`, or `senderToken` values scoped to the session.",
+        "- Production QR codes should use HTTPS `joinUrl` values. Do not make the custom scheme the primary QR target.",
+        "",
+        "## API Contract",
+        "",
+        "- Backend creates sessions with `POST /v1/sessions`.",
+        "- Receiver clients read `POST /v1/receiver/session`, `/drawings`, `/drafts`, and `/senders` with a receiver token.",
+        "- Sender clients join with `POST /v1/join`, stream mutable drafts to `/v1/sender/draft`, commit durable strokes to `/v1/sender/commit`, and finish with `/v1/sender/submit`.",
+        "- Custom senders should throttle draft updates, coalesce to the latest pending preview, and commit one durable stroke on pointer-up with a stable `clientStrokeId`.",
+        "",
+        "## Verification",
+        "",
+        "After changes, run the narrowest relevant checks first:",
+        "",
+        "```sh",
+        "remotedraw doctor",
+        "bun run test:api",
+        "bun run typecheck",
+        "```",
+        "",
+        "For customer-owned iOS sender helpers in this repo, also run:",
+        "",
+        "```sh",
+        "bun run ios:kit:test",
+        "```",
+    ].join("\n");
+}
+function isHttpOrigin(value) {
+    if (value == null || value.includes("<"))
+        return false;
+    try {
+        normalizedOrigin(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function planDefaultsForExample(example) {
+    if (example === "react-owned-sender") {
+        return {
+            target: "web",
+            sender: "embedded-web",
+            sdk: "react",
+            preset: "sketch",
+        };
+    }
+    if (example === "raw-http") {
+        return {
+            target: "desktop",
+            sender: "remotedraw-ios",
+            sdk: "js",
+            preset: "sketch",
+        };
+    }
+    if (example === "ios-owned-sender") {
+        return { target: "ios", sender: "own-ios", sdk: "swift", preset: "sketch" };
+    }
+    return {
+        target: "web",
+        sender: "remotedraw-ios",
+        sdk: "react",
+        preset: "signature",
+    };
+}
+function scaffoldSummary(verb, plan, outputDir, written, dryRun) {
+    const nextCommandPrefix = dryRun ? "Would write" : "Wrote";
+    return [
+        `${verb} RemoteDraw ${plan.target} integration in ${outputDir}`,
+        "",
+        "Choices:",
+        `  App: ${plan.appName}`,
+        `  SDK: ${plan.sdk}`,
+        `  Sender: ${plan.sender}`,
+        `  Starter: ${plan.preset}`,
+        "",
+        `${nextCommandPrefix}:`,
+        ...written.map((file) => `  ${file}`),
+        "",
+        "Next:",
+        `  1. ${installCommand(plan.packageManager)}`,
+        "  2. Set REMOTEDRAW_API_BASE_URL and REMOTEDRAW_API_KEY in backend secrets.",
+        "  3. Create an input request from backend code or run remotedraw create-input --json.",
+        "  4. Render the returned HTTPS joinUrl in your receiver UI.",
+    ].join("\n");
+}
+function scaffoldJsonResult(command, plan, outputDir, files, parsed, provisioning, offline, dryRun) {
+    const resolvedFields = [
+        ["appName", "app-name", plan.appName],
+        ["target", "target", plan.target],
+        ["sender", "sender", plan.sender],
+        ["sdk", "sdk", plan.sdk],
+        ["preset", "preset", plan.preset],
+        ["packageManager", "package-manager", plan.packageManager],
+        ["apiBaseUrl", "api-base-url", plan.apiBaseUrl],
+    ];
+    const defaultsApplied = resolvedFields
+        .filter(([, flag]) => readString(parsed, flag) == null)
+        .map(([field, , value]) => ({ field, value }));
+    const warnings = [
+        ...(plan.apiBaseUrl.includes("<deployment>")
+            ? ["Replace the deployment API placeholder before making live requests."]
+            : []),
+        ...(offline
+            ? [
+                "Cloud provisioning was skipped; no dashboard project or API key was created.",
+            ]
+            : dryRun
+                ? [
+                    "Cloud authentication and provisioning were not executed during dry-run.",
+                ]
+                : []),
+    ];
+    return {
+        ok: true,
+        command,
+        mode: dryRun ? "dry-run" : "apply",
+        plan: { ...plan },
+        defaultsApplied,
+        outputDir,
+        files,
+        warnings,
+        cloud: dryRun
+            ? { mode: "dry-run" }
+            : offline
+                ? { mode: "offline" }
+                : provisioning
+                    ? {
+                        mode: "provisioned",
+                        projectId: provisioning.project.id,
+                        dashboardUrl: provisioning.project.dashboardUrl,
+                    }
+                    : { mode: "not-run" },
+        nextCommands: [
+            installCommand(plan.packageManager),
+            "remotedraw doctor --format json",
+            `remotedraw create-input --preset ${plan.preset} --json`,
+        ],
+    };
+}
+function statusLine(state, label, message) {
+    return `[${state}] ${label}: ${message}`;
+}
+function installCommand(packageManager) {
+    if (packageManager === "npm")
+        return "npm install";
+    if (packageManager === "pnpm")
+        return "pnpm install";
+    if (packageManager === "yarn")
+        return "yarn install";
+    return "bun install";
+}
+function devCommandForPackageManager(packageManager) {
+    if (packageManager === "npm")
+        return "npm run dev";
+    if (packageManager === "pnpm")
+        return "pnpm dev";
+    if (packageManager === "yarn")
+        return "yarn dev";
+    return "bun run dev";
+}
+function titleCase(value) {
+    return value
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((segment) => segment[0]?.toUpperCase() + segment.slice(1))
+        .join(" ");
+}
+function slugify(value) {
+    const slug = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || "remotedraw-app";
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+function escapeText(value) {
+    return value.replaceAll("{", "&#123;").replaceAll("}", "&#125;");
+}