@zaflun/lumio-cli 0.6.2 → 0.10.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/program.ts
-import { Command } from "commander";
-import { createRequire as createRequire2 } from "module";
+import { Command as Command2 } from "commander";
+import { createRequire as createRequire3 } from "module";
 
 // src/commands/login.ts
 import * as http from "http";
@@ -105,13 +105,13 @@ function registerLogin(program2) {
       return;
     }
     const redirectUri = `http://localhost:${port}/callback`;
-    await new Promise((resolve10, reject) => {
+    await new Promise((resolve13, reject) => {
       let timeout;
       const server = http.createServer(async (req, res) => {
         const finish = () => {
           clearTimeout(timeout);
           server.close();
-          resolve10();
+          resolve13();
         };
         const fail = (err) => {
           clearTimeout(timeout);
@@ -302,6 +302,22 @@ function registerWhoami(program2) {
 // src/commands/init.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
+var SERVER_SCHEMA_SCAFFOLD = `import { defineSchema, defineTable, v } from "@zaflun/lumio-sdk/server";
+
+export default defineSchema({
+  items: defineTable({
+    text: v.string(),
+    completed: v.boolean(),
+  }).storage("instance"),
+});
+`;
+var SERVER_FUNCTIONS_SCAFFOLD = `import { queryRows, insertRow, patchRow, deleteRow, arg } from "@zaflun/lumio-sdk/server";
+
+export const getItems = queryRows("items", { orderBy: "created_at", orderDir: "asc" });
+export const addItem = insertRow("items", { text: arg("text"), completed: false }, { editorOnly: true });
+export const toggleItem = patchRow("items", arg("id"), { completed: arg("completed") }, { editorOnly: true });
+export const removeItem = deleteRow("items", arg("id"), { editorOnly: true });
+`;
 function registerInit(program2) {
   program2.command("init").argument("[name]", "Extension project name").description("Create a new extension project with interactive wizard").action(async (name) => {
     const store = new CredentialStore();
@@ -403,7 +419,7 @@ function registerInit(program2) {
           type: "checkbox",
           name: "targets",
           message: "Targets:",
-          choices: ["editor", "layer", "interactive"],
+          choices: ["editor", "layer"],
           default: ["editor", "layer"]
         },
         { type: "confirm", name: "server", message: "Server functions?", default: false }
@@ -465,7 +481,7 @@ function registerInit(program2) {
     } catch (err) {
       if (err.status === 404) {
         console.error(
-          "\n  You need to apply as a developer first.\n  Visit https://lumio.vision/account/developer to submit your application.\n"
+          "\n  You need to apply as a developer first.\n  Visit https://lumio.vision/dashboard/settings/developer to submit your application.\n"
         );
         process.exit(1);
       }
@@ -579,6 +595,8 @@ function registerInit(program2) {
       },
       devDependencies: {
         "typescript": "^6.0.3",
+        // `lumio dev` runs the extension on the devkit's mock host.
+        ...!isAutomationNode ? { "@zaflun/lumio-devkit": "latest" } : {},
         ...needsReact ? { "@types/react": "^19.1.0" } : {},
         ...useTailwind ? { "tailwindcss": "^4.3.0" } : {}
       }
@@ -707,10 +725,8 @@ Lumio.render(<App />, { target: "${target}" });
       }
       if (answers.server) {
         fs2.mkdirSync(path2.join(projectDir, "server"), { recursive: true });
-        const schema = 'import { defineSchema, defineTable, v } from "@zaflun/lumio-sdk/server";\n\nexport default defineSchema({\n  items: defineTable({\n    text: v.string(),\n    completed: v.boolean(),\n  }).storage("instance"),\n});\n';
-        fs2.writeFileSync(path2.join(projectDir, "server", "schema.ts"), schema);
-        const functions = 'import { queryRows, insertRow, patchRow, deleteRow, arg } from "@zaflun/lumio-sdk/server";\n\nexport const getItems = queryRows("items");\nexport const addItem = insertRow("items", { text: arg("text"), completed: false }, { editorOnly: true });\nexport const toggleItem = patchRow("items", arg("id"), { completed: arg("completed") }, { editorOnly: true });\nexport const removeItem = deleteRow("items", arg("id"), { editorOnly: true });\n';
-        fs2.writeFileSync(path2.join(projectDir, "server", "functions.ts"), functions);
+        fs2.writeFileSync(path2.join(projectDir, "server", "schema.ts"), SERVER_SCHEMA_SCAFFOLD);
+        fs2.writeFileSync(path2.join(projectDir, "server", "functions.ts"), SERVER_FUNCTIONS_SCAFFOLD);
       }
     }
     console.log(`
@@ -720,17 +736,20 @@ Done! Created ${projectDir}/`);
 }
 
 // src/commands/dev.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
+import { InvalidArgumentError } from "commander";
+import chalk3 from "chalk";
 
 // src/config/parser.ts
 import { NODE_TYPES, TRIGGER_MODES, VALID_PLATFORMS } from "@zaflun/lumio-extension-types";
 var ConfigError = class extends Error {
-  constructor(message) {
-    super(message);
+  constructor(message2) {
+    super(message2);
     this.name = "ConfigError";
   }
 };
+var VALID_TARGETS = ["editor", "layer", "designer"];
 function parseConfigFile(jsonString) {
   const raw = JSON.parse(jsonString);
   return {
@@ -806,111 +825,45 @@ function validateConfig(config) {
       }
     }
   } else if (!config.targets || config.targets.length === 0) {
-    throw new ConfigError("At least one target is required (editor, layer, or interactive)");
+    throw new ConfigError("At least one target is required (editor or layer)");
+  }
+  const unknownTargets = (config.targets ?? []).filter((t) => !VALID_TARGETS.includes(t));
+  if (unknownTargets.length > 0) {
+    throw new ConfigError(
+      `Invalid target(s): ${unknownTargets.join(", ")}. Must be one of: ${VALID_TARGETS.join(", ")}. Viewer input comes through chat commands and channel point rewards handled by a bot module.`
+    );
   }
   if (!config.version) {
     throw new ConfigError("version is required in lumio.config.json");
   }
 }
 
-// src/commands/dev-bot-module.ts
+// src/commands/dev-automation-node.ts
 import * as readline from "readline";
 import chalk from "chalk";
-function parseUserPrefix(input) {
-  const defaultUser = {
-    id: "user-001",
-    name: "dev_user",
-    displayName: "Dev User",
-    platform: "twitch",
-    role: "everyone",
-    isMod: false,
-    isVip: false,
-    isSub: false
-  };
-  if (!input.startsWith("@")) {
-    return { user: defaultUser, message: input };
-  }
-  const spaceIdx = input.indexOf(" ");
-  if (spaceIdx === -1) return { user: defaultUser, message: input };
-  const prefix = input.substring(1, spaceIdx);
-  const message = input.substring(spaceIdx + 1);
-  const parts = prefix.split(":");
-  const name = parts[parts.length - 1];
-  const rolePrefix = parts.length > 1 ? parts[0] : "everyone";
-  return {
-    user: {
-      id: `user-${name}`,
-      name,
-      displayName: name,
-      platform: "twitch",
-      role: rolePrefix,
-      isMod: rolePrefix === "mod",
-      isVip: rolePrefix === "vip",
-      isSub: ["sub", "vip", "mod", "broadcaster"].includes(rolePrefix)
-    },
-    message
-  };
-}
-async function runBotModuleDevServer(config) {
-  console.log(chalk.bold("\n\u{1F916} Bot Module Dev Server"));
-  console.log(`Extension: ${config.name}`);
-  console.log(`Platforms: ${config.platforms?.join(", ") ?? "none"}`);
-  console.log(chalk.dim("\nType chat messages. Prefix with @username or @role:username."));
-  console.log(chalk.dim("Examples: !hello  |  @sub:viewer !points 100  |  @mod:admin gg"));
-  console.log(chalk.dim("Type !quit to exit.\n"));
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: chalk.cyan("> ")
-  });
-  rl.prompt();
-  rl.on("line", async (line) => {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      rl.prompt();
-      return;
-    }
-    if (trimmed === "!quit") {
-      rl.close();
-      return;
-    }
-    const { user, message } = parseUserPrefix(trimmed);
-    console.log(chalk.dim(`  [${user.role}:${user.name}] ${message}`));
-    console.log(chalk.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
-    rl.prompt();
-  });
-  rl.on("close", () => {
-    console.log(chalk.dim("\nBot Module Dev Server stopped."));
-    process.exit(0);
-  });
-}
-
-// src/commands/dev-automation-node.ts
-import * as readline2 from "readline";
-import chalk2 from "chalk";
 async function runAutomationNodeDevServer(config) {
   const nodeType = config.nodeType ?? "action";
-  console.log(chalk2.bold("\n\u2699\uFE0F  Automation Node Dev Server"));
+  console.log(chalk.bold("\n\u2699\uFE0F  Automation Node Dev Server"));
   console.log(`Extension: ${config.name}`);
   console.log(`Node type: ${nodeType}`);
   if (nodeType === "trigger" && config.node?.triggerMode) {
     console.log(`Trigger mode: ${config.node.triggerMode}`);
   }
-  console.log(chalk2.dim("\nCommands:"));
-  console.log(chalk2.dim("  /execute [json]     \u2014 Execute the node with input data"));
+  console.log(chalk.dim("\nCommands:"));
+  console.log(chalk.dim("  /execute [json]     \u2014 Execute the node with input data"));
   if (nodeType === "trigger") {
-    console.log(chalk2.dim("  /webhook [json]     \u2014 Simulate a webhook POST payload"));
-    console.log(chalk2.dim("  /poll               \u2014 Trigger a poll cycle"));
+    console.log(chalk.dim("  /webhook [json]     \u2014 Simulate a webhook POST payload"));
+    console.log(chalk.dim("  /poll               \u2014 Trigger a poll cycle"));
   }
-  console.log(chalk2.dim("  /config [json]      \u2014 Set node instance config"));
-  console.log(chalk2.dim("  /install-config [j] \u2014 Set extension install config"));
-  console.log(chalk2.dim("  /quit               \u2014 Exit\n"));
+  console.log(chalk.dim("  /config [json]      \u2014 Set node instance config"));
+  console.log(chalk.dim("  /install-config [j] \u2014 Set extension install config"));
+  console.log(chalk.dim("  /quit               \u2014 Exit\n"));
   let nodeConfig = {};
   let installConfig = {};
-  const rl = readline2.createInterface({
+  const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: chalk2.cyan("> ")
+    prompt: chalk.cyan("> ")
   });
   rl.prompt();
   rl.on("line", async (line) => {
@@ -926,9 +879,9 @@ async function runAutomationNodeDevServer(config) {
     if (trimmed.startsWith("/config ")) {
       try {
         nodeConfig = JSON.parse(trimmed.slice("/config ".length));
-        console.log(chalk2.green("  Node config updated."));
+        console.log(chalk.green("  Node config updated."));
       } catch {
-        console.log(chalk2.red("  Invalid JSON."));
+        console.log(chalk.red("  Invalid JSON."));
       }
       rl.prompt();
       return;
@@ -936,9 +889,9 @@ async function runAutomationNodeDevServer(config) {
     if (trimmed.startsWith("/install-config ")) {
       try {
         installConfig = JSON.parse(trimmed.slice("/install-config ".length));
-        console.log(chalk2.green("  Install config updated."));
+        console.log(chalk.green("  Install config updated."));
       } catch {
-        console.log(chalk2.red("  Invalid JSON."));
+        console.log(chalk.red("  Invalid JSON."));
       }
       rl.prompt();
       return;
@@ -950,15 +903,15 @@ async function runAutomationNodeDevServer(config) {
         try {
           inputData = JSON.parse(jsonStr);
         } catch {
-          console.log(chalk2.red("  Invalid JSON."));
+          console.log(chalk.red("  Invalid JSON."));
           rl.prompt();
           return;
         }
       }
-      console.log(chalk2.dim(`  [${nodeType}] Executing with input: ${JSON.stringify(inputData)}`));
-      console.log(chalk2.dim(`  [${nodeType}] Node config: ${JSON.stringify(nodeConfig)}`));
-      console.log(chalk2.dim(`  [${nodeType}] Install config: ${JSON.stringify(installConfig)}`));
-      console.log(chalk2.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
+      console.log(chalk.dim(`  [${nodeType}] Executing with input: ${JSON.stringify(inputData)}`));
+      console.log(chalk.dim(`  [${nodeType}] Node config: ${JSON.stringify(nodeConfig)}`));
+      console.log(chalk.dim(`  [${nodeType}] Install config: ${JSON.stringify(installConfig)}`));
+      console.log(chalk.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
       rl.prompt();
       return;
     }
@@ -969,297 +922,2987 @@ async function runAutomationNodeDevServer(config) {
         try {
           body = JSON.parse(jsonStr);
         } catch {
-          console.log(chalk2.red("  Invalid JSON."));
+          console.log(chalk.red("  Invalid JSON."));
           rl.prompt();
           return;
         }
       }
-      console.log(chalk2.dim(`  [trigger:webhook] Received payload: ${JSON.stringify(body)}`));
-      console.log(chalk2.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
+      console.log(chalk.dim(`  [trigger:webhook] Received payload: ${JSON.stringify(body)}`));
+      console.log(chalk.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
       rl.prompt();
       return;
     }
     if (nodeType === "trigger" && trimmed === "/poll") {
-      console.log(chalk2.dim("  [trigger:poll] Polling..."));
-      console.log(chalk2.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
+      console.log(chalk.dim("  [trigger:poll] Polling..."));
+      console.log(chalk.yellow("  \u2192 Handler execution not yet wired (requires esbuild + V8)"));
       rl.prompt();
       return;
     }
-    console.log(chalk2.dim("  Unknown command. Type /execute, /webhook, /poll, /config, or /quit."));
+    console.log(chalk.dim("  Unknown command. Type /execute, /webhook, /poll, /config, or /quit."));
     rl.prompt();
   });
   rl.on("close", () => {
-    console.log(chalk2.dim("\nAutomation Node Dev Server stopped."));
+    console.log(chalk.dim("\nAutomation Node Dev Server stopped."));
     process.exit(0);
   });
 }
 
-// src/commands/dev.ts
-function registerDev(program2) {
-  program2.command("dev").description("Start local dev server with hot-reload and mock events").option("-p, --port <port>", "Dev server port", "3100").option("--bot-module", "Start interactive bot module chat simulator").option("--automation-node", "Start automation node dev simulator").action(async (options) => {
-    const configPath = path3.resolve("lumio.config.json");
-    if (options.botModule || options.automationNode || fs3.existsSync(configPath)) {
-      const configExists = fs3.existsSync(configPath);
-      if (configExists) {
-        const config = parseConfigFile(fs3.readFileSync(configPath, "utf-8"));
-        if (options.botModule || config.category === "bot_module") {
-          await runBotModuleDevServer(config);
-          return;
-        }
-        if (options.automationNode || config.category === "automation_node") {
-          await runAutomationNodeDevServer(config);
-          return;
-        }
-      } else if (options.botModule || options.automationNode) {
-        console.error("lumio.config.json not found. Run `lumio init` first.");
-        process.exit(1);
-      }
-    }
-    console.log(`Starting Lumio dev server on port ${options.port}...`);
-    console.log("Mock events enabled. Hot-reload active.");
-    console.log("Open http://localhost:" + options.port + " in your browser.");
-    console.log("\nDev server implementation requires @zaflun/lumio-sdk and Vite.");
-    console.log("Full implementation coming in Phase 12 (Live-Code-Editor).");
+// src/dev/builder.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+
+// src/build/pipeline.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { createRequire } from "module";
+
+// src/commands/data-schema.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var SCHEMA_FILES = ["server/schema.ts", "server/schema.js", "server/schema.mjs"];
+function findSchemaFile(projectDir) {
+  return SCHEMA_FILES.find((f) => fs3.existsSync(path3.join(projectDir, f))) ?? null;
+}
+async function loadDataSchema(projectDir) {
+  const schemaFile = findSchemaFile(projectDir);
+  if (!schemaFile) return null;
+  const { build } = await import("esbuild");
+  const result = await build({
+    entryPoints: [path3.join(projectDir, schemaFile)],
+    absWorkingDir: projectDir,
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "node",
+    target: "es2022",
+    logLevel: "silent"
   });
+  const code = result.outputFiles[0]?.text ?? "";
+  const url = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+  const mod = await import(url);
+  return toDataSchemaJson(mod.default, schemaFile);
+}
+function toDataSchemaJson(value, schemaFile = "server/schema.ts") {
+  const tables = value?.tables;
+  if (typeof tables !== "object" || tables === null || Array.isArray(tables)) {
+    throw new Error(
+      `${schemaFile} must \`export default defineSchema({ ... })\` from "@zaflun/lumio-sdk/server".`
+    );
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function formatDataSchemaError(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  const message2 = typeof parsed.message === "string" ? parsed.message : "";
+  if (parsed.error === "INVALID_DATA_SCHEMA") {
+    return [`Invalid data schema (server/schema.ts): ${message2}`];
+  }
+  if (parsed.error === "DATA_SCHEMA_NOT_ADDITIVE") {
+    const violations = Array.isArray(parsed.details?.violations) ? parsed.details.violations : [];
+    if (violations.length === 0) return [message2];
+    return [
+      "Data schema change is not additive. Published tables only allow new tables, new optional columns and relaxing NOT NULL:",
+      ...violations.map((v) => {
+        const target = v.column ? `${v.table}.${v.column}` : v.table;
+        return `  - ${target}: ${v.rule} (applied: ${v.applied}, declared: ${v.declared})`;
+      })
+    ];
+  }
+  return null;
 }
 
-// src/commands/build.ts
+// src/commands/functions-manifest.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { createRequire } from "module";
-var execFileAsync = promisify(execFile);
-function registerBuild(program2) {
-  program2.command("build").description("Bundle extension as standalone HTML + source archive").action(async () => {
-    const configPath = path4.resolve("lumio.config.json");
-    if (!fs4.existsSync(configPath)) {
-      console.error("lumio.config.json not found. Run `lumio init` first.");
-      process.exit(1);
+var FUNCTIONS_FILES = ["server/functions.ts", "server/functions.js", "server/functions.mjs"];
+var FUNCTIONS_MANIFEST_VERSION = 1;
+var FUNCTIONS_MANIFEST_FILE = "functions.json";
+var FILTER_OPERATORS = /* @__PURE__ */ new Set(["=", "!=", ">", ">=", "<", "<=", "like", "in"]);
+var NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+var FunctionsManifestError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "FunctionsManifestError";
+  }
+};
+function findFunctionsFile(projectDir) {
+  return FUNCTIONS_FILES.find((f) => fs4.existsSync(path4.join(projectDir, f))) ?? null;
+}
+function combinedServerEntry(handlerEntry, functionsFile, names) {
+  const spec = (file) => JSON.stringify(`./${file.replace(/\\/g, "/")}`);
+  const lines = [`export * from ${spec(handlerEntry)};`];
+  if (names.length > 0) {
+    lines.push(`export { ${names.join(", ")} } from ${spec(functionsFile)};`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function handlerNames(manifest) {
+  return Object.entries(manifest.functions).filter(([, entry]) => entry.kind === "handler").map(([name]) => name);
+}
+async function loadFunctionExports(projectDir) {
+  const file = findFunctionsFile(projectDir);
+  if (!file) return null;
+  const { build } = await import("esbuild");
+  const result = await build({
+    entryPoints: [path4.join(projectDir, file)],
+    absWorkingDir: projectDir,
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "node",
+    target: "es2022",
+    logLevel: "silent"
+  });
+  const code = result.outputFiles[0]?.text ?? "";
+  const url = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+  const mod = await import(url);
+  return { file, exports: { ...mod } };
+}
+function buildFunctionsManifest(exports, schema, file = "server/functions.ts") {
+  const functions = {};
+  const seen = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(exports).sort()) {
+    const value = exports[name];
+    const where = `${file}: export "${name}"`;
+    if (name === "default") {
+      throw new FunctionsManifestError(
+        `${file}: a default export is not allowed. Export each function under its name (\`export const getRules = queryRows("rules")\`).`
+      );
     }
-    const configJson = fs4.readFileSync(configPath, "utf-8");
-    const config = parseConfigFile(configJson);
-    validateConfig(config);
-    const changelogPath = path4.resolve("CHANGELOG.md");
-    if (!fs4.existsSync(changelogPath)) {
-      console.warn("Warning: No CHANGELOG.md found. It is recommended to maintain a changelog.");
+    if (!NAME_PATTERN.test(name)) {
+      throw new FunctionsManifestError(
+        `${where}: function names may only use letters, digits and "_" (at most 64 characters).`
+      );
     }
-    console.log(`Building ${config.name} v${config.version}...`);
-    const distDir = path4.resolve("dist");
-    fs4.mkdirSync(distDir, { recursive: true });
-    const { build } = await import("esbuild");
-    if (config.category === "bot_module" && config.targets.length === 0) {
-      console.log("  Bot module \u2014 no UI targets to bundle.");
+    const folded = name.toLowerCase();
+    const other = seen.get(folded);
+    if (other !== void 0) {
+      throw new FunctionsManifestError(
+        `${where}: duplicate function name \u2014 it differs from "${other}" only in case.`
+      );
     }
-    if (config.server) {
-      const serverEntry = ["server/handler.ts", "server/handler.js", "server/index.ts", "server/index.js"].find((f) => fs4.existsSync(path4.resolve(f)));
-      if (serverEntry) {
-        await build({
-          entryPoints: [path4.resolve(serverEntry)],
-          bundle: true,
-          minify: true,
-          format: "esm",
-          outfile: path4.join(distDir, "server.js"),
-          platform: "neutral",
-          target: "es2022",
-          external: ["@zaflun/lumio-sdk", "@zaflun/lumio-protocol"],
-          define: {
-            "process.env.NODE_ENV": '"production"'
-          }
-        });
-        console.log("  Built: dist/server.js");
-      } else {
-        console.warn("  Warning: server: true but no server/handler.ts or server/index.ts found.");
+    seen.set(folded, name);
+    const entry = toEntry(value, where);
+    if (entry.table !== void 0) checkTable(entry.table, schema, where);
+    functions[name] = entry;
+  }
+  return { version: FUNCTIONS_MANIFEST_VERSION, functions };
+}
+function toEntry(value, where) {
+  const type = value?.__type;
+  switch (type) {
+    case "queryRows": {
+      const def = value;
+      const entry = {
+        kind: "queryRows",
+        category: "query",
+        editorOnly: false,
+        table: tableName(def.table, where)
+      };
+      if (def.filter !== void 0) entry.filter = filters(def.filter, where);
+      if (def.orderBy !== void 0) {
+        if (typeof def.orderBy !== "string" || def.orderBy === "") {
+          throw new FunctionsManifestError(`${where}: orderBy must be a column name.`);
+        }
+        entry.orderBy = def.orderBy;
       }
-    }
-    const cssEntryFile = ["src/globals.css", "src/style.css", "src/index.css"].find((f) => fs4.existsSync(path4.resolve(f)));
-    let compiledCssPath = null;
-    if (cssEntryFile) {
-      const cssContent = fs4.readFileSync(path4.resolve(cssEntryFile), "utf-8");
-      const usesTailwind = cssContent.includes("tailwindcss") || cssContent.includes("@tailwind");
-      if (usesTailwind) {
-        console.log("  Tailwind CSS v4 detected \u2014 compiling...");
-        compiledCssPath = path4.join(distDir, "styles.css");
-        try {
-          const projectRequire = createRequire(path4.join(path4.resolve("."), "package.json"));
-          const cliPkgPath = projectRequire.resolve("@tailwindcss/cli/package.json");
-          const cliPkg = JSON.parse(fs4.readFileSync(cliPkgPath, "utf-8"));
-          const binRel = typeof cliPkg.bin === "string" ? cliPkg.bin : cliPkg.bin?.tailwindcss ?? Object.values(cliPkg.bin ?? {})[0];
-          if (!binRel) {
-            throw new Error("@tailwindcss/cli has no bin entry");
-          }
-          const binPath = path4.join(path4.dirname(cliPkgPath), binRel);
-          await execFileAsync(process.execPath, [
-            binPath,
-            "-i",
-            path4.resolve(cssEntryFile),
-            "-o",
-            compiledCssPath,
-            "--minify"
-          ], { cwd: path4.resolve(".") });
-          console.log("  Compiled: dist/styles.css");
-        } catch (err) {
-          console.error("  Error: Tailwind CSS compilation failed. Install tailwindcss v4: npm add -D tailwindcss@^4.3 @tailwindcss/cli@^4.3");
-          console.error(`  ${err instanceof Error ? err.message : String(err)}`);
-          process.exit(1);
+      if (def.orderDir !== void 0) {
+        if (def.orderDir !== "asc" && def.orderDir !== "desc") {
+          throw new FunctionsManifestError(`${where}: orderDir must be "asc" or "desc".`);
         }
-      } else {
-        compiledCssPath = path4.join(distDir, "styles.css");
-        fs4.copyFileSync(path4.resolve(cssEntryFile), compiledCssPath);
-        console.log(`  Copied: ${cssEntryFile} \u2192 dist/styles.css`);
+        entry.orderDir = def.orderDir;
       }
+      if (def.limit !== void 0) entry.limit = count(def.limit, "limit", where);
+      if (def.offset !== void 0) entry.offset = count(def.offset, "offset", where);
+      return entry;
     }
-    for (const target of config.targets) {
-      const entryPoint = path4.resolve("src", `${target}.tsx`);
-      if (!fs4.existsSync(entryPoint)) {
-        console.warn(`Warning: Entry point ${entryPoint} not found, skipping target "${target}".`);
-        continue;
+    case "insertRow": {
+      const def = value;
+      return {
+        kind: "insertRow",
+        category: "mutation",
+        editorOnly: editorOnly(def.editorOnly, where),
+        table: tableName(def.table, where),
+        values: rowValues(def.values, where)
+      };
+    }
+    case "patchRow": {
+      const def = value;
+      return {
+        kind: "patchRow",
+        category: "mutation",
+        editorOnly: editorOnly(def.editorOnly, where),
+        table: tableName(def.table, where),
+        rowId: rowId(def.rowId, where),
+        values: rowValues(def.values, where)
+      };
+    }
+    case "deleteRow": {
+      const def = value;
+      return {
+        kind: "deleteRow",
+        category: "mutation",
+        editorOnly: editorOnly(def.editorOnly, where),
+        table: tableName(def.table, where),
+        rowId: rowId(def.rowId, where)
+      };
+    }
+    case "query":
+    case "mutation":
+    case "action": {
+      if (typeof value.handler !== "function") {
+        throw new FunctionsManifestError(`${where}: ${type}() needs a handler function.`);
       }
-      await build({
-        entryPoints: [entryPoint],
-        bundle: true,
-        minify: true,
-        format: "iife",
-        globalName: "LumioExtension",
-        footer: {
-          js: "if(typeof LumioExtension!=='undefined'&&typeof LumioExtension.default==='function'){var _L=(typeof require!=='undefined'?require('@zaflun/lumio-sdk'):{}).Lumio;if(_L)_L.render(LumioExtension.default);}"
-        },
-        outdir: distDir,
-        entryNames: `${target}`,
-        jsx: "automatic",
-        target: "es2022",
-        loader: {
-          ".css": "css",
-          // Asset file loaders — copies to dist/assets/ with content hash
-          ".png": "file",
-          ".jpg": "file",
-          ".jpeg": "file",
-          ".gif": "file",
-          ".svg": "file",
-          ".webp": "file",
-          ".avif": "file",
-          ".ico": "file",
-          ".mp4": "file",
-          ".webm": "file",
-          ".ogg": "file",
-          ".mp3": "file",
-          ".wav": "file",
-          ".woff": "file",
-          ".woff2": "file",
-          ".ttf": "file",
-          ".otf": "file",
-          ".lottie": "file"
-        },
-        assetNames: "assets/[name]-[hash]",
-        external: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime", "@zaflun/lumio-sdk", "@zaflun/lumio-protocol"],
-        define: {
-          "process.env.NODE_ENV": '"production"'
-        }
-      });
-      console.log(`  Built: dist/${target}.js`);
+      const flag = editorOnly(value.editorOnly, where);
+      return { kind: "handler", category: type, editorOnly: flag };
     }
-    const { TarArchive } = await import("archiver");
-    const sourceArchivePath = path4.join(distDir, "source.tar.gz");
-    const output = fs4.createWriteStream(sourceArchivePath);
-    const archive = new TarArchive({ gzip: true });
-    archive.pipe(output);
-    archive.glob("**/*", {
-      cwd: path4.resolve("."),
-      ignore: [
-        "node_modules/**",
-        "dist/**",
-        ".git/**",
-        ".git",
-        ".next/**",
-        ".lumio-dist/**",
-        "*.tgz",
-        "*.tar.gz",
-        // Secrets & credentials must never be uploaded to the store: the
-        // archive is visible to reviewers. Exclude env files (except the
-        // example), npm/yarn auth, and local CLI state.
-        // archiver 8's readdir-glob@3 dropped the `!pattern` un-ignore
-        // feature (each ignore entry is now an independent minimatch, so a
-        // leading `!` inverts that one matcher and ignores everything else).
-        // Keep `.env.example` via an extglob instead of a negated entry.
-        "**/.env",
-        "**/.env.!(example)",
-        "**/.npmrc",
-        "**/.yarnrc",
-        "**/.yarnrc.yml",
-        "**/.lumio/**"
-      ],
-      dot: true
-    });
-    await archive.finalize();
-    console.log("  Archive: dist/source.tar.gz");
-    console.log("Build complete.");
+    case "fetchAction":
+      throw new FunctionsManifestError(
+        `${where}: fetchAction() is not supported in server functions. Call ctx.fetch() from an action() handler instead.`
+      );
+    default:
+      throw new FunctionsManifestError(
+        `${where}: not a server function definition. server/functions.ts may only export queryRows, insertRow, patchRow, deleteRow, query, mutation and action definitions \u2014 move other values into a separate module.`
+      );
+  }
+}
+function tableName(value, where) {
+  if (typeof value !== "string" || value === "") {
+    throw new FunctionsManifestError(`${where}: the table name must be a non-empty string.`);
+  }
+  return value;
+}
+function checkTable(table, schema, where) {
+  if (!schema) {
+    throw new FunctionsManifestError(
+      `${where}: uses table "${table}", but the extension has no server/schema.ts. Declare the table with defineSchema().`
+    );
+  }
+  if (!Object.prototype.hasOwnProperty.call(schema.tables, table)) {
+    const known = Object.keys(schema.tables);
+    throw new FunctionsManifestError(
+      `${where}: unknown table "${table}" (server/schema.ts declares ${known.length > 0 ? known.map((t) => `"${t}"`).join(", ") : "no tables"}).`
+    );
+  }
+}
+function editorOnly(value, where) {
+  if (value === void 0) return false;
+  if (typeof value !== "boolean") {
+    throw new FunctionsManifestError(`${where}: editorOnly must be true or false.`);
+  }
+  return value;
+}
+function rowId(value, where) {
+  if (typeof value === "string" && value !== "") return value;
+  const expr = expression(value, where);
+  if (expr?.__expr === "arg") return expr;
+  throw new FunctionsManifestError(`${where}: the row id must be a string or arg("\u2026").`);
+}
+function count(value, field, where) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return value;
+  const expr = expression(value, where);
+  if (expr?.__expr === "arg") return expr;
+  throw new FunctionsManifestError(`${where}: ${field} must be a non-negative integer or arg("\u2026").`);
+}
+function filters(value, where) {
+  const list = Array.isArray(value) ? value : [value];
+  return list.map((item) => {
+    const f = item;
+    if (typeof f !== "object" || f === null || f.__expr !== "filter") {
+      throw new FunctionsManifestError(`${where}: filter must be filter(field, op, value) or a list of them.`);
+    }
+    if (typeof f.field !== "string" || f.field === "") {
+      throw new FunctionsManifestError(`${where}: filter field must be a column name.`);
+    }
+    if (typeof f.op !== "string" || !FILTER_OPERATORS.has(f.op)) {
+      throw new FunctionsManifestError(
+        `${where}: unsupported filter operator ${JSON.stringify(f.op)} (use ${[...FILTER_OPERATORS].map((o) => `"${o}"`).join(", ")}).`
+      );
+    }
+    return { field: f.field, op: f.op, value: jsonValue(f.value, `${where} (filter "${f.field}")`) };
   });
 }
-
-// src/commands/deploy.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-
-// src/changelog/parser.ts
-var VERSION_HEADER_REGEX = /^## \[([^\]]+)\](?:\s*-\s*(\d{4}-\d{2}-\d{2}))?/;
-function parseChangelog(markdown) {
-  const lines = markdown.split("\n");
-  const entries = [];
-  let currentEntry = null;
-  const contentLines = [];
-  for (const line of lines) {
-    const match = line.match(VERSION_HEADER_REGEX);
-    if (match) {
-      if (currentEntry) {
-        currentEntry.content = contentLines.join("\n").trim();
-        entries.push(currentEntry);
-        contentLines.length = 0;
-      }
-      currentEntry = {
-        version: match[1],
-        date: match[2] ?? null,
-        content: ""
-      };
-    } else if (currentEntry) {
-      contentLines.push(line);
+function rowValues(value, where) {
+  if (!isPlainObject(value)) {
+    throw new FunctionsManifestError(`${where}: row values must be an object of column \u2192 value.`);
+  }
+  return jsonValue(value, where);
+}
+function expression(value, where) {
+  if (!isPlainObject(value) || !("__expr" in value)) return null;
+  const expr = value.__expr;
+  if (expr === "arg") {
+    if (typeof value.name !== "string" || value.name === "") {
+      throw new FunctionsManifestError(`${where}: arg() needs a parameter name.`);
     }
+    return { __expr: "arg", name: value.name };
   }
-  if (currentEntry) {
-    currentEntry.content = contentLines.join("\n").trim();
-    entries.push(currentEntry);
+  if (expr === "identity") return { __expr: "identity" };
+  if (expr === "secret") {
+    throw new FunctionsManifestError(
+      `${where}: secret() is only available in action() handlers, not in declarative functions.`
+    );
   }
-  return entries;
+  throw new FunctionsManifestError(`${where}: ${JSON.stringify(expr)} expression is not allowed here.`);
 }
-function getVersionEntry(changelog, version) {
-  const entries = parseChangelog(changelog);
-  return entries.find((e) => e.version === version) ?? null;
+function jsonValue(value, where, stack = []) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new FunctionsManifestError(`${where}: ${value} is not a JSON number.`);
+    }
+    return value;
+  }
+  if (value === void 0) {
+    throw new FunctionsManifestError(`${where}: undefined is not a JSON value; use null.`);
+  }
+  if (typeof value !== "object") {
+    throw new FunctionsManifestError(`${where}: a ${typeof value} value cannot be serialised.`);
+  }
+  if (stack.includes(value)) {
+    throw new FunctionsManifestError(`${where}: circular value cannot be serialised.`);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => jsonValue(item, where, [...stack, value]));
+  }
+  if (!isPlainObject(value)) {
+    const ctor = value.constructor?.name ?? "object";
+    throw new FunctionsManifestError(`${where}: a ${ctor} value cannot be serialised; use plain JSON.`);
+  }
+  const expr = expression(value, where);
+  if (expr) return expr;
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    out[key] = jsonValue(item, where, [...stack, value]);
+  }
+  return out;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
 }
 
-// src/commands/deploy.ts
-function collectFiles(dir, base = dir) {
-  const entries = fs5.readdirSync(dir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const fullPath = path5.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...collectFiles(fullPath, base));
-    } else if (entry.isFile()) {
-      files.push(path5.relative(base, fullPath));
+// src/build/pipeline.ts
+var execFileAsync = promisify(execFile);
+var HANDLER_FILES = ["server/handler.ts", "server/handler.js", "server/index.ts", "server/index.js"];
+var CSS_ENTRY_FILES = ["src/globals.css", "src/style.css", "src/index.css"];
+var TARGET_FOOTER = "if(typeof LumioExtension!=='undefined'&&typeof LumioExtension.default==='function'){var _L=(typeof require!=='undefined'?require('@zaflun/lumio-sdk'):{}).Lumio;if(_L)_L.render(LumioExtension.default);}";
+var ASSET_LOADERS = Object.fromEntries(
+  [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".avif", ".ico", ".mp4", ".webm", ".ogg", ".mp3", ".wav", ".woff", ".woff2", ".ttf", ".otf", ".lottie"].map((ext) => [ext, "file"])
+);
+function define(mode) {
+  return { "process.env.NODE_ENV": JSON.stringify(mode.dev ? "development" : "production") };
+}
+function targetEntry(projectDir, target) {
+  const entry = path5.join(projectDir, "src", `${target}.tsx`);
+  return fs5.existsSync(entry) ? entry : null;
+}
+function targetBuildOptions(entryPoint, outdir, target, mode = {}) {
+  return {
+    entryPoints: [entryPoint],
+    bundle: true,
+    minify: !mode.dev,
+    format: "iife",
+    globalName: "LumioExtension",
+    footer: { js: TARGET_FOOTER },
+    // outdir instead of outfile so esbuild can emit asset files alongside JS;
+    // entryNames keeps the target name.
+    outdir,
+    entryNames: target,
+    jsx: "automatic",
+    target: "es2022",
+    loader: { ".css": "css", ...ASSET_LOADERS },
+    assetNames: "assets/[name]-[hash]",
+    external: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime", "@zaflun/lumio-sdk", "@zaflun/lumio-protocol"],
+    define: define(mode)
+  };
+}
+async function planServerBuild(projectDir, config, outfile, mode = {}) {
+  const functionsFile = config.category !== "automation_node" ? findFunctionsFile(projectDir) : null;
+  const schema = await loadDataSchema(projectDir);
+  let manifest = null;
+  if (functionsFile) {
+    const loaded = await loadFunctionExports(projectDir);
+    manifest = buildFunctionsManifest(loaded?.exports ?? {}, schema, functionsFile);
+  }
+  const handlerEntry = HANDLER_FILES.find((f) => fs5.existsSync(path5.join(projectDir, f))) ?? null;
+  const sfHandlers = manifest ? handlerNames(manifest) : [];
+  const entry = handlerEntry && functionsFile && sfHandlers.length > 0 ? {
+    stdin: {
+      contents: combinedServerEntry(handlerEntry, functionsFile, sfHandlers),
+      resolveDir: projectDir,
+      sourcefile: "lumio-server-entry.ts",
+      loader: "ts"
     }
+  } : handlerEntry || functionsFile ? { entryPoints: [path5.join(projectDir, handlerEntry ?? functionsFile)] } : null;
+  const options = entry ? {
+    ...entry,
+    absWorkingDir: projectDir,
+    bundle: true,
+    // Minified in dev too: the isolate's ESM → script transform (backend
+    // and devkit replica alike) reads esbuild's minified import/export form.
+    minify: true,
+    format: "esm",
+    outfile,
+    platform: "neutral",
+    target: "es2022",
+    external: ["@zaflun/lumio-sdk", "@zaflun/lumio-protocol"],
+    define: define(mode)
+  } : null;
+  return { options, manifest, schema, handlerEntry, functionsFile };
+}
+function findCssEntry(projectDir) {
+  return CSS_ENTRY_FILES.find((f) => fs5.existsSync(path5.join(projectDir, f))) ?? null;
+}
+async function compileCss(projectDir, outDir, mode = {}) {
+  const cssEntryFile = findCssEntry(projectDir);
+  if (!cssEntryFile) return null;
+  const input = path5.join(projectDir, cssEntryFile);
+  const output = path5.join(outDir, "styles.css");
+  const cssContent = fs5.readFileSync(input, "utf-8");
+  const usesTailwind = cssContent.includes("tailwindcss") || cssContent.includes("@tailwind");
+  if (!usesTailwind) {
+    fs5.copyFileSync(input, output);
+    return { file: output, tailwind: false };
   }
-  return files;
+  try {
+    const projectRequire = createRequire(path5.join(projectDir, "package.json"));
+    const cliPkgPath = projectRequire.resolve("@tailwindcss/cli/package.json");
+    const cliPkg = JSON.parse(fs5.readFileSync(cliPkgPath, "utf-8"));
+    const binRel = typeof cliPkg.bin === "string" ? cliPkg.bin : cliPkg.bin?.tailwindcss ?? Object.values(cliPkg.bin ?? {})[0];
+    if (!binRel) throw new Error("@tailwindcss/cli has no bin entry");
+    const binPath = path5.join(path5.dirname(cliPkgPath), binRel);
+    await execFileAsync(process.execPath, [binPath, "-i", input, "-o", output, ...mode.dev ? [] : ["--minify"]], { cwd: projectDir });
+  } catch (err) {
+    throw new CssBuildError(err instanceof Error ? err.message : String(err));
+  }
+  return { file: output, tailwind: true };
 }
-var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
-  "js",
-  "css",
-  "html",
-  "map",
-  "png",
-  "jpg",
-  "jpeg",
-  "gif",
-  "svg",
-  "webp",
+var CssBuildError = class extends Error {
+  hint = "Install tailwindcss v4: npm add -D tailwindcss@^4.3 @tailwindcss/cli@^4.3";
+  constructor(message2) {
+    super(message2);
+    this.name = "CssBuildError";
+  }
+};
+
+// src/dev/builder.ts
+var DEV_OUT_DIR = path6.join(".lumio", "dev");
+var DEV_TARGETS = ["editor", "layer"];
+function devTargets(projectDir, config) {
+  const targets = [];
+  const skipped = [];
+  for (const t of config.targets) {
+    if (!DEV_TARGETS.includes(t)) {
+      skipped.push(`target "${t}" is not simulated by lumio dev`);
+    } else if (!targetEntry(projectDir, t)) {
+      skipped.push(`target "${t}": src/${t}.tsx not found`);
+    } else targets.push(t);
+  }
+  return { targets, skipped };
+}
+function formatMessages(messages) {
+  return messages.map((m) => m.location ? `${m.location.file}:${m.location.line}:${m.location.column}: ${m.text}` : m.text);
+}
+var DevBuilder = class {
+  constructor(projectDir, config, targets, handlers) {
+    this.projectDir = projectDir;
+    this.config = config;
+    this.targets = targets;
+    this.handlers = handlers;
+    this.outDir = path6.join(projectDir, DEV_OUT_DIR);
+  }
+  projectDir;
+  config;
+  targets;
+  handlers;
+  contexts = [];
+  serverContext = null;
+  serverEntryKey = "";
+  watchers = [];
+  serverTimer = null;
+  serverBusy = false;
+  lastTarget = /* @__PURE__ */ new Map();
+  lastServer = "";
+  cssRunning = null;
+  stopped = false;
+  outDir;
+  /** Builds everything once and starts watching. Resolves to the first bundles. */
+  async start() {
+    fs6.mkdirSync(this.outDir, { recursive: true });
+    const { context } = await import("esbuild");
+    const bundles = {};
+    let first = true;
+    for (const target of this.targets) {
+      const entry = targetEntry(this.projectDir, target);
+      const outFile = path6.join(this.outDir, `${target}.js`);
+      const ctx = await context({
+        ...targetBuildOptions(entry, this.outDir, target, { dev: true }),
+        absWorkingDir: this.projectDir,
+        logLevel: "silent",
+        plugins: [
+          this.onEnd(`${target}.js`, (ok) => {
+            if (!ok) return;
+            const code = fs6.readFileSync(outFile, "utf8");
+            if (this.lastTarget.get(target) === code) return;
+            this.lastTarget.set(target, code);
+            if (first) bundles[target] = code;
+            else this.handlers.onTarget(target, code);
+            void this.css();
+          })
+        ]
+      });
+      this.contexts.push(ctx);
+      await ctx.rebuild().catch(() => {
+      });
+    }
+    const server = await this.buildServer(true);
+    await this.css();
+    first = false;
+    for (const ctx of this.contexts) await ctx.watch();
+    if (this.serverContext) await this.serverContext.watch();
+    this.watch(path6.join(this.projectDir, "server"), () => this.scheduleServer());
+    return { bundles, server };
+  }
+  onEnd(key, done) {
+    return {
+      name: "lumio-dev",
+      setup: (build) => {
+        build.onEnd(async (result) => {
+          if (this.stopped) return;
+          const ok = result.errors.length === 0;
+          this.handlers.onStatus(key, ok ? null : formatMessages(result.errors).map((m) => `${key}: ${m}`));
+          await done(ok, result);
+        });
+      }
+    };
+  }
+  watch(dir, onChange) {
+    if (!fs6.existsSync(dir)) return;
+    try {
+      this.watchers.push(fs6.watch(dir, { recursive: true }, () => onChange()));
+    } catch {
+    }
+  }
+  scheduleServer() {
+    if (this.stopped) return;
+    if (this.serverTimer) clearTimeout(this.serverTimer);
+    this.serverTimer = setTimeout(() => {
+      this.serverTimer = null;
+      void this.buildServer(false);
+    }, 120);
+  }
+  /** Plans the server build (functions.json + schema), (re)creates its context when the entry changed, and builds. */
+  async buildServer(first) {
+    const empty = { bundle: null, functions: null, schema: null };
+    if (!this.config.server) return empty;
+    this.serverBusy = true;
+    try {
+      const outfile = path6.join(this.outDir, "server.js");
+      let plan;
+      try {
+        plan = await planServerBuild(this.projectDir, this.config, outfile, { dev: true });
+        this.handlers.onStatus("server", null);
+      } catch (e) {
+        this.handlers.onStatus("server", [`server: ${e instanceof Error ? e.message : String(e)}`]);
+        return empty;
+      }
+      const result = { bundle: null, functions: plan.manifest ? JSON.stringify(plan.manifest) : null, schema: plan.schema };
+      if (!plan.options) {
+        await this.serverContext?.dispose();
+        this.serverContext = null;
+      } else {
+        const key = JSON.stringify({ e: plan.options.entryPoints, s: plan.options.stdin });
+        if (!this.serverContext || key !== this.serverEntryKey) {
+          await this.serverContext?.dispose();
+          const { context } = await import("esbuild");
+          this.serverContext = await context({
+            ...plan.options,
+            logLevel: "silent",
+            // A change inside the bundle graph re-plans: functions.ts may be part of it.
+            plugins: [this.onEnd("server.js", () => {
+              if (!this.serverBusy) this.scheduleServer();
+            })]
+          });
+          this.serverEntryKey = key;
+          if (!first) await this.serverContext.watch();
+        }
+        try {
+          await this.serverContext.rebuild();
+        } catch {
+          if (!first) return result;
+        }
+        result.bundle = this.readServer(outfile);
+      }
+      const fingerprint = JSON.stringify(result);
+      if (!first && fingerprint !== this.lastServer) this.handlers.onServer(result);
+      this.lastServer = fingerprint;
+      return result;
+    } finally {
+      this.serverBusy = false;
+    }
+  }
+  readServer(outfile) {
+    return fs6.existsSync(outfile) ? fs6.readFileSync(outfile, "utf8") : null;
+  }
+  /** Tailwind scans the sources, so the stylesheet follows every target build. */
+  css() {
+    if (this.cssRunning) return this.cssRunning;
+    this.cssRunning = (async () => {
+      try {
+        const css = await compileCss(this.projectDir, this.outDir, { dev: true });
+        this.handlers.onStatus("styles.css", null);
+        if (css) this.handlers.onCss();
+      } catch (e) {
+        const hint = e instanceof CssBuildError ? ` (${e.hint})` : "";
+        this.handlers.onStatus("styles.css", [`styles.css: ${e instanceof Error ? e.message : String(e)}${hint}`]);
+      } finally {
+        this.cssRunning = null;
+      }
+    })();
+    return this.cssRunning;
+  }
+  /** The built stylesheet, or `null`. */
+  stylesheet() {
+    const file = path6.join(this.outDir, "styles.css");
+    return fs6.existsSync(file) ? fs6.readFileSync(file, "utf8") : null;
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.serverTimer) clearTimeout(this.serverTimer);
+    for (const w of this.watchers.splice(0)) w.close();
+    for (const ctx of this.contexts.splice(0)) await ctx.dispose();
+    await this.serverContext?.dispose();
+    this.serverContext = null;
+  }
+};
+
+// src/dev/project-modules.ts
+import * as vm from "vm";
+import { createRequire as createRequire2 } from "module";
+import * as path8 from "path";
+
+// src/dev/resolve.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+import { pathToFileURL } from "url";
+function findPackage(fromDir, name) {
+  let dir = path7.resolve(fromDir);
+  for (; ; ) {
+    const candidate = path7.join(dir, "node_modules", name, "package.json");
+    if (fs7.existsSync(candidate)) {
+      const manifest = JSON.parse(fs7.readFileSync(candidate, "utf8"));
+      return {
+        name,
+        version: typeof manifest.version === "string" ? manifest.version : "0.0.0",
+        dir: fs7.realpathSync(path7.dirname(candidate)),
+        manifest
+      };
+    }
+    const parent = path7.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function entryOf(pkg, subpath = ".") {
+  const exportsField = pkg.manifest.exports;
+  let target;
+  if (typeof exportsField === "string") {
+    target = subpath === "." ? exportsField : void 0;
+  } else if (exportsField && typeof exportsField === "object") {
+    const map = exportsField;
+    const isSubpathMap = Object.keys(map).some((k) => k.startsWith("."));
+    const entry = isSubpathMap ? map[subpath] : subpath === "." ? map : void 0;
+    target = pickCondition(entry);
+  }
+  if (target === void 0 && subpath === ".") {
+    target = pkg.manifest.module ?? pkg.manifest.main ?? "index.js";
+  }
+  if (typeof target !== "string") {
+    throw new Error(`${pkg.name} does not export "${subpath}" (installed ${pkg.version} at ${pkg.dir})`);
+  }
+  return path7.join(pkg.dir, target);
+}
+function pickCondition(entry) {
+  if (typeof entry === "string" || entry === void 0 || entry === null) return entry ?? void 0;
+  if (typeof entry !== "object") return void 0;
+  const conditions = entry;
+  for (const key of ["import", "node", "default"]) {
+    if (key in conditions) return pickCondition(conditions[key]);
+  }
+  return void 0;
+}
+async function importFile(file) {
+  return await import(pathToFileURL(file).href);
+}
+function compareVersions(a, b) {
+  const parse = (v) => v.split("-")[0].split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const [x, y] = [parse(a), parse(b)];
+  for (let i = 0; i < 3; i++) {
+    const d = (x[i] ?? 0) - (y[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+
+// src/dev/version.ts
+var CLI_PROTOCOL_VERSION = "0.9.0";
+
+// src/dev/project-modules.ts
+var MissingPackageError = class extends Error {
+  constructor(packageName) {
+    super(`${packageName} is not installed in this project. Run: npm install --save-dev ${packageName}`);
+    this.packageName = packageName;
+    this.name = "MissingPackageError";
+  }
+  packageName;
+};
+function need(fromDir, name) {
+  const pkg = findPackage(fromDir, name);
+  if (!pkg) throw new MissingPackageError(name);
+  return pkg;
+}
+async function loadProjectModules(projectDir) {
+  const devkitPkg = need(projectDir, "@zaflun/lumio-devkit");
+  const sdkPkg = findPackage(devkitPkg.dir, "@zaflun/lumio-sdk") ?? need(projectDir, "@zaflun/lumio-sdk");
+  const protocolPkg = findPackage(sdkPkg.dir, "@zaflun/lumio-protocol") ?? need(projectDir, "@zaflun/lumio-protocol");
+  const devkit = await importFile(entryOf(devkitPkg));
+  const devkitNode = await importFile(entryOf(devkitPkg, "./node"));
+  const sdk = await importFile(entryOf(sdkPkg));
+  const sdkServer = await importFile(entryOf(sdkPkg, "./server"));
+  const protocol = await importFile(entryOf(protocolPkg));
+  const sdkRequire = createRequire2(path8.join(sdkPkg.dir, "package.json"));
+  const react = sdkRequire("react");
+  const jsxRuntime = sdkRequire("react/jsx-runtime");
+  const warnings = [];
+  if (compareVersions(protocolPkg.version, CLI_PROTOCOL_VERSION) < 0) {
+    warnings.push(
+      `@zaflun/lumio-sdk ${sdkPkg.version} of this project speaks protocol ${protocolPkg.version}, older than ${CLI_PROTOCOL_VERSION} of this CLI. Update: npm install @zaflun/lumio-sdk@latest && npm install --save-dev @zaflun/lumio-devkit@latest`
+    );
+  }
+  const devkitProtocol = findPackage(devkitPkg.dir, "@zaflun/lumio-protocol");
+  if (devkitProtocol && compareVersions(devkitProtocol.version, CLI_PROTOCOL_VERSION) < 0) {
+    warnings.push(
+      `@zaflun/lumio-devkit ${devkitPkg.version} mocks protocol ${devkitProtocol.version}, older than ${CLI_PROTOCOL_VERSION} of this CLI: events and actions added since are missing. Update: npm install --save-dev @zaflun/lumio-devkit@latest`
+    );
+  }
+  return {
+    devkit,
+    devkitNode,
+    react,
+    registry: {
+      react,
+      "react/jsx-runtime": jsxRuntime,
+      "@zaflun/lumio-sdk": sdk,
+      "@zaflun/lumio-sdk/server": sdkServer,
+      "@zaflun/lumio-protocol": protocol
+    },
+    versions: { devkit: devkitPkg.version, sdk: sdkPkg.version, protocol: protocolPkg.version },
+    warnings
+  };
+}
+var BundleError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "BundleError";
+  }
+};
+function evaluateTargetBundle(code, file, modules) {
+  const react = modules.react;
+  let rendered = null;
+  const lumio = {
+    render(input) {
+      if (rendered) throw new Error("Lumio.render() can only be called once");
+      rendered = typeof input === "function" ? react.createElement(input) : input;
+    }
+  };
+  const registry = {
+    ...modules.registry,
+    "@zaflun/lumio-sdk": { ...modules.registry["@zaflun/lumio-sdk"], Lumio: lumio }
+  };
+  const lumioRequire = (id) => {
+    if (!(id in registry)) throw new Error(`[Lumio Runtime] Module "${id}" is not available in the extension sandbox`);
+    return registry[id];
+  };
+  try {
+    const fn = vm.runInThisContext(`(function (require, self) {
+${code}
+})`, { filename: file });
+    fn(lumioRequire, globalThis);
+  } catch (e) {
+    throw new BundleError(`${path8.basename(file)} failed to evaluate: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (!rendered) {
+    throw new BundleError(`${path8.basename(file)} rendered nothing: export a default component or call Lumio.render(<App />)`);
+  }
+  return rendered;
+}
+
+// src/dev/repl.ts
+import * as readline2 from "readline";
+import chalk2 from "chalk";
+
+// src/dev/errors.ts
+var CommandSyntaxError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "CommandSyntaxError";
+  }
+};
+
+// src/dev/load.ts
+var MAX_COUNT = 1e4;
+var MAX_RATE_PER_SECOND = 1e3;
+function parseCount(raw) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || n > MAX_COUNT) throw new CommandSyntaxError(`--count must be an integer between 1 and ${MAX_COUNT}, got "${raw}"`);
+  return n;
+}
+function parseRate(raw) {
+  const m = /^(\d+(?:\.\d+)?)(?:\/(s|sec|m|min|h))?$/.exec(raw.trim());
+  if (!m) throw new CommandSyntaxError(`--rate is a count per time, e.g. 5/s, 120/m or 600/h, got "${raw}"`);
+  const per = { s: 1, sec: 1, m: 60, min: 60, h: 3600 }[m[2] ?? "s"];
+  const perSecond = Number(m[1]) / per;
+  if (!(perSecond > 0) || perSecond > MAX_RATE_PER_SECOND) {
+    throw new CommandSyntaxError(`--rate must be above 0 and at most ${MAX_RATE_PER_SECOND}/s, got "${raw}"`);
+  }
+  return 1e3 / perSecond;
+}
+function describeRate(intervalMs) {
+  if (intervalMs <= 0) return "back to back";
+  const perSecond = 1e3 / intervalMs;
+  return perSecond >= 1 ? `${round(perSecond)}/s` : `${round(perSecond * 60)}/m`;
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+function seededPicker(seed) {
+  let state = seed >>> 0;
+  return (items) => {
+    if (items.length === 0) throw new CommandSyntaxError("Nothing to pick from");
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    const r = ((t ^ t >>> 14) >>> 0) / 4294967296;
+    return items[Math.floor(r * items.length)];
+  };
+}
+function freshSeed() {
+  return Math.floor(Math.random() * 2 ** 31);
+}
+function randomEventPool(eventTypes, platform) {
+  const pool = eventTypes.filter((e) => e.forwarded && (platform === void 0 || e.type.startsWith(`${platform}:`))).map((e) => e.type);
+  if (pool.length === 0) {
+    throw new CommandSyntaxError(platform ? `No ${platform}:* event type is forwarded to extensions` : "No event type is forwarded to extensions");
+  }
+  return pool;
+}
+function repeatSpec(cmd, defaultSeed) {
+  const spec = { count: cmd.count ?? 1, intervalMs: cmd.intervalMs ?? 0, random: cmd.random === true, seed: cmd.seed ?? defaultSeed };
+  if (!Number.isInteger(spec.count) || spec.count < 1 || spec.count > MAX_COUNT) throw new CommandSyntaxError(`count must be an integer between 1 and ${MAX_COUNT}`);
+  if (typeof spec.intervalMs !== "number" || !(spec.intervalMs >= 0)) throw new CommandSyntaxError("intervalMs must be 0 or more");
+  const inner = cmd.command;
+  if (typeof inner !== "object" || inner === null || inner.kind !== "event" && inner.kind !== "scenario" && inner.kind !== "chat") {
+    throw new CommandSyntaxError("repeat runs an event, scenario or chat command");
+  }
+  return spec;
+}
+function repeatVariants(cmd, spec, pools) {
+  const inner = cmd.command;
+  if (!spec.random) return () => inner;
+  const pick = seededPicker(spec.seed);
+  if (inner.kind === "scenario") {
+    if (pools.scenarios.length === 0) throw new CommandSyntaxError("This devkit has no scenarios");
+    return () => ({ ...inner, name: pick(pools.scenarios) });
+  }
+  if (inner.kind !== "event") throw new CommandSyntaxError("--random picks an event type or a scenario");
+  const pool = randomEventPool(pools.eventTypes, cmd.platform);
+  return () => ({ ...inner, type: pick(pool) });
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve13) => {
+    if (signal?.aborted) return resolve13();
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve13();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+async function runLoad(spec, run, hooks = {}) {
+  const now = hooks.now ?? Date.now;
+  const sleep = hooks.sleep ?? defaultSleep;
+  const results = [];
+  const start = now();
+  for (let i = 0; i < spec.count; i++) {
+    if (hooks.signal?.aborted) return { results, failed: null, stopped: true };
+    if (i > 0 && spec.intervalMs > 0) {
+      const wait = start + i * spec.intervalMs - now();
+      if (wait > 0) await sleep(wait, hooks.signal);
+      if (hooks.signal?.aborted) return { results, failed: null, stopped: true };
+    }
+    const r = await run(i);
+    results.push(r);
+    if (!r.ok) return { results, failed: r, stopped: false };
+  }
+  return { results, failed: null, stopped: false };
+}
+function summarizeLoad(spec, result) {
+  const ok = result.results.filter((r) => r.ok).length;
+  const pace = spec.count > 1 ? ` (${describeRate(spec.intervalMs)})` : "";
+  const random = spec.random ? ` \xB7 random picks, seed ${spec.seed}` : "";
+  if (result.failed) return `failed at ${result.results.length}/${spec.count}, ${ok} sent${pace}${random}`;
+  if (result.stopped) return `stopped after ${ok}/${spec.count}${pace}${random}`;
+  return `sent ${ok}/${spec.count}${pace}${random}`;
+}
+
+// src/dev/commands.ts
+var REPL_HELP = [
+  "Commands (plain text without a / is a chat message):",
+  "  /event <type> [field=value \u2026] [--json '{\u2026}'] [--user name]   send an event (fields are dotted paths)",
+  "  /event @<preset>                                               send a preset from lumio/mocks/events/",
+  "  /chat [@role:name] <text> [--platform kick]                   a chat message (commands, keywords, moderation)",
+  '  /reward "<title>" [--user name] [--input "text"] [--platform kick]   redeem a channel-point reward',
+  "  /reward-status <redemption-id> <status>                        fulfilled|canceled (Twitch), accepted|rejected (Kick)",
+  "  /music play|pause|skip [n]|seek 1:30|volume 50|shuffle on|repeat track|queue <uri>|device <name>|advance 30s",
+  "  /timer <name>        fire a declared timer          /defer run   run queued ctx.defer jobs",
+  "  /scenario <name> [key=value \u2026]                                 e.g. /scenario raid viewers=500",
+  "  load flags on /event, /scenario and chat: --count N  --rate 5/s  --random [--platform kick]  --seed n",
+  "    e.g. /event twitch:follower --count 50 --rate 5/s \xB7 /event --random --count 20 \xB7 /scenario --random",
+  "  /storage [key] [json]   show or set storage       /db [table] [--reset]   show ctx.db rows",
+  "  /config [key=value \u2026]   show or change settings   /theme light|dark",
+  "  /view editor|layer      switch the sandbox view   /stop   stop running loads   /status   /help   /quit"
+];
+function tokenize(line) {
+  const out = [];
+  let current = "";
+  let quote = null;
+  let inToken = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (quote) {
+      if (c === quote) quote = null;
+      else if (c === "\\" && quote === '"' && i + 1 < line.length) current += line[++i];
+      else current += c;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      inToken = true;
+    } else if (c === "\\" && i + 1 < line.length) {
+      current += line[++i];
+      inToken = true;
+    } else if (/\s/.test(c)) {
+      if (inToken) out.push(current);
+      current = "";
+      inToken = false;
+    } else {
+      current += c;
+      inToken = true;
+    }
+  }
+  if (quote) throw new CommandSyntaxError(`Unclosed ${quote} quote`);
+  if (inToken) out.push(current);
+  return out;
+}
+var LOAD_FLAGS = ["count", "rate", "seed"];
+function splitFlags(tokens, flags, booleans = []) {
+  const words = [];
+  const found = {};
+  const bools = /* @__PURE__ */ new Set();
+  const all = [...flags, ...booleans];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.startsWith("--")) {
+      const name = t.slice(2);
+      if (!all.includes(name)) throw new CommandSyntaxError(`Unknown option ${t} (options: ${all.map((f) => `--${f}`).join(", ") || "none"})`);
+      if (booleans.includes(name)) {
+        bools.add(name);
+        continue;
+      }
+      if (i + 1 >= tokens.length) throw new CommandSyntaxError(`${t} needs a value`);
+      found[name] = tokens[++i];
+    } else words.push(t);
+  }
+  return { words, flags: found, bools };
+}
+function loadFlags(flags, bools) {
+  return { count: flags.count, rate: flags.rate, seed: flags.seed, random: bools.has("random") };
+}
+function withLoad(inner, load) {
+  const random = load.random === true;
+  if (load.platform !== void 0 && !random) throw new CommandSyntaxError("--platform filters --random; the event type already names its platform");
+  if (load.count === void 0 && load.rate === void 0 && load.seed === void 0 && !random) return inner;
+  if (load.rate !== void 0 && load.count === void 0) throw new CommandSyntaxError("--rate paces --count runs: add --count N");
+  if (load.seed !== void 0 && !random) throw new CommandSyntaxError("--seed sets the --random picks; event fields follow the session seed (lumio dev --seed)");
+  if (inner.kind !== "event" && inner.kind !== "scenario" && inner.kind !== "chat") {
+    throw new CommandSyntaxError("--count, --rate and --random apply to events, scenarios and chat messages");
+  }
+  if (random) {
+    if (inner.kind === "chat") throw new CommandSyntaxError("--random picks an event type or a scenario, not a chat message");
+    if (inner.kind === "event" && (inner.type !== void 0 || inner.preset !== void 0 || Object.keys(inner.data ?? {}).length > 0)) {
+      throw new CommandSyntaxError("--random picks the event type itself: drop the type, preset and fields (every event gets fresh random fields anyway)");
+    }
+    if (inner.kind === "scenario" && (inner.name !== "" || Object.keys(inner.options ?? {}).length > 0)) {
+      throw new CommandSyntaxError("--random picks the scenario itself: drop the name and options");
+    }
+  }
+  if (random && load.platform !== void 0 && inner.kind !== "event") throw new CommandSyntaxError("--platform filters random event types only");
+  let seed;
+  if (load.seed !== void 0) {
+    seed = Number(load.seed);
+    if (!Number.isInteger(seed) || seed < 0 || seed > 2 ** 31 - 1) throw new CommandSyntaxError(`--seed must be an integer between 0 and ${2 ** 31 - 1}`);
+  }
+  return {
+    kind: "repeat",
+    command: inner,
+    count: load.count === void 0 ? 1 : parseCount(load.count),
+    intervalMs: load.rate === void 0 ? 0 : parseRate(load.rate),
+    ...random ? { random: true } : {},
+    ...load.platform !== void 0 ? { platform: load.platform } : {},
+    ...seed !== void 0 ? { seed } : {}
+  };
+}
+function parseValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw);
+  if (/^[[{]/.test(raw)) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new CommandSyntaxError(`Not valid JSON: ${raw}`);
+    }
+  }
+  return raw;
+}
+function setPath(target, dotted, value) {
+  const parts = dotted.split(".");
+  if (parts.some((p) => p === "" || p === "__proto__" || p === "constructor" || p === "prototype")) {
+    throw new CommandSyntaxError(`Invalid field path "${dotted}"`);
+  }
+  let node = target;
+  for (const part of parts.slice(0, -1)) {
+    const next = node[part];
+    if (typeof next !== "object" || next === null || Array.isArray(next)) node[part] = {};
+    node = node[part];
+  }
+  node[parts[parts.length - 1]] = value;
+}
+function assignments(words, what) {
+  const out = {};
+  for (const w of words) {
+    const eq = w.indexOf("=");
+    if (eq <= 0) throw new CommandSyntaxError(`Expected ${what} as key=value, got "${w}"`);
+    setPath(out, w.slice(0, eq), parseValue(w.slice(eq + 1)));
+  }
+  return out;
+}
+var ROLE_ALIASES = {
+  mod: "moderator",
+  moderator: "moderator",
+  sub: "subscriber",
+  subscriber: "subscriber",
+  vip: "vip",
+  broadcaster: "broadcaster",
+  everyone: "everyone",
+  viewer: "everyone",
+  follower: "follower"
+};
+function parseUserPrefix(word) {
+  const body = word.slice(1);
+  const colon = body.indexOf(":");
+  if (colon === -1) return { name: body };
+  const role = ROLE_ALIASES[body.slice(0, colon).toLowerCase()];
+  if (!role) throw new CommandSyntaxError(`Unknown role "${body.slice(0, colon)}" (use ${Object.keys(ROLE_ALIASES).join(", ")})`);
+  return { role, name: body.slice(colon + 1) };
+}
+function userFlag(value) {
+  if (value === void 0) return void 0;
+  return value.startsWith("@") ? parseUserPrefix(value) : { name: value };
+}
+function parseReplLine(line) {
+  const trimmed = line.trim();
+  if (trimmed === "") throw new CommandSyntaxError("Empty input");
+  if (!trimmed.startsWith("/")) return parseChat(tokenize(trimmed));
+  const [head, ...rest] = tokenize(trimmed);
+  switch (head) {
+    case "/quit":
+    case "/exit":
+      return null;
+    case "/help":
+      return { kind: "help" };
+    case "/status":
+      return { kind: "status" };
+    case "/stop":
+      return { kind: "stop" };
+    case "/event": {
+      const { words, flags, bools } = splitFlags(rest, ["json", "user", "platform", ...LOAD_FLAGS], ["random"]);
+      const load = { ...loadFlags(flags, bools), platform: flags.platform };
+      const [type, ...fields] = words;
+      if (!type && load.random) {
+        if (flags.json !== void 0) throw new CommandSyntaxError("--random picks the event type itself: drop --json");
+        return withLoad({ kind: "event", user: userFlag(flags.user) }, load);
+      }
+      if (!type) throw new CommandSyntaxError("Usage: /event <type> [field=value \u2026] | /event @<preset> | /event --random");
+      if (type.startsWith("@")) {
+        if (fields.length || flags.json) throw new CommandSyntaxError("A preset takes no fields");
+        return withLoad({ kind: "event", preset: type.slice(1), user: userFlag(flags.user) }, load);
+      }
+      const data = assignments(fields, "event fields");
+      if (flags.json !== void 0) {
+        const json = parseValue(flags.json);
+        if (typeof json !== "object" || json === null || Array.isArray(json)) throw new CommandSyntaxError("--json needs a JSON object");
+        Object.assign(data, json);
+      }
+      return withLoad({ kind: "event", type, data, user: userFlag(flags.user) }, load);
+    }
+    case "/chat":
+      return parseChat(rest);
+    case "/reward": {
+      const { words, flags } = splitFlags(rest, ["user", "input", "platform"]);
+      if (words.length !== 1) throw new CommandSyntaxError('Usage: /reward "<title or id>" [--user name] [--input "text"] [--platform twitch|kick]');
+      return { kind: "reward", reward: words[0], user: userFlag(flags.user), input: flags.input, platform: flags.platform };
+    }
+    case "/reward-status": {
+      if (rest.length !== 2) throw new CommandSyntaxError("Usage: /reward-status <redemption-id> <status>");
+      return { kind: "reward-status", id: rest[0], status: rest[1] };
+    }
+    case "/music": {
+      const [op, ...args] = rest;
+      if (!op) throw new CommandSyntaxError("Usage: /music play|pause|skip|seek|volume|shuffle|repeat|queue|device|advance \u2026");
+      return { kind: "music", op, args };
+    }
+    case "/timer":
+      if (rest.length !== 1) throw new CommandSyntaxError("Usage: /timer <name>");
+      return { kind: "timer", name: rest[0] };
+    case "/defer":
+      if (rest[0] !== "run" || rest.length !== 1) throw new CommandSyntaxError("Usage: /defer run");
+      return { kind: "defer-run" };
+    case "/scenario": {
+      const { words, flags, bools } = splitFlags(rest, [...LOAD_FLAGS], ["random"]);
+      const load = loadFlags(flags, bools);
+      const [name, ...opts] = words;
+      if (!name && !load.random) throw new CommandSyntaxError("Usage: /scenario <name> [key=value \u2026] | /scenario --random");
+      return withLoad({ kind: "scenario", name: name ?? "", options: assignments(opts, "scenario options") }, load);
+    }
+    case "/storage": {
+      if (rest.length === 0) return { kind: "storage" };
+      if (rest.length > 2) throw new CommandSyntaxError("Usage: /storage [key] ['<json>']");
+      if (rest.length === 1) return { kind: "storage", key: rest[0] };
+      let value;
+      try {
+        value = JSON.parse(rest[1]);
+      } catch {
+        throw new CommandSyntaxError(`Storage values are JSON: ${rest[1]}`);
+      }
+      return { kind: "storage", key: rest[0], value };
+    }
+    case "/db": {
+      const reset = rest.includes("--reset");
+      const words = rest.filter((w) => w !== "--reset");
+      if (words.length > 1) throw new CommandSyntaxError("Usage: /db [table] [--reset]");
+      return { kind: "db", table: words[0], reset };
+    }
+    case "/config":
+      return rest.length ? { kind: "config", settings: assignments(rest, "settings") } : { kind: "config" };
+    case "/theme":
+      if (rest[0] !== "light" && rest[0] !== "dark") throw new CommandSyntaxError("Usage: /theme light|dark");
+      return { kind: "theme", mode: rest[0] };
+    case "/view":
+      if (rest[0] !== "editor" && rest[0] !== "layer") throw new CommandSyntaxError("Usage: /view editor|layer");
+      return { kind: "view", target: rest[0] };
+    default:
+      throw new CommandSyntaxError(`Unknown command ${head}. Type /help.`);
+  }
+}
+function parseChat(tokens) {
+  const { words, flags } = splitFlags(tokens, ["platform", "user", "count", "rate"]);
+  let user = userFlag(flags.user);
+  if (words[0]?.startsWith("@") && words.length > 1) {
+    user = parseUserPrefix(words[0]);
+    words.shift();
+  }
+  const text = words.join(" ");
+  if (text === "") throw new CommandSyntaxError("Usage: /chat [@role:name] <text>");
+  return withLoad({ kind: "chat", text, user, platform: flags.platform }, { count: flags.count, rate: flags.rate });
+}
+var KINDS = /* @__PURE__ */ new Set([
+  "event",
+  "chat",
+  "reward",
+  "reward-status",
+  "music",
+  "timer",
+  "defer-run",
+  "scenario",
+  "storage",
+  "db",
+  "config",
+  "theme",
+  "view",
+  "callback",
+  "server-override",
+  "repeat",
+  "stop",
+  "status",
+  "help"
+]);
+function commandFromJson(body) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    throw new CommandSyntaxError('Send { "line": "/event twitch:follower" } or a command object { "kind": \u2026 }');
+  }
+  const b = body;
+  if (typeof b.line === "string") return parseReplLine(b.line);
+  if (typeof b.kind !== "string" || !KINDS.has(b.kind)) {
+    throw new CommandSyntaxError(`Unknown command kind ${JSON.stringify(b.kind)} (one of: ${[...KINDS].join(", ")})`);
+  }
+  return b;
+}
+function parseDuration(raw) {
+  const m = /^(?:(\d+):)?(\d+(?:\.\d+)?)(s|ms)?$/.exec(raw);
+  if (!m) throw new CommandSyntaxError(`Not a time: ${raw} (use 1:30, 90 or 90s)`);
+  if (m[3] === "ms") return Number(m[2]) + Number(m[1] ?? 0) * 6e4;
+  return Math.round((Number(m[1] ?? 0) * 60 + Number(m[2])) * 1e3);
+}
+
+// src/dev/repl.ts
+var PRINT_OUTPUT = /* @__PURE__ */ new Set([
+  "help",
+  "status",
+  "storage",
+  "db",
+  "config",
+  "music",
+  "scenario",
+  "timer",
+  "defer-run",
+  "view",
+  "reward",
+  "reward-status",
+  "server-override",
+  "theme",
+  "stop"
+]);
+var KIND_STYLE = {
+  input: chalk2.dim,
+  event: chalk2.cyan,
+  chat: chalk2.white,
+  bot: chalk2.green,
+  action: chalk2.magenta,
+  server: chalk2.blue,
+  storage: chalk2.blue,
+  handler: chalk2.green,
+  error: chalk2.red,
+  warning: chalk2.yellow,
+  build: chalk2.dim,
+  info: chalk2.dim
+};
+function formatLogEntry(entry) {
+  const style = KIND_STYLE[entry.kind];
+  const text = entry.kind === "event" ? `\u2190 ${entry.text}` : entry.text;
+  const payload = entry.payload === void 0 ? "" : ` ${chalk2.dim(JSON.stringify(entry.payload))}`;
+  return `${style(text)}${payload}`;
+}
+function startRepl(session, onQuit) {
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout, prompt: chalk2.cyan("lumio> ") });
+  let closed = false;
+  const above = (text) => {
+    if (closed) {
+      console.log(text);
+      return;
+    }
+    readline2.clearLine(process.stdout, 0);
+    readline2.cursorTo(process.stdout, 0);
+    console.log(text);
+    rl.prompt(true);
+  };
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      rl.prompt();
+      return;
+    }
+    let cmd;
+    try {
+      cmd = parseReplLine(trimmed);
+    } catch (e) {
+      above(chalk2.red(e instanceof CommandSyntaxError ? e.message : String(e)));
+      return;
+    }
+    if (cmd === null) {
+      rl.close();
+      return;
+    }
+    const kind = cmd.kind;
+    void session.run(cmd, "repl").then((result) => {
+      if (result.ok && PRINT_OUTPUT.has(kind)) for (const l of result.output) above(l);
+      else rl.prompt(true);
+    });
+  });
+  rl.on("close", () => {
+    closed = true;
+    onQuit();
+  });
+  rl.prompt();
+  return {
+    print(entry) {
+      if (entry.kind === "input" && entry.text.startsWith("repl: ")) return;
+      above(formatLogEntry(entry));
+    },
+    close() {
+      if (!closed) rl.close();
+    }
+  };
+}
+
+// src/dev/session.ts
+var LOG_LIMIT = 500;
+var CALL_LIMIT = 100;
+var DEFAULT_USER = "dev_user";
+var ACCOUNT_ROLES = ["owner", "administrator", "moderator"];
+var THEMES = {
+  dark: {
+    colors: {
+      primary: "#6366f1",
+      secondary: "#8b5cf6",
+      accent: "#06b6d4",
+      background: "transparent",
+      surface: "rgba(15, 23, 42, 0.8)",
+      text: "#f8fafc",
+      muted: "#94a3b8",
+      border: "rgba(148, 163, 184, 0.2)"
+    }
+  },
+  light: {
+    colors: {
+      primary: "#4f46e5",
+      secondary: "#7c3aed",
+      accent: "#0891b2",
+      background: "transparent",
+      surface: "rgba(255, 255, 255, 0.9)",
+      text: "#0f172a",
+      muted: "#475569",
+      border: "rgba(15, 23, 42, 0.15)"
+    }
+  }
+};
+var MUSIC_OPS = ["play", "pause", "skip", "seek", "volume", "shuffle", "repeat", "queue", "device", "advance"];
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function compact(value) {
+  try {
+    return JSON.stringify(value) ?? "undefined";
+  } catch {
+    return String(value);
+  }
+}
+function message(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+var DevSession = class {
+  host;
+  runtime = null;
+  opts;
+  rawConfig;
+  bundles = /* @__PURE__ */ new Map();
+  server = { bundle: null, functions: null, schema: null };
+  overrides = /* @__PURE__ */ new Map();
+  viewTarget;
+  themeMode = "dark";
+  mountError = null;
+  buildStatus = { ok: true, errors: [], at: null };
+  cssVersion = 0;
+  logEntries = [];
+  nextLogId = 1;
+  serverCalls = [];
+  seen = { events: 0, bot: 0, calls: 0, errors: 0, warnings: 0, invocations: 0, runtimeWarnings: 0 };
+  lastTree = null;
+  pumpTimer = null;
+  queue = Promise.resolve();
+  closed = false;
+  /** Running `--count` / `--rate` loads; `/stop` and `close()` abort them. */
+  loads = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.opts = options;
+    this.rawConfig = options.rawConfig;
+    this.viewTarget = options.view && options.targets.includes(options.view) ? options.view : options.targets[0] ?? null;
+  }
+  // ── Lifecycle ───────────────────────────────────────────────────────
+  /** Creates the host (and runtime) from the current bundles and mounts the view. */
+  async start(server, bundles) {
+    this.server = server;
+    for (const [t, code] of Object.entries(bundles)) if (code !== void 0) this.bundles.set(t, code);
+    this.createHost({});
+    await this.mountView();
+    this.pump();
+    this.pumpTimer = setInterval(() => this.pump(), 200);
+    this.pumpTimer.unref?.();
+  }
+  createHost(carry) {
+    const { devkit, devkitNode } = this.opts.modules;
+    const hasServer = this.server.bundle !== null || this.server.functions !== null;
+    this.runtime = hasServer ? devkitNode.createBotRuntime({
+      bundle: this.server.bundle ?? void 0,
+      functions: this.server.functions ?? void 0,
+      schema: this.server.schema ?? void 0,
+      cooldowns: this.opts.cooldowns ?? true
+    }) : null;
+    const role = this.opts.role;
+    const mocks = this.opts.mocks;
+    this.host = devkit.createMockHost({
+      seed: this.opts.seed ?? 1,
+      context: {
+        target: this.viewTarget ?? "editor",
+        platform: this.opts.platform ?? "twitch",
+        ...role && ACCOUNT_ROLES.includes(role) ? { role } : {}
+      },
+      config: this.rawConfig,
+      mocks,
+      services: this.opts.services,
+      storage: carry.storage,
+      theme: THEMES[this.themeMode],
+      runtime: this.runtime ?? void 0
+    });
+    for (const [fn, answer] of this.overrides) this.host.mockServer(fn, answer);
+    this.host.viewers.resolve({ name: DEFAULT_USER, role: this.defaultRole() });
+    this.seen = { events: 0, bot: 0, calls: 0, errors: 0, warnings: 0, invocations: 0, runtimeWarnings: 0 };
+    this.lastTree = null;
+  }
+  defaultRole() {
+    const role = this.opts.role;
+    if (role && this.opts.modules.devkit.VIEWER_ROLES.includes(role)) return role;
+    return role === "owner" || role === "administrator" ? "broadcaster" : role === void 0 ? "everyone" : role;
+  }
+  async mountView() {
+    this.mountError = null;
+    if (this.host.mounted) await this.host.unmount();
+    const target = this.viewTarget;
+    if (!target) return;
+    this.host.setTarget(target);
+    const code = this.bundles.get(target);
+    if (code === void 0) {
+      this.mountError = `src/${target}.tsx is not built yet`;
+      return;
+    }
+    try {
+      const element = evaluateTargetBundle(code, `${target}.js`, this.opts.modules);
+      await this.host.mount(element);
+    } catch (e) {
+      this.mountError = message(e);
+      this.addLog("error", `${target}: ${this.mountError}`);
+      if (this.host.mounted) await this.host.unmount().catch(() => {
+      });
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.stopLoads();
+    if (this.pumpTimer) clearInterval(this.pumpTimer);
+    this.host.destroy();
+    await this.runtime?.close();
+  }
+  /** Commands run one after another, like typed input. */
+  serial(fn) {
+    const next = this.queue.then(fn, fn);
+    this.queue = next.catch(() => {
+    });
+    return next;
+  }
+  // ── Rebuilds (SSE → re-init the surface / reload the handler bundle) ──
+  /** A rebuilt target bundle: the surface re-initialises; storage, ctx.db and the player stay. */
+  updateTarget(target, code) {
+    return this.serial(async () => {
+      this.bundles.set(target, code);
+      if (target === this.viewTarget) {
+        await this.mountView();
+        this.addLog("build", `${target}.js rebuilt: surface re-initialised (storage, ctx.db and player kept)`);
+      } else this.addLog("build", `${target}.js rebuilt`);
+      this.pump();
+    });
+  }
+  /** A rebuilt `server.js` / `functions.json` / schema. */
+  updateServer(next) {
+    return this.serial(async () => {
+      const hadServer = this.runtime !== null;
+      const hasServer = next.bundle !== null || next.functions !== null;
+      if (!hadServer || !hasServer) {
+        this.server = next;
+        await this.restartHost("server code changed");
+        return;
+      }
+      try {
+        const { dbReset } = this.runtime.reload({
+          bundle: next.bundle ?? void 0,
+          functions: next.functions ?? void 0,
+          schema: next.schema ?? void 0
+        });
+        this.server = next;
+        this.addLog("build", dbReset ? "server.js reloaded; server/schema.ts changed, so ctx.db starts empty" : "server.js reloaded (ctx.db, cache and cooldowns kept)");
+      } catch (e) {
+        this.addLog("error", `server reload refused, previous version keeps running: ${message(e)}`);
+      }
+      this.pump();
+    });
+  }
+  /** `lumio.config.json` changed: permissions and triggers are read once, so the host restarts. */
+  updateConfig(rawConfig, mocks) {
+    return this.serial(async () => {
+      this.rawConfig = rawConfig;
+      if (mocks !== void 0) this.opts.mocks = mocks;
+      await this.restartHost("lumio.config.json or lumio/mocks/ changed");
+    });
+  }
+  async restartHost(reason) {
+    const storage = this.host.storage.entries();
+    this.host.destroy();
+    await this.runtime?.close();
+    this.createHost({ storage });
+    await this.mountView();
+    this.addLog("build", `${reason}: session restarted (storage kept; ctx.db, player and rewards start fresh)`);
+    this.pump();
+  }
+  /** The current build errors of every part; new ones are logged once. */
+  setBuild(status) {
+    const known = new Set(this.buildStatus.errors);
+    this.buildStatus = { ...status, at: (/* @__PURE__ */ new Date()).toISOString() };
+    for (const e of status.errors) if (!known.has(e)) this.addLog("error", e);
+    this.opts.onChange?.();
+  }
+  /** The extension's stylesheet changed. */
+  cssChanged() {
+    this.cssVersion += 1;
+    this.opts.onChange?.();
+  }
+  setTargets(targets) {
+    this.opts.targets = targets;
+  }
+  // ── Log ─────────────────────────────────────────────────────────────
+  addLog(kind, text, payload) {
+    const entry = { id: this.nextLogId++, at: (/* @__PURE__ */ new Date()).toISOString(), kind, text, ...payload === void 0 ? {} : { payload } };
+    this.logEntries.push(entry);
+    if (this.logEntries.length > LOG_LIMIT) this.logEntries.splice(0, this.logEntries.length - LOG_LIMIT);
+    this.opts.onLog?.(entry);
+    this.opts.onChange?.();
+    return entry;
+  }
+  /** Picks up everything the host and the runtime recorded since the last call. */
+  pump() {
+    if (this.closed || this.host.destroyed) return;
+    const h = this.host;
+    const events = h.events;
+    for (; this.seen.events < events.length; this.seen.events++) {
+      const e = events[this.seen.events];
+      this.addLog("event", `${e.type} \u2192 ${e.delivered ? "extension" : "no surface mounted"}`, e.data);
+    }
+    const bot = h.botMessages;
+    for (; this.seen.bot < bot.length; this.seen.bot++) {
+      this.addLog("bot", `bot (${bot[this.seen.bot].platform}): ${bot[this.seen.bot].message}`);
+    }
+    const calls = h.calls;
+    for (; this.seen.calls < calls.length; this.seen.calls++) {
+      const call = calls[this.seen.calls];
+      if (call.kind === "request" && !("result" in call) && !call.error) break;
+      this.logCall(call);
+    }
+    for (; this.seen.errors < h.errors.length; this.seen.errors++) {
+      const e = h.errors[this.seen.errors];
+      this.addLog("error", `${e.code}: ${e.message}`);
+    }
+    for (; this.seen.warnings < h.warnings.length; this.seen.warnings++) this.addLog("warning", h.warnings[this.seen.warnings]);
+    const rt = this.runtime;
+    if (rt) {
+      const inv = rt.invocations;
+      for (; this.seen.invocations < inv.length; this.seen.invocations++) {
+        const log = inv[this.seen.invocations];
+        if (log.ms === 0 && !log.error && log.value === void 0) break;
+        this.logInvocation(log);
+      }
+    }
+    if (h.tree !== this.lastTree) {
+      this.lastTree = h.tree;
+      this.opts.onChange?.();
+    }
+  }
+  logCall(call) {
+    const p = isObject(call.params) ? call.params : {};
+    const answer = call.error ? { error: call.error } : { result: call.result };
+    switch (call.method) {
+      case "action.execute":
+        this.addLog("action", `action ${String(p.action)}: ${call.error ? `${call.error.message} (${call.error.code})` : "ok"}`, { params: p.params, ...answer });
+        break;
+      case "server.query":
+      case "server.mutation": {
+        const fn = String(p.fn);
+        const entry = {
+          id: this.seen.calls,
+          method: call.method,
+          fn,
+          params: p.params ?? {},
+          ...call.error ? { error: call.error } : { result: call.result },
+          overridden: this.overrides.has(fn)
+        };
+        this.serverCalls.push(entry);
+        if (this.serverCalls.length > CALL_LIMIT) this.serverCalls.shift();
+        this.addLog("server", `${call.method} ${fn}${entry.overridden ? " (override)" : ""}: ${call.error ? call.error.message : compact(call.result)}`, { params: entry.params, ...answer });
+        break;
+      }
+      case "storage.set":
+        this.addLog("storage", `storage.set ${String(p.key)}`, p.value);
+        break;
+      case "ui.action":
+        this.addLog("action", "ui.action", call.params);
+        break;
+      case "sound.play":
+      case "sound.stop":
+      case "sound.list":
+        this.addLog("action", `${call.method}: ${call.error?.message ?? "ok"}`, call.params);
+        break;
+      default:
+        break;
+    }
+  }
+  logInvocation(log) {
+    if (log.trigger === "command" || log.trigger === "keyword" || log.trigger === "pattern" || log.trigger === "moderate") {
+      for (const l of log.logs) this.addLog("handler", `${log.name} console.${l.level}: ${l.text}`);
+      return;
+    }
+    const parts = [`${log.trigger} ${log.name} (${Math.round(log.ms)} ms)`];
+    if (log.error) parts.push(`failed: ${log.error.message}`);
+    for (const r of log.replies) parts.push(`reply: ${r}`);
+    for (const a of log.actions) parts.push(`action ${a.action}: ${a.success ? "ok" : a.error}`);
+    for (const r of log.realtime) parts.push(`realtime ${r.topic}`);
+    this.addLog(log.error ? "error" : "handler", `handler ${parts.join(" \xB7 ")}`, log.value);
+    for (const l of log.logs) this.addLog("handler", `${log.name} console.${l.level}: ${l.text}`);
+  }
+  // ── State ───────────────────────────────────────────────────────────
+  state() {
+    const h = this.host;
+    const rt = this.runtime;
+    const cfg = this.rawConfig;
+    return {
+      project: {
+        name: String(cfg.name ?? ""),
+        category: String(cfg.category ?? "widget"),
+        version: String(cfg.version ?? ""),
+        extensionId: String(cfg.extensionId ?? cfg.extension_id ?? "")
+      },
+      versions: this.opts.modules.versions,
+      view: this.viewTarget,
+      targets: this.opts.targets,
+      chatFirst: this.opts.chatFirst ?? false,
+      mounted: h.mounted,
+      mountError: this.mountError,
+      tree: h.tree,
+      themeMode: this.themeMode,
+      cssVersion: this.cssVersion,
+      build: this.buildStatus,
+      storage: h.storage.entries(),
+      settings: h.settings,
+      db: rt ? rt.db.tables().map((table) => ({ table, rows: rt.db.rows(table) })) : null,
+      player: h.player.state,
+      rewards: h.rewards.list().map((r) => ({ id: r.id, platform: r.platform, title: r.title, cost: r.cost, prompt: r.prompt, inputRequired: r.inputRequired })),
+      redemptions: h.rewards.history().slice(-50),
+      viewers: h.viewers.list().map((v) => ({ login: v.login, displayName: v.displayName, role: v.role })),
+      live: h.live,
+      timers: rt ? [...rt.timers] : [],
+      pendingDeferred: rt?.pendingDeferred ?? 0,
+      functions: this.functionNames(),
+      serverCalls: [...this.serverCalls],
+      overrides: Object.fromEntries(this.overrides),
+      presets: Object.keys(this.opts.mocks?.events ?? {}),
+      defaults: { platform: h.context.platform, user: DEFAULT_USER, role: this.defaultRole() },
+      log: [...this.logEntries]
+    };
+  }
+  functionNames() {
+    const f = this.server.functions;
+    const parsed = typeof f === "string" ? JSON.parse(f) : f;
+    return isObject(parsed) && isObject(parsed.functions) ? Object.keys(parsed.functions) : [];
+  }
+  meta() {
+    const { devkit } = this.opts.modules;
+    return {
+      eventTypes: devkit.EVENT_TYPES.map((type) => ({ type, ...devkit.eventDelivery(type) })).map(({ type, forwarded, reason }) => ({ type, forwarded, reason })),
+      scenarios: Object.keys(devkit.SCENARIOS),
+      platforms: [...devkit.CHAT_PLATFORMS],
+      rewardPlatforms: [...devkit.REWARD_PLATFORMS],
+      roles: [...devkit.VIEWER_ROLES],
+      musicOps: MUSIC_OPS,
+      rewardStatuses: { twitch: ["fulfilled", "canceled"], kick: ["pending", "accepted", "rejected"] }
+    };
+  }
+  /** A payload for the panel's form and JSON editor (`createEvent`, not sent). */
+  eventTemplate(type) {
+    const { devkit } = this.opts.modules;
+    if (!devkit.isLumioEventType(type)) throw new CommandSyntaxError(`Unknown event type "${type}"`);
+    const payload = devkit.createEvent(type, void 0, { seed: (this.opts.seed ?? 1) + this.nextLogId });
+    return { payload, schema: null };
+  }
+  /** The tree node that registered `handlerId` and the prop it belongs to. */
+  findHandler(handlerId) {
+    const stack = [...this.host.tree];
+    while (stack.length) {
+      const node = stack.pop();
+      for (const [key, value] of Object.entries(node.props ?? {})) {
+        if (key.startsWith("__handler_") && value === handlerId) return { node, prop: key.slice("__handler_".length) };
+      }
+      for (const child of node.children ?? []) if (typeof child === "object" && child !== null) stack.push(child);
+    }
+    return null;
+  }
+  // ── Commands ────────────────────────────────────────────────────────
+  /** Runs one command; every input is echoed with what the extension received. */
+  run(cmd, source = "repl") {
+    if (cmd.kind === "repeat") return this.repeat(cmd, source);
+    if (cmd.kind === "stop") {
+      const n = this.stopLoads();
+      this.addLog("input", `${source}: /stop`);
+      return Promise.resolve({ ok: true, output: [n ? `stopped ${n} running load(s)` : "no load is running"] });
+    }
+    return this.serial(async () => {
+      if (cmd.kind !== "help" && cmd.kind !== "status" && cmd.kind !== "callback") {
+        this.addLog("input", `${source}: ${describe(cmd)}`);
+      }
+      const from = this.nextLogId;
+      const since = () => this.logEntries.filter((e) => e.id >= from);
+      try {
+        const result = await this.execute(cmd);
+        await this.host.settle();
+        this.pump();
+        return { ...result, log: since() };
+      } catch (e) {
+        this.pump();
+        const error = message(e);
+        this.addLog("error", error);
+        return { ok: false, output: [`error: ${error}`], error, log: since() };
+      }
+    });
+  }
+  stopLoads() {
+    const n = this.loads.size;
+    for (const ac of this.loads) ac.abort();
+    this.loads.clear();
+    return n;
+  }
+  /** `--count` / `--rate` / `--random`: the inner command, once per run, paced; the first failure stops it. */
+  async repeat(cmd, source) {
+    const fail = (error) => {
+      this.addLog("error", error);
+      return { ok: false, output: [`error: ${error}`], error };
+    };
+    let spec;
+    let variant;
+    try {
+      spec = repeatSpec(cmd, (this.opts.seed ?? 1) + this.nextLogId);
+      variant = repeatVariants(cmd, spec, { eventTypes: this.meta().eventTypes, scenarios: Object.keys(this.opts.modules.devkit.SCENARIOS) });
+    } catch (e) {
+      return fail(message(e));
+    }
+    this.addLog("input", `${source}: ${describe(cmd)}`);
+    const ac = new AbortController();
+    this.loads.add(ac);
+    const from = this.nextLogId;
+    let result;
+    try {
+      result = await runLoad(spec, () => this.closed ? Promise.resolve({ ok: false, output: [], error: "session closed" }) : this.run(variant(), source), { signal: ac.signal });
+    } finally {
+      this.loads.delete(ac);
+    }
+    const summary = summarizeLoad(spec, result);
+    this.addLog(result.failed ? "error" : "info", summary);
+    return {
+      ok: result.failed === null,
+      output: [summary, ...result.failed?.error ? [`error: ${result.failed.error}`] : []],
+      payload: result.results.map((r) => r.payload),
+      ...result.failed?.error ? { error: result.failed.error } : {},
+      log: this.logEntries.filter((e) => e.id >= from)
+    };
+  }
+  user(u) {
+    const name = u?.name?.replace(/^@/, "") || DEFAULT_USER;
+    return u?.role ? { name, role: u.role } : { name };
+  }
+  async execute(cmd) {
+    const h = this.host;
+    switch (cmd.kind) {
+      case "help":
+        return { ok: true, output: REPL_HELP };
+      case "status": {
+        const s = this.state();
+        return {
+          ok: true,
+          output: [
+            `${s.project.name} (${s.project.category}) \xB7 view ${s.view ?? "none"}${s.mountError ? ` (${s.mountError})` : ""}`,
+            `surfaces: ${s.targets.join(", ") || "none"} \xB7 bot runtime: ${this.runtime ? "yes" : "no"} \xB7 functions: ${s.functions.join(", ") || "none"}`,
+            `timers: ${s.timers.map((t) => t.name).join(", ") || "none"} \xB7 presets: ${s.presets.join(", ") || "none"} \xB7 deferred jobs: ${s.pendingDeferred}`,
+            `devkit ${s.versions.devkit} \xB7 sdk ${s.versions.sdk} \xB7 protocol ${s.versions.protocol}`
+          ]
+        };
+      }
+      case "event": {
+        let data;
+        if (cmd.preset !== void 0) {
+          const preset = h.preset(cmd.preset);
+          if (cmd.user) preset.user = this.user(cmd.user);
+          data = h.emit(preset);
+          return { ok: true, output: [`${preset.type} ${compact(data)}`], payload: data };
+        }
+        if (!cmd.type) throw new CommandSyntaxError("An event needs a type or a preset");
+        const type = cmd.type;
+        const overrides = this.coerce(type, cmd.data ?? {});
+        data = h.emit(type, overrides, cmd.user ? { user: this.user(cmd.user) } : void 0);
+        return { ok: true, output: [`${type} ${compact(data)}`], payload: data };
+      }
+      case "chat": {
+        const platform = cmd.platform ?? h.context.platform;
+        const r = await h.chat(cmd.text, { user: this.user(cmd.user), platform });
+        const out = [`${platform}:chat ${r.viewer.login} (${r.viewer.role}): ${r.message.message}`];
+        const bot = r;
+        if (bot.log) out.push(...bot.log.map((l) => `  ${l}`));
+        else if (this.runtime === null) out.push("  (no bot module in this project: delivered as chat events only)");
+        this.addLog("chat", out.join("\n"), r.message);
+        return { ok: true, output: out, payload: r.message };
+      }
+      case "reward": {
+        const platform = cmd.platform ?? (h.context.platform === "kick" ? "kick" : "twitch");
+        const r = h.redeem({ reward: cmd.reward, platform, user: this.user(cmd.user), input: cmd.input });
+        const ev = h.events.at(-1);
+        return { ok: true, output: [`redeemed ${r.rewardId} as ${r.viewer} (redemption ${r.id}, ${r.status})`, `${ev?.type} ${compact(ev?.data)}`], payload: ev?.data };
+      }
+      case "reward-status": {
+        const r = h.rewards.setStatus(cmd.id, cmd.status);
+        const ev = h.events.at(-1);
+        return { ok: true, output: [`redemption ${r.id} \u2192 ${r.status}`], payload: ev?.data };
+      }
+      case "music":
+        return this.music(cmd.op, cmd.args ?? []);
+      case "timer": {
+        if (!this.runtime) throw new CommandSyntaxError("This project has no bot module (server/handler.ts), so it has no timers");
+        const log = await this.runtime.fireTimer(cmd.name);
+        return { ok: true, output: [log ? `timer ${cmd.name} ran (${Math.round(log.ms)} ms)` : `timer ${cmd.name} skipped (see warnings)`] };
+      }
+      case "defer-run": {
+        if (!this.runtime) throw new CommandSyntaxError("This project has no server code, so ctx.defer has nothing queued");
+        const pending = this.runtime.pendingDeferred;
+        const errors = await this.runtime.runDeferred();
+        return { ok: errors.length === 0, output: [`ran ${pending} deferred job batch(es)${errors.length ? `; errors: ${errors.join("; ")}` : ""}`] };
+      }
+      case "scenario":
+        return this.scenario(cmd.name, cmd.options ?? {});
+      case "storage": {
+        if (cmd.key === void 0) return { ok: true, output: [compact(h.storage.entries())], payload: h.storage.entries() };
+        if (!("value" in cmd) || cmd.value === void 0) return { ok: true, output: [`${cmd.key} = ${compact(h.storage.get(cmd.key))}`], payload: h.storage.get(cmd.key) };
+        h.storage.set(cmd.key, cmd.value);
+        return { ok: true, output: [`storage.update ${cmd.key} = ${compact(cmd.value)}`], payload: cmd.value };
+      }
+      case "db": {
+        const rt = this.runtime;
+        if (!rt) throw new CommandSyntaxError("This project has no server code, so it has no ctx.db");
+        if (cmd.reset) {
+          rt.db.reset();
+          return { ok: true, output: ["ctx.db cleared"] };
+        }
+        const tables = cmd.table ? [cmd.table] : rt.db.tables();
+        if (cmd.table && !rt.db.tables().includes(cmd.table)) {
+          throw new CommandSyntaxError(`server/schema.ts declares no table "${cmd.table}" (tables: ${rt.db.tables().join(", ") || "none"})`);
+        }
+        const out = tables.length ? tables.map((t) => `${t} (${rt.db.rows(t).length}): ${compact(rt.db.rows(t))}`) : ["server/schema.ts declares no tables"];
+        return { ok: true, output: out, payload: Object.fromEntries(tables.map((t) => [t, rt.db.rows(t)])) };
+      }
+      case "config": {
+        if (!cmd.settings) return { ok: true, output: [compact(h.settings)], payload: h.settings };
+        if (!isObject(cmd.settings)) throw new CommandSyntaxError("config needs an object of settings");
+        const settings = { ...h.settings, ...cmd.settings };
+        h.setConfig(settings);
+        return { ok: true, output: [`config.update ${compact(settings)}`], payload: settings };
+      }
+      case "theme": {
+        if (cmd.mode !== "light" && cmd.mode !== "dark") throw new CommandSyntaxError('theme is "light" or "dark"');
+        this.themeMode = cmd.mode;
+        h.setTheme(THEMES[cmd.mode]);
+        return { ok: true, output: [`theme.change (${cmd.mode})`], payload: h.theme };
+      }
+      case "view": {
+        if (cmd.target !== "editor" && cmd.target !== "layer") throw new CommandSyntaxError('view is "editor" or "layer"');
+        if (!this.opts.targets.includes(cmd.target)) {
+          throw new CommandSyntaxError(`This project has no ${cmd.target} surface (lumio.config.json targets + src/${cmd.target}.tsx)`);
+        }
+        this.viewTarget = cmd.target;
+        await this.mountView();
+        return { ok: this.mountError === null, output: [this.mountError ? `${cmd.target}: ${this.mountError}` : `view ${cmd.target} mounted`] };
+      }
+      case "callback": {
+        if (typeof cmd.handlerId !== "string") throw new CommandSyntaxError("callback needs a handlerId");
+        const found = this.findHandler(cmd.handlerId);
+        if (!found) throw new CommandSyntaxError("That control is no longer on screen");
+        await h.fire(found.node, found.prop, ...Array.isArray(cmd.args) ? cmd.args : []);
+        return { ok: true, output: [`event.callback ${found.node.type}.${found.prop}`] };
+      }
+      case "server-override": {
+        if (typeof cmd.fn !== "string" || cmd.fn === "") throw new CommandSyntaxError("server-override needs fn");
+        if (cmd.answer === null) {
+          this.overrides.delete(cmd.fn);
+          h.clearMockServer(cmd.fn);
+          return { ok: true, output: [`${cmd.fn}: override removed, the local function answers again`] };
+        }
+        h.mockServer(cmd.fn, cmd.answer);
+        this.overrides.set(cmd.fn, cmd.answer);
+        return { ok: true, output: [`${cmd.fn}: answered by override ${compact(cmd.answer)}`] };
+      }
+      default:
+        throw new CommandSyntaxError(`Unknown command ${compact(cmd.kind)}`);
+    }
+  }
+  /**
+   * REPL fields arrive as `tier=2`: a value keeps the type of the field in the
+   * factory output (a string field stays a string, a number field becomes a
+   * number), so the schema sees what you meant.
+   */
+  coerce(type, data) {
+    const { devkit } = this.opts.modules;
+    if (!devkit.isLumioEventType(type)) return data;
+    const base = devkit.createEvent(type, void 0, { seed: 1 });
+    const walk = (value, template, key = "") => {
+      if (isObject(value)) {
+        const t = isObject(template) ? template : {};
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walk(v, t[k], k)]));
+      }
+      if (/tier$/.test(key) && typeof template === "string" && /^[123]000$/.test(template) && /^[123]$/.test(String(value))) return `${String(value)}000`;
+      if (typeof template === "string" && (typeof value === "number" || typeof value === "boolean")) return String(value);
+      if (typeof template === "number" && typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value))) return Number(value);
+      return value;
+    };
+    return walk(data, base);
+  }
+  music(op, args) {
+    const p = this.host.player;
+    const arg = args[0];
+    const needArg = (what) => {
+      if (arg === void 0) throw new CommandSyntaxError(`/music ${op} needs ${what}`);
+      return arg;
+    };
+    switch (op) {
+      case "play":
+        p.play(arg);
+        break;
+      case "pause":
+        p.pause();
+        break;
+      case "skip":
+        p.skip(arg === void 0 ? 1 : Number(arg));
+        break;
+      case "seek":
+        p.seek(parseDuration(needArg("a time (1:30)")));
+        break;
+      case "volume":
+        p.setVolume(Number(needArg("a percentage")));
+        break;
+      case "shuffle":
+        p.setShuffle(needArg("on|off") === "on");
+        break;
+      case "repeat":
+        p.setRepeat(needArg("off|context|track"));
+        break;
+      case "queue":
+        p.queueAdd(needArg("a track URI"));
+        break;
+      case "device":
+        p.transfer(args.join(" ") || needArg("a device name"));
+        break;
+      case "advance":
+        p.advance(parseDuration(needArg("a duration (30s)")));
+        break;
+      default:
+        throw new CommandSyntaxError(`Unknown /music command "${op}" (${MUSIC_OPS.join(", ")})`);
+    }
+    const s = p.state;
+    return {
+      ok: true,
+      output: [`player: ${s.track ? `${s.track.name}` : "nothing"} \xB7 ${s.is_playing ? "playing" : "paused"} \xB7 ${Math.round(s.progress_ms / 1e3)} s \xB7 volume ${s.device.volume_percent}%`],
+      payload: s
+    };
+  }
+  async scenario(name, options) {
+    const { devkit } = this.opts.modules;
+    const factories = devkit.SCENARIOS;
+    const make = factories[name];
+    if (!make) throw new CommandSyntaxError(`Unknown scenario "${name}" (scenarios: ${Object.keys(factories).join(", ")})`);
+    const { instant, ...rest } = options;
+    for (const key of ["users", "lines"]) {
+      if (typeof rest[key] === "string") rest[key] = rest[key].split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    const run = await this.host.play(make(rest), { instant: instant === true });
+    return { ok: true, output: [`scenario ${run.name}: ${run.events.length} event(s)`], payload: run.events.map((e) => ({ type: e.type, data: e.data })) };
+  }
+};
+function describe(cmd) {
+  switch (cmd.kind) {
+    case "event":
+      return cmd.preset !== void 0 ? `/event @${cmd.preset}` : `/event ${cmd.type ?? "?"}${cmd.data && Object.keys(cmd.data).length ? ` ${compact(cmd.data)}` : ""}`;
+    case "chat":
+      return `/chat ${cmd.user?.role ? `@${cmd.user.role}:` : cmd.user?.name ? "@" : ""}${cmd.user?.name ?? ""}${cmd.user?.name || cmd.user?.role ? " " : ""}${cmd.text}${cmd.platform ? ` --platform ${cmd.platform}` : ""}`;
+    case "reward":
+      return `/reward ${JSON.stringify(cmd.reward)}${cmd.user?.name ? ` --user ${cmd.user.name}` : ""}${cmd.input ? ` --input ${JSON.stringify(cmd.input)}` : ""}${cmd.platform ? ` --platform ${cmd.platform}` : ""}`;
+    case "reward-status":
+      return `/reward-status ${cmd.id} ${cmd.status}`;
+    case "music":
+      return `/music ${cmd.op}${cmd.args?.length ? ` ${cmd.args.join(" ")}` : ""}`;
+    case "timer":
+      return `/timer ${cmd.name}`;
+    case "defer-run":
+      return "/defer run";
+    case "scenario":
+      return `/scenario ${cmd.name}${cmd.options && Object.keys(cmd.options).length ? ` ${compact(cmd.options)}` : ""}`;
+    case "storage":
+      return `/storage${cmd.key ? ` ${cmd.key}` : ""}${cmd.value !== void 0 ? ` ${compact(cmd.value)}` : ""}`;
+    case "db":
+      return `/db${cmd.table ? ` ${cmd.table}` : ""}${cmd.reset ? " --reset" : ""}`;
+    case "config":
+      return `/config${cmd.settings ? ` ${compact(cmd.settings)}` : ""}`;
+    case "theme":
+      return `/theme ${cmd.mode}`;
+    case "view":
+      return `/view ${cmd.target}`;
+    case "callback":
+      return `callback ${cmd.handlerId}`;
+    case "server-override":
+      return `server override ${cmd.fn}${cmd.answer === null ? " (removed)" : ` ${compact(cmd.answer)}`}`;
+    case "repeat": {
+      const inner = cmd.random ? cmd.command.kind === "scenario" ? "/scenario --random" : `/event --random${cmd.platform ? ` --platform ${cmd.platform}` : ""}` : describe(cmd.command);
+      return `${inner} --count ${cmd.count ?? 1}${cmd.intervalMs ? ` --rate ${describeRate(cmd.intervalMs)}` : ""}${cmd.seed !== void 0 ? ` --seed ${cmd.seed}` : ""}`;
+    }
+    default:
+      return `/${cmd.kind}`;
+  }
+}
+
+// src/dev/server.ts
+import * as fs8 from "fs";
+import * as http2 from "http";
+import * as path9 from "path";
+import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import { fileURLToPath } from "url";
+var DEFAULT_DEV_PORT = 3100;
+var TOKEN_HEADER = "x-lumio-dev-token";
+var DEV_SERVER_FILE = path9.join(".lumio", "dev-server.json");
+var MAX_BODY = 1024 * 1024;
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf"
+};
+var PAGE_CSP = [
+  "default-src 'self'",
+  "script-src 'self'",
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: blob: https: http:",
+  "media-src 'self' data: blob: https: http:",
+  "font-src 'self' data: https:",
+  "connect-src 'self'",
+  "frame-ancestors 'none'",
+  "base-uri 'none'",
+  "form-action 'none'"
+].join("; ");
+function defaultSandboxDir() {
+  const here = path9.dirname(fileURLToPath(import.meta.url));
+  const candidates = [path9.join(here, "sandbox"), path9.join(here, "..", "..", "dist", "sandbox")];
+  return candidates.find((c) => fs8.existsSync(path9.join(c, "index.html"))) ?? candidates[0];
+}
+function createToken() {
+  return randomBytes2(24).toString("base64url");
+}
+function writeDevServerFile(projectDir, info) {
+  const file = path9.join(projectDir, DEV_SERVER_FILE);
+  fs8.mkdirSync(path9.dirname(file), { recursive: true });
+  fs8.writeFileSync(file, `${JSON.stringify(info, null, 2)}
+`, { mode: 384 });
+  fs8.chmodSync(file, 384);
+  ensureGitignored(projectDir);
+  return file;
+}
+function ensureGitignored(projectDir) {
+  const file = path9.join(projectDir, ".gitignore");
+  const current = fs8.existsSync(file) ? fs8.readFileSync(file, "utf8") : "";
+  const listed = current.split(/\r?\n/).some((l) => [".lumio", ".lumio/", "/.lumio", "/.lumio/", ".lumio/**"].includes(l.trim()));
+  if (listed) return false;
+  const prefix = current === "" || current.endsWith("\n") ? "" : "\n";
+  fs8.writeFileSync(file, `${current}${prefix}# lumio dev (session token, dev bundles)
+.lumio/
+`);
+  return true;
+}
+function removeDevServerFile(projectDir, token) {
+  const file = path9.join(projectDir, DEV_SERVER_FILE);
+  try {
+    const info = JSON.parse(fs8.readFileSync(file, "utf8"));
+    if (info.token === token) fs8.rmSync(file, { force: true });
+  } catch {
+  }
+}
+function safeEqual(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+function within(root, rel) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(rel);
+  } catch {
+    return null;
+  }
+  if (decoded.includes("\0")) return null;
+  const full = path9.resolve(root, `.${path9.posix.sep}${decoded.replace(/^\/+/, "")}`);
+  const base = path9.resolve(root);
+  return full === base || full.startsWith(base + path9.sep) ? full : null;
+}
+async function startDevServer(options) {
+  const { session, outDir } = options;
+  const sandboxDir = options.sandboxDir ?? defaultSandboxDir();
+  const token = options.token ?? createToken();
+  const requestedPort = options.port ?? DEFAULT_DEV_PORT;
+  const streams = /* @__PURE__ */ new Set();
+  let port = requestedPort;
+  let notifyTimer = null;
+  const allowedHosts = () => /* @__PURE__ */ new Set([`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`]);
+  const send = (res, status, body, type, extra = {}) => {
+    res.writeHead(status, {
+      "Content-Type": type,
+      "Cache-Control": "no-store",
+      "X-Content-Type-Options": "nosniff",
+      "Referrer-Policy": "no-referrer",
+      ...extra
+    });
+    res.end(body);
+  };
+  const json = (res, status, body) => send(res, status, JSON.stringify(body), CONTENT_TYPES[".json"]);
+  const serveFile = (res, file, extra = {}) => {
+    if (!file || !fs8.existsSync(file) || !fs8.statSync(file).isFile()) return json(res, 404, { error: "NOT_FOUND" });
+    send(res, 200, fs8.readFileSync(file), CONTENT_TYPES[path9.extname(file).toLowerCase()] ?? "application/octet-stream", extra);
+  };
+  const readBody = (req) => new Promise((resolve13, reject) => {
+    let size = 0;
+    const chunks = [];
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > MAX_BODY) {
+        reject(new Error("Body larger than 1 MiB"));
+        req.destroy();
+      } else chunks.push(c);
+    });
+    req.on("end", () => resolve13(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+  const broadcast = () => {
+    notifyTimer = null;
+    if (streams.size === 0) return;
+    const data = `event: state
+data: ${JSON.stringify(session.state())}
+
+`;
+    for (const res of streams) res.write(data);
+  };
+  const handler = async (req, res) => {
+    if (!allowedHosts().has(req.headers.host ?? "")) return json(res, 421, { error: "WRONG_HOST", message: "Use the URL lumio dev printed" });
+    const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+    const p = url.pathname;
+    if (p.startsWith("/__lumio/")) {
+      const given = req.headers[TOKEN_HEADER] ?? (p === "/__lumio/stream" ? url.searchParams.get("token") ?? void 0 : void 0);
+      if (!given || !safeEqual(given, token)) {
+        return json(res, 401, { error: "UNAUTHORIZED", message: `Send the token from ${DEV_SERVER_FILE} in the ${TOKEN_HEADER} header` });
+      }
+      if (req.method === "GET" && p === "/__lumio/state") return json(res, 200, session.state());
+      if (req.method === "GET" && p === "/__lumio/meta") return json(res, 200, session.meta());
+      if (req.method === "GET" && p === "/__lumio/event-template") {
+        try {
+          return json(res, 200, session.eventTemplate(url.searchParams.get("type") ?? ""));
+        } catch (e) {
+          return json(res, 400, { error: "BAD_REQUEST", message: e.message });
+        }
+      }
+      if (req.method === "GET" && p === "/__lumio/stream") {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-store",
+          Connection: "keep-alive",
+          "X-Content-Type-Options": "nosniff"
+        });
+        res.write(`retry: 1000
+event: state
+data: ${JSON.stringify(session.state())}
+
+`);
+        streams.add(res);
+        req.on("close", () => streams.delete(res));
+        return;
+      }
+      if (req.method === "POST" && p === "/__lumio/events") {
+        if (!(req.headers["content-type"] ?? "").startsWith("application/json")) {
+          return json(res, 415, { error: "UNSUPPORTED_MEDIA_TYPE", message: "Send application/json" });
+        }
+        let cmd;
+        try {
+          cmd = commandFromJson(JSON.parse(await readBody(req)));
+        } catch (e) {
+          const status = e instanceof CommandSyntaxError || e instanceof SyntaxError ? 400 : 413;
+          return json(res, status, { ok: false, error: e.message });
+        }
+        if (cmd === null) return json(res, 400, { ok: false, error: "Stop the session in its terminal (Ctrl+C or /quit)" });
+        const header = req.headers["x-lumio-source"];
+        const source = header === "panel" ? "panel" : header === "trigger" ? "trigger" : "http";
+        const result = await session.run(cmd, source);
+        return json(res, result.ok ? 200 : 422, result);
+      }
+      return json(res, 404, { error: "NOT_FOUND" });
+    }
+    if (req.method !== "GET" && req.method !== "HEAD") return json(res, 405, { error: "METHOD_NOT_ALLOWED" });
+    if (p === "/" || p === "/index.html") {
+      const file = path9.join(sandboxDir, "index.html");
+      if (!fs8.existsSync(file)) {
+        return send(res, 500, `The sandbox is missing from this CLI install (${file}). Reinstall @zaflun/lumio-cli.`, "text/plain; charset=utf-8");
+      }
+      const html = fs8.readFileSync(file, "utf8").replace("%LUMIO_DEV_TOKEN%", token);
+      return send(res, 200, html, CONTENT_TYPES[".html"], { "Content-Security-Policy": PAGE_CSP });
+    }
+    if (p.startsWith("/sandbox/")) return serveFile(res, within(sandboxDir, p.slice("/sandbox/".length)));
+    if (p.startsWith("/bundles/")) return serveFile(res, within(outDir, p.slice("/bundles/".length)));
+    if (p.startsWith("/assets/")) return serveFile(res, within(path9.join(outDir, "assets"), p.slice("/assets/".length)));
+    return json(res, 404, { error: "NOT_FOUND" });
+  };
+  const server = http2.createServer((req, res) => {
+    handler(req, res).catch((e) => {
+      if (!res.headersSent) json(res, 500, { error: "INTERNAL", message: e instanceof Error ? e.message : String(e) });
+      else res.end();
+    });
+  });
+  await new Promise((resolve13, reject) => {
+    server.once("error", (e) => {
+      reject(e.code === "EADDRINUSE" ? new Error(`Port ${requestedPort} is in use. Stop the other server or pass --port <port>.`) : e);
+    });
+    server.listen(requestedPort, "127.0.0.1", () => resolve13());
+  });
+  const address = server.address();
+  if (address && typeof address === "object") port = address.port;
+  const keepAlive = setInterval(() => {
+    for (const res of streams) res.write(": ping\n\n");
+  }, 15e3);
+  keepAlive.unref();
+  return {
+    url: `http://127.0.0.1:${port}/`,
+    port,
+    token,
+    notify() {
+      if (!notifyTimer) notifyTimer = setTimeout(broadcast, 40);
+    },
+    async close() {
+      clearInterval(keepAlive);
+      if (notifyTimer) clearTimeout(notifyTimer);
+      for (const res of streams) res.end();
+      streams.clear();
+      await new Promise((resolve13) => server.close(() => resolve13()));
+    }
+  };
+}
+
+// src/commands/dev.ts
+var PLATFORMS = ["twitch", "youtube", "kick"];
+var ROLES = ["everyone", "follower", "subscriber", "vip", "moderator", "broadcaster", "owner", "administrator"];
+function intOption(name, min, max) {
+  return (value) => {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < min || n > max) throw new InvalidArgumentError(`${name} must be an integer between ${min} and ${max}.`);
+    return value;
+  };
+}
+function registerDev(program2) {
+  program2.command("dev").description("Run the extension locally: sandbox page, REPL and bot-module runtime in one session").option("-p, --port <port>", "Dev server port", intOption("--port", 0, 65535), String(DEFAULT_DEV_PORT)).option("--bot-module", "Open the sandbox with the chat first (the session is the same)").option("--automation-node", "Start the automation node dev simulator").option("--platform <platform>", `Default chat platform (${PLATFORMS.join(", ")})`, "twitch").option("--role <role>", `Role of the default chat user (${ROLES.slice(0, 6).join(", ")})`).option("--seed <n>", "Seed of every random event field", intOption("--seed", 0, 2 ** 31 - 1), "1").option("--no-cooldown", "Do not enforce command cooldowns").option("--view <target>", "Surface to open first (editor, layer)").option("--open", "Open the sandbox in the browser").action(async (options) => {
+    const configPath = path10.resolve("lumio.config.json");
+    if (!fs9.existsSync(configPath)) {
+      console.error("lumio.config.json not found. Run `lumio init` first.");
+      process.exit(1);
+    }
+    const config = parseConfigFile(fs9.readFileSync(configPath, "utf-8"));
+    if (options.automationNode || config.category === "automation_node") {
+      await runAutomationNodeDevServer(config);
+      return;
+    }
+    try {
+      await runDevSession(process.cwd(), config, options);
+    } catch (e) {
+      console.error(chalk3.red(e instanceof Error ? e.message : String(e)));
+      process.exit(1);
+    }
+  });
+}
+function readRawConfig(projectDir) {
+  return JSON.parse(fs9.readFileSync(path10.join(projectDir, "lumio.config.json"), "utf8"));
+}
+async function runDevSession(projectDir, config, options) {
+  if (!PLATFORMS.includes(options.platform)) throw new Error(`--platform must be one of ${PLATFORMS.join(", ")}`);
+  if (options.role !== void 0 && !ROLES.includes(options.role)) throw new Error(`--role must be one of ${ROLES.join(", ")}`);
+  if (options.view !== void 0 && options.view !== "editor" && options.view !== "layer") throw new Error("--view must be editor or layer");
+  let modules;
+  try {
+    modules = await loadProjectModules(projectDir);
+  } catch (e) {
+    if (e instanceof MissingPackageError) throw new Error(`${e.message}
+lumio dev runs your extension with the devkit's mock host.`);
+    throw e;
+  }
+  const mocks = await modules.devkitNode.loadMockFiles(projectDir);
+  const { targets, skipped } = devTargets(projectDir, config);
+  if (targets.length === 0 && !config.server) {
+    throw new Error('Nothing to run: lumio.config.json has no editor/layer target with a src/<target>.tsx and no "server": true.');
+  }
+  console.log(chalk3.bold(`
+Lumio dev \xB7 ${config.name}`) + chalk3.dim(` (${config.category})`));
+  for (const w of modules.warnings) console.log(chalk3.yellow(`warning: ${w}`));
+  for (const s of skipped) console.log(chalk3.dim(`note: ${s}`));
+  let repl = null;
+  let server = null;
+  const pending = [];
+  const session = new DevSession({
+    projectDir,
+    rawConfig: readRawConfig(projectDir),
+    modules,
+    targets,
+    seed: Number(options.seed),
+    platform: options.platform,
+    role: options.role,
+    cooldowns: options.cooldown,
+    view: options.view ?? void 0,
+    chatFirst: options.botModule ?? false,
+    mocks,
+    onLog: (entry) => repl ? repl.print(entry) : pending.push(entry),
+    onChange: () => server?.notify()
+  });
+  const buildErrors = /* @__PURE__ */ new Map();
+  const builder = new DevBuilder(projectDir, config, targets, {
+    onTarget: (target, code) => void session.updateTarget(target, code),
+    onServer: (next) => void session.updateServer(next),
+    onCss: () => session.cssChanged(),
+    onStatus: (key, errors) => {
+      const before = JSON.stringify([...buildErrors]);
+      if (errors) buildErrors.set(key, errors);
+      else buildErrors.delete(key);
+      if (JSON.stringify([...buildErrors]) === before) return;
+      const all = [...buildErrors.values()].flat();
+      session.setBuild({ ok: all.length === 0, errors: all });
+      if (!errors && all.length === 0) session.addLog("build", "build ok");
+    }
+  });
+  const first = await builder.start();
+  await session.start(first.server, first.bundles);
+  server = await startDevServer({ session, outDir: builder.outDir, port: Number(options.port) });
+  writeDevServerFile(projectDir, {
+    url: server.url,
+    port: server.port,
+    token: server.token,
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const state = session.state();
+  console.log(`Sandbox:  ${chalk3.cyan(server.url)}`);
+  console.log(chalk3.dim(`Surfaces: ${state.targets.join(", ") || "none"} \xB7 bot runtime: ${config.server ? "on" : "off"} \xB7 seed ${options.seed} \xB7 platform ${options.platform}`));
+  console.log(chalk3.dim("Type /help for commands. Plain text is a chat message.\n"));
+  if (options.open) {
+    const { default: open } = await import("open");
+    await open(server.url).catch(() => {
+    });
+  }
+  let configTimer = null;
+  const reloadConfig = () => {
+    if (configTimer) clearTimeout(configTimer);
+    configTimer = setTimeout(() => {
+      void (async () => {
+        try {
+          const raw = readRawConfig(projectDir);
+          const nextMocks = await modules.devkitNode.loadMockFiles(projectDir);
+          await session.updateConfig(raw, nextMocks);
+        } catch (e) {
+          session.addLog("error", `lumio.config.json / lumio/mocks/ not reloaded: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      })();
+    }, 150);
+  };
+  const watchers = [fs9.watch(path10.join(projectDir, "lumio.config.json"), reloadConfig)];
+  const mocksDir = path10.join(projectDir, "lumio", "mocks");
+  if (fs9.existsSync(mocksDir)) {
+    try {
+      watchers.push(fs9.watch(mocksDir, { recursive: true }, reloadConfig));
+    } catch {
+    }
+  }
+  await new Promise((resolve13) => {
+    let stopping = false;
+    const stop = () => {
+      if (stopping) return;
+      stopping = true;
+      void (async () => {
+        for (const w of watchers) w.close();
+        if (configTimer) clearTimeout(configTimer);
+        removeDevServerFile(projectDir, server?.token ?? "");
+        await server?.close();
+        await builder.stop();
+        await session.close();
+        repl?.close();
+        console.log(chalk3.dim("\nlumio dev stopped."));
+        resolve13();
+      })();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    repl = startRepl(session, stop);
+    for (const entry of pending.splice(0)) repl.print(entry);
+  });
+}
+
+// src/commands/trigger.ts
+import chalk4 from "chalk";
+
+// src/dev/trigger.ts
+import * as fs10 from "fs";
+import * as path11 from "path";
+var VALUE_FLAGS = ["field", "data", "json", "file", "user", "role", "platform", "input", "timer", "storage", "count", "rate", "seed"];
+var REPEATABLE = /* @__PURE__ */ new Set(["field", "storage"]);
+var BOOLEAN_FLAGS = ["random", "quiet"];
+var TRIGGER_USAGE = [
+  "lumio trigger <type> [field=value \u2026] [--field a.b=value] [--<field> value] [--data '{\u2026}'] [--file payload.json] [--user name] [--role role]",
+  "lumio trigger @<preset> [--user name]",
+  'lumio trigger chat "<text>" [--user name] [--role moderator] [--platform kick]',
+  'lumio trigger reward "<title or id>" [--user name] [--input "text"] [--platform kick]',
+  "lumio trigger reward-status <redemption-id> <status>",
+  "lumio trigger music play|pause|skip|seek 1:30|volume 50|\u2026",
+  "lumio trigger scenario <name> [key=value \u2026]",
+  "lumio trigger --timer <name>          lumio trigger --storage key='<json>'",
+  "load: --count N  --rate 5/s  --random [--platform twitch]  --seed n  --quiet"
+];
+function isObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMerge(target, source) {
+  for (const [k, v] of Object.entries(source)) {
+    if (k === "__proto__" || k === "constructor" || k === "prototype") throw new CommandSyntaxError(`Invalid field "${k}"`);
+    target[k] = isObject2(v) && isObject2(target[k]) ? deepMerge(target[k], v) : v;
+  }
+  return target;
+}
+function jsonObject(raw, what) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (e) {
+    throw new CommandSyntaxError(`${what} is not valid JSON: ${e.message}`);
+  }
+  if (!isObject2(value)) throw new CommandSyntaxError(`${what} must be a JSON object`);
+  return value;
+}
+function roleOf(raw) {
+  const role = ROLE_ALIASES[raw.toLowerCase()];
+  if (!role) throw new CommandSyntaxError(`Unknown role "${raw}" (use ${Object.keys(ROLE_ALIASES).join(", ")})`);
+  return role;
+}
+function storageCommand(raw) {
+  const eq = raw.indexOf("=");
+  if (eq <= 0) throw new CommandSyntaxError(`--storage needs key=value, got "${raw}"`);
+  const key = raw.slice(0, eq);
+  const text = raw.slice(eq + 1);
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    if (/^\s*[[{"]/.test(text)) throw new CommandSyntaxError(`--storage ${key}: not valid JSON: ${text}`);
+    value = text;
+  }
+  return { kind: "storage", key, value };
+}
+function parseTriggerArgs(argv, cwd = process.cwd()) {
+  const words = [];
+  const flags = /* @__PURE__ */ new Map();
+  const bools = /* @__PURE__ */ new Set();
+  const shortcuts = [];
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i];
+    if (!t.startsWith("--") || t === "--") {
+      if (t !== "--") words.push(t);
+      continue;
+    }
+    const eq = t.indexOf("=");
+    const name = eq === -1 ? t.slice(2) : t.slice(2, eq);
+    if (name === "") throw new CommandSyntaxError(`Invalid option ${t}`);
+    if (BOOLEAN_FLAGS.includes(name)) {
+      if (eq !== -1) throw new CommandSyntaxError(`--${name} takes no value`);
+      bools.add(name);
+      continue;
+    }
+    let value;
+    if (eq !== -1) value = t.slice(eq + 1);
+    else {
+      if (i + 1 >= argv.length) throw new CommandSyntaxError(`--${name} needs a value`);
+      value = argv[++i];
+    }
+    if (VALUE_FLAGS.includes(name)) {
+      const list = flags.get(name) ?? [];
+      if (list.length && !REPEATABLE.has(name)) throw new CommandSyntaxError(`--${name} is given twice`);
+      flags.set(name, [...list, value]);
+    } else shortcuts.push([name, value]);
+  }
+  const one = (name) => flags.get(name)?.[0];
+  if (one("json") !== void 0 && one("data") !== void 0) throw new CommandSyntaxError("--json is --data: give one of them");
+  const setup = [...(flags.get("storage") ?? []).map(storageCommand)];
+  const timer = one("timer");
+  if (timer !== void 0) setup.push({ kind: "timer", name: timer });
+  let user;
+  const userFlag2 = one("user");
+  const role = one("role");
+  if (userFlag2 !== void 0) user = userFlag2.startsWith("@") ? parseUserPrefix(userFlag2) : { name: userFlag2 };
+  if (role !== void 0) user = { ...user, role: roleOf(role) };
+  const load = { count: one("count"), rate: one("rate"), seed: one("seed"), random: bools.has("random") };
+  const platform = one("platform");
+  const only = (allowed, what) => {
+    for (const name of ["field", "data", "json", "file", "input"]) {
+      if (flags.has(name) && !allowed.includes(name)) throw new CommandSyntaxError(`--${name} does not apply to ${what}`);
+    }
+    if (shortcuts.length && !allowed.includes("field")) throw new CommandSyntaxError(`Unknown option --${shortcuts[0][0]} (${what} takes no fields)`);
+  };
+  const [head, ...rest] = words;
+  let main;
+  if (head === void 0) {
+    if (load.random) {
+      only([], "--random");
+      main = withLoad({ kind: "event", user }, { ...load, platform });
+    } else {
+      if (setup.length === 0) throw new CommandSyntaxError(`Nothing to trigger. Usage:
+  ${TRIGGER_USAGE.join("\n  ")}`);
+      only([], "--timer / --storage");
+      if (user || platform || load.count || load.rate || load.seed) throw new CommandSyntaxError("--user, --role, --platform and load flags need an event, chat message or scenario");
+      main = null;
+    }
+  } else if (head === "chat") {
+    only([], "a chat message");
+    const text = rest.join(" ");
+    if (text === "") throw new CommandSyntaxError('Usage: lumio trigger chat "<text>" [--user name] [--role role] [--platform kick]');
+    main = withLoad({ kind: "chat", text, user, platform }, load);
+  } else if (head === "reward") {
+    only(["input"], "a reward");
+    if (rest.length !== 1) throw new CommandSyntaxError('Usage: lumio trigger reward "<title or id>" [--user name] [--input "text"] [--platform kick]');
+    main = withLoad({ kind: "reward", reward: rest[0], user, input: one("input"), platform }, load);
+  } else if (head === "reward-status") {
+    only([], "a reward status");
+    if (rest.length !== 2) throw new CommandSyntaxError("Usage: lumio trigger reward-status <redemption-id> <status>");
+    main = withLoad({ kind: "reward-status", id: rest[0], status: rest[1] }, load);
+  } else if (head === "music") {
+    only([], "the music player");
+    const [op, ...args] = rest;
+    if (!op) throw new CommandSyntaxError("Usage: lumio trigger music play|pause|skip [n]|seek 1:30|volume 50|shuffle on|repeat track|queue <uri>|device <name>|advance 30s");
+    main = withLoad({ kind: "music", op, args }, load);
+  } else if (head === "scenario") {
+    only([], "a scenario (options are key=value words)");
+    const [name, ...opts] = rest;
+    if (!name && !load.random) throw new CommandSyntaxError("Usage: lumio trigger scenario <name> [key=value \u2026] | lumio trigger scenario --random");
+    main = withLoad({ kind: "scenario", name: name ?? "", options: assignments(opts, "scenario options") }, load);
+  } else if (head.startsWith("@")) {
+    only([], "a preset");
+    if (rest.length) throw new CommandSyntaxError("A preset takes no fields");
+    main = withLoad({ kind: "event", preset: head.slice(1), user }, load);
+  } else if (head.includes(":")) {
+    if (load.random) throw new CommandSyntaxError("--random picks the event type itself: drop the type (every event gets fresh random fields anyway)");
+    const data = {};
+    const file = one("file");
+    if (file !== void 0) {
+      const full = path11.resolve(cwd, file);
+      if (!fs10.existsSync(full)) throw new CommandSyntaxError(`--file ${file}: no such file`);
+      deepMerge(data, jsonObject(fs10.readFileSync(full, "utf8"), `--file ${file}`));
+    }
+    const raw = one("data") ?? one("json");
+    if (raw !== void 0) deepMerge(data, jsonObject(raw, "--data"));
+    deepMerge(data, assignments(rest, "event fields"));
+    for (const f of flags.get("field") ?? []) deepMerge(data, assignments([f], "--field"));
+    for (const [name, value] of shortcuts) setPath(data, name, parseValue(value));
+    main = withLoad({ kind: "event", type: head, data, user }, { ...load, platform });
+  } else {
+    throw new CommandSyntaxError(`Unknown trigger "${head}": use an event type (twitch:follower), @preset, chat, reward, music or scenario`);
+  }
+  return { setup, main, quiet: bools.has("quiet") };
+}
+var DevServerError = class extends Error {
+  code;
+  constructor(code, message2) {
+    super(message2);
+    this.name = "DevServerError";
+    this.code = code;
+  }
+};
+function findProjectDir(start) {
+  let dir = path11.resolve(start);
+  for (; ; ) {
+    if (fs10.existsSync(path11.join(dir, DEV_SERVER_FILE)) || fs10.existsSync(path11.join(dir, "lumio.config.json"))) return dir;
+    const parent = path11.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readDevServerFile(projectDir) {
+  const file = path11.join(projectDir, DEV_SERVER_FILE);
+  if (!fs10.existsSync(file)) {
+    throw new DevServerError("NO_SESSION", `No lumio dev session is running in ${projectDir} (no ${DEV_SERVER_FILE}). Start \`lumio dev\` in another terminal first.`);
+  }
+  let info;
+  try {
+    info = JSON.parse(fs10.readFileSync(file, "utf8"));
+  } catch {
+    throw new DevServerError("BAD_FILE", `${DEV_SERVER_FILE} is not valid JSON. Restart \`lumio dev\` to rewrite it.`);
+  }
+  let url = null;
+  try {
+    url = typeof info.url === "string" ? new URL(info.url) : null;
+  } catch {
+    url = null;
+  }
+  if (!url || url.protocol !== "http:" || url.hostname !== "127.0.0.1" || typeof info.token !== "string" || info.token === "" || typeof info.port !== "number") {
+    throw new DevServerError("BAD_FILE", `${DEV_SERVER_FILE} does not describe a local lumio dev session (http://127.0.0.1:<port>/ and a token). Restart \`lumio dev\` to rewrite it.`);
+  }
+  return info;
+}
+function connectDevServer(projectDir, fetchImpl = fetch) {
+  const info = readDevServerFile(projectDir);
+  const base = new URL(info.url);
+  const request = async (route, init = {}) => {
+    let res;
+    try {
+      res = await fetchImpl(new URL(route, base), { ...init, headers: { ...init.headers, [TOKEN_HEADER]: info.token } });
+    } catch {
+      throw new DevServerError(
+        "NOT_RUNNING",
+        `The lumio dev session from ${DEV_SERVER_FILE} (port ${info.port}, pid ${info.pid}) is not answering \u2014 it was stopped or crashed. Start \`lumio dev\` again.`
+      );
+    }
+    if (res.status === 401 || res.status === 421) {
+      throw new DevServerError(
+        "BAD_TOKEN",
+        `The server on port ${info.port} refused the token from ${DEV_SERVER_FILE}: it is another lumio dev session (another project?) or the file is stale. Restart \`lumio dev\` in this project.`
+      );
+    }
+    return res;
+  };
+  const body = async (res) => {
+    try {
+      return await res.json();
+    } catch {
+      throw new DevServerError("BAD_RESPONSE", `The server on port ${info.port} did not answer like lumio dev (HTTP ${res.status}). Is something else using the port?`);
+    }
+  };
+  return {
+    url: info.url,
+    async meta() {
+      const res = await request("/__lumio/meta");
+      if (!res.ok) throw new DevServerError("BAD_RESPONSE", `GET /__lumio/meta answered HTTP ${res.status}`);
+      return body(res);
+    },
+    async send(cmd) {
+      const res = await request("/__lumio/events", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Lumio-Source": "trigger" },
+        body: JSON.stringify(cmd)
+      });
+      const r = await body(res);
+      if (res.ok || res.status === 422) return { ok: r.ok === true, output: r.output ?? [], log: r.log, payload: r.payload, error: r.error };
+      const error = r.error && r.message ? `${r.error}: ${r.message}` : r.error ?? r.message ?? `HTTP ${res.status}`;
+      return { ok: false, output: [], error };
+    }
+  };
+}
+async function runTrigger(client, plan, hooks = {}) {
+  const results = [];
+  const send = async (cmd) => {
+    const r = await client.send(cmd);
+    results.push(r);
+    hooks.onResult?.(r, cmd);
+    return r;
+  };
+  for (const cmd of plan.setup) {
+    if (!(await send(cmd)).ok) return { results, ok: false };
+  }
+  if (!plan.main) return { results, ok: true };
+  if (plan.main.kind !== "repeat") return { results, ok: (await send(plan.main)).ok };
+  const repeat = plan.main;
+  const spec = repeatSpec(repeat, repeat.seed ?? (hooks.seed ?? freshSeed)());
+  const meta = spec.random ? await client.meta() : { eventTypes: [], scenarios: [] };
+  const variant = repeatVariants(repeat, spec, meta);
+  const result = await runLoad(spec, () => send(variant()), { signal: hooks.signal });
+  return { results, load: { spec, result, summary: summarizeLoad(spec, result) }, ok: result.failed === null };
+}
+
+// src/commands/trigger.ts
+function formatResult(r) {
+  const log = (r.log ?? []).filter((e) => e.kind !== "input");
+  const lines = log.length ? log.map(formatLogEntry) : r.output.map((l) => r.ok ? l : chalk4.red(l));
+  if (!r.ok && r.error && !log.some((e) => e.kind === "error")) lines.push(chalk4.red(`error: ${r.error}`));
+  return lines;
+}
+function registerTrigger(program2) {
+  program2.command("trigger").description("Send an event, chat message, reward, music command, timer or scenario to the running `lumio dev`").argument("[args...]", "what to trigger (see below)").allowUnknownOption().allowExcessArguments().helpOption("-h, --help", "Show help").addHelpText(
+    "after",
+    [
+      "",
+      "Usage:",
+      ...TRIGGER_USAGE.map((l) => `  ${l}`),
+      "",
+      "Examples:",
+      "  lumio trigger twitch:follower",
+      "  lumio trigger twitch:subscribe --tier 2 --field user_name=Alice",
+      "  lumio trigger kick:reward --field reward.title=Hydrate",
+      '  lumio trigger chat "!points 100" --user alice --role moderator',
+      "  lumio trigger twitch:follower --count 50 --rate 5/s",
+      "  lumio trigger --random --count 20 --rate 2/s --platform kick",
+      "  lumio trigger music skip",
+      "  lumio trigger --timer reminder",
+      `  lumio trigger --storage counter='{"value":3}'`,
+      "",
+      "Talks to the lumio dev session of this project through .lumio/dev-server.json."
+    ].join("\n")
+  ).action(async (args) => {
+    let plan;
+    try {
+      plan = parseTriggerArgs(args);
+    } catch (e) {
+      console.error(chalk4.red(e instanceof Error ? e.message : String(e)));
+      process.exit(2);
+    }
+    const projectDir = findProjectDir(process.cwd()) ?? process.cwd();
+    const abort = new AbortController();
+    const onSigint = () => {
+      if (abort.signal.aborted) process.exit(130);
+      abort.abort();
+    };
+    process.on("SIGINT", onSigint);
+    try {
+      const client = connectDevServer(projectDir);
+      const quiet = plan.quiet;
+      const run = await runTrigger(client, plan, {
+        signal: abort.signal,
+        onResult: (r) => {
+          if (quiet && r.ok) return;
+          for (const line of formatResult(r)) console.log(line);
+        }
+      });
+      if (run.load) console.log((run.ok ? chalk4.dim : chalk4.red)(run.load.summary));
+      process.exitCode = run.ok ? 0 : 1;
+    } catch (e) {
+      const known = e instanceof DevServerError || e instanceof CommandSyntaxError;
+      console.error(chalk4.red(known ? e.message : `lumio trigger failed: ${e instanceof Error ? e.message : String(e)}`));
+      process.exitCode = 1;
+    } finally {
+      process.off("SIGINT", onSigint);
+    }
+  });
+}
+
+// src/commands/build.ts
+import * as fs11 from "fs";
+import * as path12 from "path";
+function registerBuild(program2) {
+  program2.command("build").description("Bundle extension as standalone HTML + source archive").action(async () => {
+    const configPath = path12.resolve("lumio.config.json");
+    if (!fs11.existsSync(configPath)) {
+      console.error("lumio.config.json not found. Run `lumio init` first.");
+      process.exit(1);
+    }
+    const configJson = fs11.readFileSync(configPath, "utf-8");
+    const config = parseConfigFile(configJson);
+    validateConfig(config);
+    const changelogPath = path12.resolve("CHANGELOG.md");
+    if (!fs11.existsSync(changelogPath)) {
+      console.warn("Warning: No CHANGELOG.md found. It is recommended to maintain a changelog.");
+    }
+    console.log(`Building ${config.name} v${config.version}...`);
+    const distDir = path12.resolve("dist");
+    fs11.mkdirSync(distDir, { recursive: true });
+    const { build } = await import("esbuild");
+    const projectDir = process.cwd();
+    if (config.category === "bot_module" && config.targets.length === 0) {
+      console.log("  Bot module \u2014 no UI targets to bundle.");
+    }
+    const manifestPath = path12.join(distDir, FUNCTIONS_MANIFEST_FILE);
+    fs11.rmSync(manifestPath, { force: true });
+    const functionsFile = config.category !== "automation_node" ? findFunctionsFile(projectDir) : null;
+    if (functionsFile && !config.server) {
+      console.warn(`  Warning: ${functionsFile} found but lumio.config.json has no "server": true \u2014 it is not built.`);
+    }
+    if (config.server) {
+      let plan;
+      try {
+        plan = await planServerBuild(projectDir, config, path12.join(distDir, "server.js"));
+      } catch (err) {
+        console.error(`  Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
+      if (plan.options) {
+        await build(plan.options);
+        console.log("  Built: dist/server.js");
+      } else {
+        console.warn("  Warning: server: true but no server/handler.ts, server/index.ts or server/functions.ts found.");
+      }
+      if (plan.manifest) {
+        fs11.writeFileSync(manifestPath, `${JSON.stringify(plan.manifest, null, 2)}
+`);
+        console.log(`  Built: dist/${FUNCTIONS_MANIFEST_FILE} (${Object.keys(plan.manifest.functions).length} function(s))`);
+      }
+    }
+    const cssEntryFile = findCssEntry(projectDir);
+    try {
+      const css = await compileCss(projectDir, distDir);
+      if (css?.tailwind) console.log("  Tailwind CSS v4 detected \u2014 compiled dist/styles.css");
+      else if (css) console.log(`  Copied: ${cssEntryFile} \u2192 dist/styles.css`);
+    } catch (err) {
+      console.error(`  Error: Tailwind CSS compilation failed. ${err instanceof CssBuildError ? err.hint : ""}`);
+      console.error(`  ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    for (const target of config.targets) {
+      const entryPoint = targetEntry(projectDir, target);
+      if (!entryPoint) {
+        console.warn(`Warning: Entry point ${path12.resolve("src", `${target}.tsx`)} not found, skipping target "${target}".`);
+        continue;
+      }
+      await build(targetBuildOptions(entryPoint, distDir, target));
+      console.log(`  Built: dist/${target}.js`);
+    }
+    const { TarArchive } = await import("archiver");
+    const sourceArchivePath = path12.join(distDir, "source.tar.gz");
+    const output = fs11.createWriteStream(sourceArchivePath);
+    const archive = new TarArchive({ gzip: true });
+    archive.pipe(output);
+    archive.glob("**/*", {
+      cwd: path12.resolve("."),
+      ignore: [
+        "node_modules/**",
+        "dist/**",
+        ".git/**",
+        ".git",
+        ".next/**",
+        ".lumio-dist/**",
+        "*.tgz",
+        "*.tar.gz",
+        // Secrets & credentials must never be uploaded to the store: the
+        // archive is visible to reviewers. Exclude env files (except the
+        // example), npm/yarn auth, and local CLI state.
+        // archiver 8's readdir-glob@3 dropped the `!pattern` un-ignore
+        // feature (each ignore entry is now an independent minimatch, so a
+        // leading `!` inverts that one matcher and ignores everything else).
+        // Keep `.env.example` via an extglob instead of a negated entry.
+        "**/.env",
+        "**/.env.!(example)",
+        "**/.npmrc",
+        "**/.yarnrc",
+        "**/.yarnrc.yml",
+        "**/.lumio/**"
+      ],
+      dot: true
+    });
+    await archive.finalize();
+    console.log("  Archive: dist/source.tar.gz");
+    console.log("Build complete.");
+  });
+}
+
+// src/commands/deploy.ts
+import * as fs12 from "fs";
+import * as path13 from "path";
+
+// src/changelog/parser.ts
+var VERSION_HEADER_REGEX = /^## \[([^\]]+)\](?:\s*-\s*(\d{4}-\d{2}-\d{2}))?/;
+function parseChangelog(markdown) {
+  const lines = markdown.split("\n");
+  const entries = [];
+  let currentEntry = null;
+  const contentLines = [];
+  for (const line of lines) {
+    const match = line.match(VERSION_HEADER_REGEX);
+    if (match) {
+      if (currentEntry) {
+        currentEntry.content = contentLines.join("\n").trim();
+        entries.push(currentEntry);
+        contentLines.length = 0;
+      }
+      currentEntry = {
+        version: match[1],
+        date: match[2] ?? null,
+        content: ""
+      };
+    } else if (currentEntry) {
+      contentLines.push(line);
+    }
+  }
+  if (currentEntry) {
+    currentEntry.content = contentLines.join("\n").trim();
+    entries.push(currentEntry);
+  }
+  return entries;
+}
+function getVersionEntry(changelog, version) {
+  const entries = parseChangelog(changelog);
+  return entries.find((e) => e.version === version) ?? null;
+}
+
+// src/commands/deploy.ts
+function collectFiles(dir, base = dir) {
+  const entries = fs12.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path13.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath, base));
+    } else if (entry.isFile()) {
+      files.push(path13.relative(base, fullPath));
+    }
+  }
+  return files;
+}
+var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
+  "js",
+  "css",
+  "html",
+  "map",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "svg",
+  "webp",
   "avif",
   "ico",
   "mp4",
@@ -1291,15 +3934,15 @@ function registerDeploy(program2) {
       console.error("Not logged in. Run `lumio login` or provide --token.");
       process.exit(1);
     }
-    const configPath = path5.resolve("lumio.config.json");
-    if (!fs5.existsSync(configPath)) {
+    const configPath = path13.resolve("lumio.config.json");
+    if (!fs12.existsSync(configPath)) {
       console.error("lumio.config.json not found. Run `lumio init` first.");
       process.exit(1);
     }
-    const configJson = fs5.readFileSync(configPath, "utf-8");
+    const configJson = fs12.readFileSync(configPath, "utf-8");
     const config = parseConfigFile(configJson);
     validateConfig(config);
-    const distDir = path5.resolve("dist");
+    const distDir = path13.resolve("dist");
     if (config.sounds && config.sounds.length > 0) {
       for (const sound of config.sounds) {
         const soundFile = sound.file;
@@ -1310,15 +3953,15 @@ function registerDeploy(program2) {
           );
           process.exit(1);
         }
-        const soundAbsPath = path5.join(distDir, "sounds", soundFile);
-        if (fs5.existsSync(distDir) && !fs5.existsSync(soundAbsPath)) {
+        const soundAbsPath = path13.join(distDir, "sounds", soundFile);
+        if (fs12.existsSync(distDir) && !fs12.existsSync(soundAbsPath)) {
           console.error(
             `Error: Sound file "${soundFile}" declared in lumio.config.json was not found at dist/sounds/${soundFile}. Run \`lumio build\` first.`
           );
           process.exit(1);
         }
-        if (fs5.existsSync(soundAbsPath)) {
-          const stat = fs5.statSync(soundAbsPath);
+        if (fs12.existsSync(soundAbsPath)) {
+          const stat = fs12.statSync(soundAbsPath);
           if (stat.size > LARGE_SOUND_THRESHOLD) {
             console.warn(
               `  Warning: Sound file "${soundFile}" is ${(stat.size / 1024 / 1024).toFixed(1)} MB. Consider compressing large audio files to reduce load times.`
@@ -1344,22 +3987,22 @@ function registerDeploy(program2) {
               `Error: Extension declares ${config.sounds.length} sounds, but your limit is ${maxSounds}.`
             );
             console.error(
-              "Request a limit increase at /account/developer/limits or contact support."
+              "Request a limit increase at /dashboard/settings/developer/limits or contact support."
             );
             process.exit(1);
           }
           let totalSize2 = 0;
           for (const sound of config.sounds) {
-            const soundPath = path5.resolve("dist", "sounds", sound.file);
-            if (fs5.existsSync(soundPath)) {
-              const size = fs5.statSync(soundPath).size;
+            const soundPath = path13.resolve("dist", "sounds", sound.file);
+            if (fs12.existsSync(soundPath)) {
+              const size = fs12.statSync(soundPath).size;
               totalSize2 += size;
               if (size > maxFileSize) {
                 console.error(
                   `Error: Sound file "${sound.file}" is ${(size / 1024 / 1024).toFixed(1)} MB but your per-file limit is ${(maxFileSize / 1024 / 1024).toFixed(1)} MB.`
                 );
                 console.error(
-                  "Request a limit increase at /account/developer/limits or contact support."
+                  "Request a limit increase at /dashboard/settings/developer/limits or contact support."
                 );
                 process.exit(1);
               }
@@ -1370,7 +4013,7 @@ function registerDeploy(program2) {
               `Error: Total sound size is ${(totalSize2 / 1024 / 1024).toFixed(1)} MB but your storage limit is ${(maxStorage / 1024 / 1024).toFixed(1)} MB.`
             );
             console.error(
-              "Request a limit increase at /account/developer/limits or contact support."
+              "Request a limit increase at /dashboard/settings/developer/limits or contact support."
             );
             process.exit(1);
           }
@@ -1388,9 +4031,9 @@ function registerDeploy(program2) {
     const version = options.version ?? config.version;
     let releaseNotes = options.description ?? "";
     if (!releaseNotes) {
-      const changelogPath = path5.resolve("CHANGELOG.md");
-      if (fs5.existsSync(changelogPath)) {
-        const changelog = fs5.readFileSync(changelogPath, "utf-8");
+      const changelogPath = path13.resolve("CHANGELOG.md");
+      if (fs12.existsSync(changelogPath)) {
+        const changelog = fs12.readFileSync(changelogPath, "utf-8");
         const entry = getVersionEntry(changelog, version);
         if (entry) {
           releaseNotes = entry.content;
@@ -1401,10 +4044,23 @@ function registerDeploy(program2) {
         }
       }
     }
-    if (!fs5.existsSync(distDir)) {
+    let dataSchema;
+    try {
+      dataSchema = await loadDataSchema(process.cwd());
+    } catch (err) {
+      console.error(`Error: Could not load server/schema.ts: ${err.message ?? String(err)}`);
+      process.exit(1);
+    }
+    if (!fs12.existsSync(distDir)) {
       console.error("No dist/ directory found. Run `lumio build` first.");
       process.exit(1);
     }
+    const exposesFunctions = config.server && config.category !== "automation_node";
+    const functionsFile = exposesFunctions ? findFunctionsFile(process.cwd()) : null;
+    if (functionsFile && !fs12.existsSync(path13.join(distDir, FUNCTIONS_MANIFEST_FILE))) {
+      console.error(`Error: ${functionsFile} exists but dist/${FUNCTIONS_MANIFEST_FILE} is missing. Run \`lumio build\` first.`);
+      process.exit(1);
+    }
     console.log(`Deploying ${config.name} v${version}...`);
     const apiUrl = process.env.LUMIO_API_URL ?? store.getApiUrl();
     const client = new LumioApiClient(apiUrl, token);
@@ -1424,8 +4080,8 @@ function registerDeploy(program2) {
       console.error(`Too many files (${bundleFiles.length}). Maximum is ${MAX_FILES}.`);
       process.exit(1);
     }
-    const sourceArchive = path5.join(distDir, sourceFile);
-    if (!fs5.existsSync(sourceArchive)) {
+    const sourceArchive = path13.join(distDir, sourceFile);
+    if (!fs12.existsSync(sourceArchive)) {
       console.error("Error: source.tar.gz not found in dist/. Run `lumio build` first.");
       process.exit(1);
     }
@@ -1436,7 +4092,11 @@ function registerDeploy(program2) {
     formData.append("manifest", JSON.stringify(manifest));
     formData.append("release_notes", releaseNotes);
     formData.append("is_breaking", String(!!options.breaking));
-    const sourceBuffer = fs5.readFileSync(sourceArchive);
+    if (dataSchema) {
+      formData.append("data_schema", JSON.stringify(dataSchema));
+      console.log(`  Data schema: ${Object.keys(dataSchema.tables).length} table(s)`);
+    }
+    const sourceBuffer = fs12.readFileSync(sourceArchive);
     if (sourceBuffer.length === 0) {
       console.error("Error: source.tar.gz is empty. Run `lumio build` to regenerate.");
       process.exit(1);
@@ -1445,8 +4105,8 @@ function registerDeploy(program2) {
     console.log(`  Source: source.tar.gz (${(sourceBuffer.length / 1024).toFixed(1)} KB)`);
     let totalSize = 0;
     for (const relPath of bundleFiles) {
-      const absPath = path5.join(distDir, relPath);
-      const buffer = fs5.readFileSync(absPath);
+      const absPath = path13.join(distDir, relPath);
+      const buffer = fs12.readFileSync(absPath);
       if (buffer.length === 0) {
         console.warn(`  Warning: Skipping empty file: ${relPath}`);
         continue;
@@ -1475,9 +4135,16 @@ function registerDeploy(program2) {
       }
     } catch (err) {
       const status = err.status;
-      const message = err.message ?? String(err);
+      const message2 = err.message ?? String(err);
+      const schemaLines = err instanceof ApiError && status === 422 ? formatDataSchemaError(err.body) : null;
+      if (schemaLines) {
+        console.error(`
+  Deploy failed (HTTP ${status}):`);
+        for (const line of schemaLines) console.error(`  ${line}`);
+        process.exit(1);
+      }
       console.error(`
-  Deploy failed${status ? ` (HTTP ${status})` : ""}: ${message}`);
+  Deploy failed${status ? ` (HTTP ${status})` : ""}: ${message2}`);
       if (status === 409) {
         console.error("  This version already exists. Bump the version in lumio.config.json.");
       } else if (status === 413) {
@@ -1491,8 +4158,8 @@ function registerDeploy(program2) {
 }
 
 // src/commands/status.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 function registerStatus(program2) {
   program2.command("status").description("Show review status of the latest version").action(async () => {
     const store = new CredentialStore();
@@ -1501,12 +4168,12 @@ function registerStatus(program2) {
       console.error("Not logged in. Run `lumio login` first.");
       process.exit(1);
     }
-    const configPath = path6.resolve("lumio.config.json");
-    if (!fs6.existsSync(configPath)) {
+    const configPath = path14.resolve("lumio.config.json");
+    if (!fs13.existsSync(configPath)) {
       console.error("lumio.config.json not found.");
       process.exit(1);
     }
-    const config = parseConfigFile(fs6.readFileSync(configPath, "utf-8"));
+    const config = parseConfigFile(fs13.readFileSync(configPath, "utf-8"));
     const client = new LumioApiClient(store.getApiUrl(), token);
     try {
       const versions = await client.get(
@@ -1535,8 +4202,8 @@ function registerStatus(program2) {
 }
 
 // src/commands/logs.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 function registerLogs(program2) {
   program2.command("logs").description("Stream server function logs via SSE").option("-f, --follow", "Follow log output", true).option("-n, --lines <count>", "Number of recent lines", "50").action(async (options) => {
     const store = new CredentialStore();
@@ -1545,12 +4212,12 @@ function registerLogs(program2) {
       console.error("Not logged in. Run `lumio login` first.");
       process.exit(1);
     }
-    const configPath = path7.resolve("lumio.config.json");
-    if (!fs7.existsSync(configPath)) {
+    const configPath = path15.resolve("lumio.config.json");
+    if (!fs14.existsSync(configPath)) {
       console.error("lumio.config.json not found.");
       process.exit(1);
     }
-    const config = parseConfigFile(fs7.readFileSync(configPath, "utf-8"));
+    const config = parseConfigFile(fs14.readFileSync(configPath, "utf-8"));
     const apiUrl = store.getApiUrl();
     const logsUrl = `${apiUrl}/v1/developer/extensions/${config.extensionId}/logs?lines=${options.lines}`;
     console.log(`Streaming logs for ${config.name}...`);
@@ -1587,22 +4254,31 @@ function registerLogs(program2) {
 }
 
 // src/commands/env.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs15 from "fs";
+import * as path16 from "path";
+var MAX_SECRET_KEY_LEN = 64;
+var MAX_SECRET_VALUE_BYTES = 4096;
 function validateSecretKey(key) {
-  return key.length > 0 && /^[A-Z0-9_]+$/.test(key);
+  return /^[A-Z0-9_]{1,64}$/.test(key);
+}
+function validateSecretValue(value) {
+  const bytes = Buffer.byteLength(value, "utf8");
+  return bytes > 0 && bytes <= MAX_SECRET_VALUE_BYTES;
+}
+function secretEndpoint(extensionId, key) {
+  return `/v1/developer/extensions/${extensionId}/secrets/${encodeURIComponent(key)}`;
 }
 function formatSecretList(secrets) {
   if (secrets.length === 0) return "No secrets configured.";
   return secrets.map((s) => `  ${s.key}  (created ${s.created_at})`).join("\n");
 }
 function loadConfig() {
-  const configPath = path8.resolve("lumio.config.json");
-  if (!fs8.existsSync(configPath)) {
+  const configPath = path16.resolve("lumio.config.json");
+  if (!fs15.existsSync(configPath)) {
     console.error("lumio.config.json not found. Run `lumio init` first.");
     process.exit(1);
   }
-  return parseConfigFile(fs8.readFileSync(configPath, "utf-8"));
+  return parseConfigFile(fs15.readFileSync(configPath, "utf-8"));
 }
 function requireClient() {
   const store = new CredentialStore();
@@ -1615,10 +4291,10 @@ function requireClient() {
 }
 function registerEnv(program2) {
   const envCmd = program2.command("env").description("Manage server-side secrets for the extension");
-  envCmd.command("set <key> [value]").description("Set a secret (POST /v1/developer/extensions/{id}/secrets). Omit <value> to be prompted (hidden) or read it from the LUMIO_SECRET env var \u2014 avoids leaking the secret into shell history / the process list.").action(async (key, value) => {
+  envCmd.command("set <key> [value]").description("Set a secret (PUT /v1/developer/extensions/{id}/secrets/{key}). Omit <value> to be prompted (hidden) or read it from the LUMIO_SECRET env var \u2014 avoids leaking the secret into shell history / the process list.").action(async (key, value) => {
     if (!validateSecretKey(key)) {
       console.error(
-        "Invalid key format. Use uppercase letters, numbers, and underscores only (e.g. API_KEY)."
+        `Secret key must match ^[A-Z0-9_]{1,${MAX_SECRET_KEY_LEN}}$ (uppercase letters, digits, underscores; e.g. API_KEY).`
       );
       process.exit(1);
     }
@@ -1633,9 +4309,13 @@ function registerEnv(program2) {
       }]);
       secretValue = answer.value;
     }
+    if (!validateSecretValue(secretValue)) {
+      console.error(`Secret value must be between 1 and ${MAX_SECRET_VALUE_BYTES} bytes.`);
+      process.exit(1);
+    }
     const config = loadConfig();
     const client = requireClient();
-    await client.post(`/v1/developer/extensions/${config.extensionId}/secrets`, { key, value: secretValue });
+    await client.put(secretEndpoint(config.extensionId, key), { value: secretValue });
     console.log(`Secret ${key} set.`);
   });
   envCmd.command("list").description("List all secrets (keys only, no values)").action(async () => {
@@ -1649,14 +4329,14 @@ function registerEnv(program2) {
   envCmd.command("delete <key>").description("Delete a secret").action(async (key) => {
     const config = loadConfig();
     const client = requireClient();
-    await client.delete(`/v1/developer/extensions/${config.extensionId}/secrets/${encodeURIComponent(key)}`);
+    await client.delete(secretEndpoint(config.extensionId, key));
     console.log(`Secret ${key} deleted.`);
   });
 }
 
 // src/commands/run.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs16 from "fs";
+import * as path17 from "path";
 var VALID_FUNCTION_TYPES = [
   "query",
   "mutation",
@@ -1693,12 +4373,12 @@ function parseFunctionRef(ref) {
 function registerRun(program2) {
   program2.command("run <type:name> [args]").description("Execute a server function locally (e.g. lumio run query:getPlayers)").option("--user <name>", "Mock user name for bot handlers", "testuser").option("--role <role>", "Mock user role for bot handlers", "everyone").option("--message <text>", "Mock chat message for bot handlers").option("--platform <platform>", "Mock platform for bot handlers", "twitch").action(async (typeAndName, argsJson, options) => {
     const fnRef = parseFunctionRef(typeAndName);
-    const configPath = path9.resolve("lumio.config.json");
-    if (!fs9.existsSync(configPath)) {
+    const configPath = path17.resolve("lumio.config.json");
+    if (!fs16.existsSync(configPath)) {
       console.error("lumio.config.json not found. Run `lumio init` first.");
       process.exit(1);
     }
-    const config = parseConfigFile(fs9.readFileSync(configPath, "utf-8"));
+    const config = parseConfigFile(fs16.readFileSync(configPath, "utf-8"));
     const store = new CredentialStore();
     const token = store.getToken();
     if (!token) {
@@ -1747,16 +4427,16 @@ function registerRun(program2) {
 }
 
 // src/commands/dashboard.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 function registerDashboard(program2) {
   program2.command("dashboard").description("Open the extension dashboard in browser").action(async () => {
-    const configPath = path10.resolve("lumio.config.json");
-    if (!fs10.existsSync(configPath)) {
+    const configPath = path18.resolve("lumio.config.json");
+    if (!fs17.existsSync(configPath)) {
       console.error("lumio.config.json not found. Run `lumio init` first.");
       process.exit(1);
     }
-    const config = parseConfigFile(fs10.readFileSync(configPath, "utf-8"));
+    const config = parseConfigFile(fs17.readFileSync(configPath, "utf-8"));
     const baseUrl = process.env.LUMIO_WEB_URL ?? "https://lumio.vision";
     const url = `${baseUrl}/dashboard/extensions/${config.extensionId}`;
     console.log(`Opening ${url}...`);
@@ -1767,10 +4447,10 @@ function registerDashboard(program2) {
 
 // src/program.ts
 function createProgram() {
-  const program2 = new Command();
+  const program2 = new Command2();
   program2.name("lumio");
   program2.description("Lumio Extension CLI -- Build, test, and deploy Lumio extensions");
-  const require2 = createRequire2(import.meta.url);
+  const require2 = createRequire3(import.meta.url);
   const { version } = require2("../package.json");
   program2.version(version);
   registerLogin(program2);
@@ -1778,6 +4458,7 @@ function createProgram() {
   registerWhoami(program2);
   registerInit(program2);
   registerDev(program2);
+  registerTrigger(program2);
   registerBuild(program2);
   registerDeploy(program2);
   registerStatus(program2);