theokit 0.74.5 → 0.75.0

package/dist/{dev-TW6QD7F3.js → dev-J2XZIENF.js}

@@ -11,12 +11,12 @@ import {
 } from "./chunk-KTMQUYED.js";
 import {
   theoPluginAsync
-} from "./chunk-XUAWD5HK.js";
-import "./chunk-VD3BCME6.js";
+} from "./chunk-RKRFJRJ3.js";
+import "./chunk-I5PDEWZZ.js";
 import "./chunk-BDH5GKFZ.js";
 import "./chunk-3PWQQWT6.js";
 import "./chunk-FDOOBTXJ.js";
-import "./chunk-DA3GGICE.js";
+import "./chunk-RQKMY3JW.js";
 import "./chunk-BINRCILF.js";
 import "./chunk-FNJVSFEC.js";
 import "./chunk-WSMLSIS5.js";
@@ -24,17 +24,17 @@ import "./chunk-MX63AWEK.js";
 import "./chunk-C27VRUVN.js";
 import "./chunk-7UZZHCRN.js";
 import "./chunk-47MM2JUK.js";
-import "./chunk-WR5B2XNT.js";
-import "./chunk-HKF6YNY4.js";
+import "./chunk-FNAEKJHO.js";
+import "./chunk-FU3LEX2I.js";
 import "./chunk-4WP7A7RX.js";
 import "./chunk-Z7CJHDLS.js";
 import {
   loadConfig
-} from "./chunk-VOXLI66L.js";
+} from "./chunk-OZB2TKGJ.js";
 import {
   loadEnv
 } from "./chunk-3QPVEJ7D.js";
-import "./chunk-U5PWXS3J.js";
+import "./chunk-O5JZ6ROY.js";
 import "./chunk-NX3P5MLH.js";
 import {
   orchestrateDev
@@ -128,4 +128,4 @@ export {
   devCommand,
   startDevServer
 };
-//# sourceMappingURL=dev-TW6QD7F3.js.map
+//# sourceMappingURL=dev-J2XZIENF.js.map

package/dist/{dev-emit-T3X6RR7M.js → dev-emit-AXTJK56H.js}

@@ -1,7 +1,7 @@
 import {
   generateManifest
-} from "./chunk-V7ISZGNS.js";
-import "./chunk-6R5F5YF2.js";
+} from "./chunk-7HGZ3CKL.js";
+import "./chunk-A6UFN6QQ.js";
 import "./chunk-DV34VG3N.js";
 import "./chunk-SOYOYGWY.js";
 import "./chunk-ZWN3AODA.js";
@@ -339,4 +339,4 @@ export {
   _resetInFlightForTests,
   reEmitOpenApi
 };
-//# sourceMappingURL=dev-emit-T3X6RR7M.js.map
+//# sourceMappingURL=dev-emit-AXTJK56H.js.map

package/dist/{dev-emit-ZK5GCHXN.js → dev-emit-XAPVJBM4.js}

@@ -6,8 +6,8 @@ import {
 } from "./chunk-47VNWTL4.js";
 import {
   generateManifest
-} from "./chunk-WR5B2XNT.js";
-import "./chunk-HKF6YNY4.js";
+} from "./chunk-FNAEKJHO.js";
+import "./chunk-FU3LEX2I.js";
 import "./chunk-4WP7A7RX.js";
 import "./chunk-Z7CJHDLS.js";
 
@@ -41,4 +41,4 @@ export {
   _resetInFlightForTests,
   reEmitOpenApi
 };
-//# sourceMappingURL=dev-emit-ZK5GCHXN.js.map
+//# sourceMappingURL=dev-emit-XAPVJBM4.js.map

package/dist/{generate-EN6EDITF.js → generate-RW3NO3NR.js}

@@ -1,9 +1,41 @@
 #!/usr/bin/env node
 import "tsx/esm";
+import {
+  cronScanDirs,
+  isDiscoverableCronFile,
+  listCronFiles
+} from "./chunk-IWIRHUNV.js";
+import {
+  findAgentFile
+} from "./chunk-FU3LEX2I.js";
+import "./chunk-Z7CJHDLS.js";
+import {
+  loadConfig
+} from "./chunk-OZB2TKGJ.js";
+import "./chunk-3QPVEJ7D.js";
+import "./chunk-O5JZ6ROY.js";
+import "./chunk-NX3P5MLH.js";
+import "./chunk-L4V5V2TI.js";
+import "./chunk-D2R5SJEL.js";
 
 // src/cli/commands/generate.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve2, dirname as dirname2 } from "path";
+import { resolve as resolve4, dirname as dirname3 } from "path";
+
+// src/cli/commands/generate-containment.ts
+import { isAbsolute, relative, resolve, sep } from "path";
+function isPathInside(cwd, filePath) {
+  if (filePath.includes("\0")) return false;
+  const fromRoot = relative(resolve(cwd), filePath);
+  return fromRoot !== "" && !isAbsolute(fromRoot) && fromRoot.split(sep)[0] !== "..";
+}
+function pathTraversalRefusal(cwd, filePath) {
+  if (isPathInside(cwd, filePath)) return void 0;
+  return {
+    status: "invalid_name",
+    message: `Path traversal denied: "${filePath}" is outside the project root ${resolve(cwd)}.`
+  };
+}
 
 // src/cli/commands/generate-policy-placeholder.ts
 var UNDECIDED_POLICY_IDENT = "undecidedPolicy";
@@ -25,7 +57,7 @@ function undecidedPolicyDeclaration(routePath, what) {
 
 // src/cli/commands/generate-resource.ts
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { resolve, dirname } from "path";
+import { resolve as resolve2, dirname } from "path";
 var ALLOWED_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "text", "number", "boolean"]);
 var RESERVED_FIELDS = /* @__PURE__ */ new Set(["id", "createdAt", "created_at"]);
 function parseResourceFields(args) {
@@ -205,10 +237,10 @@ function generateResource(cwd, name, fieldArgs) {
   } catch (err) {
     return { status: "invalid_name", message: err instanceof Error ? err.message : String(err) };
   }
-  const schemaPath = resolve(cwd, "server/db/schema.ts");
-  const routeIndexPath = resolve(cwd, `server/routes/${name}/index.ts`);
-  const routeIdPath = resolve(cwd, `server/routes/${name}/[id].ts`);
-  const testPath = resolve(cwd, `tests/${name}.test.ts`);
+  const schemaPath = resolve2(cwd, "server/db/schema.ts");
+  const routeIndexPath = resolve2(cwd, `server/routes/${name}/index.ts`);
+  const routeIdPath = resolve2(cwd, `server/routes/${name}/[id].ts`);
+  const testPath = resolve2(cwd, `tests/${name}.test.ts`);
   if (!existsSync(schemaPath)) {
     return {
       status: "not_a_project",
@@ -239,6 +271,133 @@ function generateResource(cwd, name, fieldArgs) {
   return { status: "created", filePath: routeIndexPath, kind: "resource", name };
 }
 
+// src/cli/commands/generate-schedule.ts
+import { basename, dirname as dirname2, extname, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+
+// src/server/cron/define-cron.ts
+var NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var CRON_NAME_RULE = "Must be 1-64 chars, lowercase alphanumeric + hyphen, starting with [a-z0-9].";
+function isValidCronName(name) {
+  return typeof name === "string" && NAME_RE.test(name);
+}
+
+// src/cli/commands/generate-schedule.ts
+async function resolveScheduleTarget(cwd, name) {
+  const malformed = cronNameRefusal(name);
+  if (malformed !== void 0) return malformed;
+  let config;
+  try {
+    config = await loadConfig(cwd);
+  } catch (err) {
+    return {
+      status: "invalid_config",
+      message: `Cannot read ${resolve3(cwd, "theo.config.ts")}: ${err.message}`
+    };
+  }
+  const { agentsDir, serverDir } = config;
+  const agentsRoot = resolve3(cwd, agentsDir);
+  const cronDirs = cronScanDirs(cwd, serverDir, agentsDir);
+  const filePath = resolve3(cronDirs.schedules, `${name}.ts`);
+  const escaped = pathTraversalRefusal(cwd, filePath);
+  if (escaped !== void 0) return escaped;
+  const chatPath = findAgentFile(agentsRoot, "chat");
+  if (chatPath === void 0) {
+    return {
+      status: "agent_not_found",
+      message: `No "chat" agent in ${agentsRoot} (the build serves it from chat.{ts,tsx,js,jsx} or chat/index.{ts,tsx,js,jsx}). A schedule runs the chat agent; create it first.`
+    };
+  }
+  const taken = cronNameTaken(name, filePath, [cronDirs.crons, cronDirs.schedules]);
+  if (taken !== void 0) return taken;
+  return { filePath, content: generateScheduleTemplate(name, importSpecifier(filePath, chatPath)) };
+}
+function cronNameOf(name) {
+  return name.split("/").pop() ?? name;
+}
+function cronNameRefusal(name) {
+  const cronName = cronNameOf(name);
+  if (!isDiscoverableCronFile(`${cronName}.ts`)) {
+    return {
+      status: "invalid_name",
+      message: `Invalid schedule name "${name}": the build does not discover a cron file named "${cronName}.ts".`
+    };
+  }
+  if (!isValidCronName(cronName)) {
+    return {
+      status: "invalid_name",
+      message: `Invalid schedule name "${name}": its cron name "${cronName}" is one defineCron rejects. ${CRON_NAME_RULE}`
+    };
+  }
+  return void 0;
+}
+function cronNameTaken(name, filePath, cronDirs) {
+  const cronName = cronNameOf(name);
+  const clash = listCronFiles(cronDirs).find(
+    (path) => path !== filePath && basename(path, extname(path)) === cronName
+  );
+  if (clash === void 0) return void 0;
+  return {
+    status: "invalid_name",
+    message: `Invalid schedule name "${name}": the cron name "${cronName}" is already used by ${clash}. Cron names must be unique across server/crons/ and agents/schedules/.`
+  };
+}
+function importSpecifier(fromFile, toFile) {
+  const path = relative2(dirname2(fromFile), toFile).split(sep2).join("/").replace(/\.tsx?$/, ".js");
+  return path.startsWith(".") ? path : `./${path}`;
+}
+function generateScheduleTemplate(name, chatSpecifier) {
+  const base = cronNameOf(name);
+  return [
+    `import { defineCron } from 'theokit/server/cron'`,
+    `import { resolveProvider } from 'theokit/server/agent'`,
+    `import { streamAgentTurnInProcess } from '@theokit/agents'`,
+    ``,
+    `import chat from '${chatSpecifier}'`,
+    ``,
+    `/**`,
+    ` * A scheduled agent run, a first-class TheoKit cron. \`theokit build\` discovers it and translates the`,
+    ` * schedule to your deploy target's native cron; \`theokit start\` runs it in-process.`,
+    ` *`,
+    ` * Each fire is one model run of your \`chat\` agent, so it spends tokens. Nobody is present to approve`,
+    ` * a gated tool, so the run uses the \`auto-reject\` posture: every approval is answered "no" and the`,
+    ` * gated tool does not run.`,
+    ` *`,
+    ` * Schedules are UTC (https://crontab.guru). \`signal\` aborts when the scheduler stops.`,
+    ` */`,
+    `export default defineCron('${base}', {`,
+    `  schedule: '0 9 * * *', // every day at 09:00 UTC`,
+    `  async handler({ traceId, scheduledAt, signal }) {`,
+    `    let outcome = 'ok'`,
+    `    try {`,
+    `      const agent = chat as { model?: string; plugins?: readonly unknown[] }`,
+    `      const { apiKey } = resolveProvider(agent.model, { plugins: agent.plugins })`,
+    `      const run = streamAgentTurnInProcess(chat, apiKey, {`,
+    `        message: \`Scheduled run "${base}" at \${scheduledAt.toISOString()}\`,`,
+    `        signal,`,
+    `        approvals: {`,
+    `          kind: 'auto-reject',`,
+    `          reason: 'unattended schedule "${base}": nobody is present to approve',`,
+    `        },`,
+    `      })`,
+    `      for await (const chunk of run) {`,
+    `        // The SDK can report a failed run as a chunk rather than a rejection.`,
+    `        if (chunk.type === 'error') {`,
+    `          throw new Error(\`[${base}] agent run failed: \${chunk.errorText ?? 'no error text'}\`)`,
+    `        }`,
+    `      }`,
+    `    } catch (err) {`,
+    `      outcome = \`failed: \${err instanceof Error ? err.message : String(err)}\``,
+    `      throw err`,
+    `    } finally {`,
+    `      // One traced line per fire, failed fires included: the scheduler's own error line has no trace id.`,
+    `      console.log(\`[${base}] fire \${outcome} at \${scheduledAt.toISOString()} (trace \${traceId})\`)`,
+    `    }`,
+    `  },`,
+    `})`,
+    ``
+  ].join("\n");
+}
+
 // src/cli/commands/generate-types.ts
 var VALID_TYPES = [
   "route",
@@ -268,16 +427,8 @@ var RESERVED_BASENAMES = /* @__PURE__ */ new Set([
   "hasOwnProperty"
 ]);
 function hasReservedSegment(name) {
-  const basename = name.includes("/") ? name.split("/").pop() ?? name : name;
-  return RESERVED_BASENAMES.has(basename);
-}
-function isPathInside(cwd, targetSubpath) {
-  if (targetSubpath.includes("\0")) return false;
-  if (targetSubpath.startsWith("/") || targetSubpath.startsWith("\\")) return false;
-  const resolved = resolve2(cwd, targetSubpath);
-  const cwdResolved = resolve2(cwd);
-  const sep = process.platform === "win32" ? "\\" : "/";
-  return resolved === cwdResolved || resolved.startsWith(cwdResolved + sep);
+  const basename2 = name.includes("/") ? name.split("/").pop() ?? name : name;
+  return RESERVED_BASENAMES.has(basename2);
 }
 function toPascalCase(name) {
   return name.split(/[-/]/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
@@ -439,30 +590,6 @@ function generateSandboxTemplate(name) {
     ``
   ].join("\n");
 }
-function generateScheduleTemplate(name) {
-  const base = name.split("/").pop() ?? name;
-  return [
-    `import { defineCron } from 'theokit/server/cron'`,
-    ``,
-    `/**`,
-    ` * A scheduled agent run \u2014 a first-class TheoKit cron. \`theokit build\` discovers it automatically and`,
-    ` * translates the schedule to your deploy target's native cron (Vercel / Cloudflare / AWS). No manual`,
-    ` * scheduler to start. The handler is where you invoke your agent \u2014 POST to \`/api/agents/chat\`, or use`,
-    ` * \`@theokit/sdk\`'s \`Agent\` with the same model + system prompt as \`agents/chat.ts\`.`,
-    ` *`,
-    ` * Schedules are UTC (https://crontab.guru). \`signal\` aborts when the scheduler stops.`,
-    ` */`,
-    `export default defineCron('${base}', {`,
-    `  schedule: '0 9 * * *', // every day at 09:00 UTC`,
-    `  async handler({ traceId, scheduledAt, signal }) {`,
-    `    void signal`,
-    `    // Invoke your agent here \u2014 e.g. fetch your own \`/api/agents/chat\` endpoint, or call the SDK Agent.`,
-    `    console.log(\`[${base}] fired at \${scheduledAt.toISOString()} (trace \${traceId})\`)`,
-    `  },`,
-    `})`,
-    ``
-  ].join("\n");
-}
 function generateMemoryTemplate(_name) {
   return [
     `/**`,
@@ -482,71 +609,32 @@ function generateMemoryTemplate(_name) {
     ``
   ].join("\n");
 }
-function resolveTemplate(cwd, type, name) {
-  switch (type) {
-    // Agent-capability generators. These live UNDER `agents/` — they are facets of the agent domain,
-    // not standalone top-level concerns — and the folder-semantic scanner treats each as composition
-    // (never a phantom route).
-    case "workflow":
-      return {
-        filePath: resolve2(cwd, "agents/workflows", `${name}.ts`),
-        content: generateWorkflowTemplate(name)
-      };
-    case "eval":
-      return {
-        filePath: resolve2(cwd, "agents/evals", `${name}.ts`),
-        content: generateEvalTemplate(name)
-      };
-    case "sandbox":
-      return {
-        filePath: resolve2(cwd, "agents/sandbox", `${name}.ts`),
-        content: generateSandboxTemplate(name)
-      };
-    case "schedule":
-      return {
-        filePath: resolve2(cwd, "agents/schedules", `${name}.ts`),
-        content: generateScheduleTemplate(name)
-      };
-    case "memory":
-      return {
-        filePath: resolve2(cwd, "agents/memory", `${name}.ts`),
-        content: generateMemoryTemplate(name)
-      };
-    case "route":
-      return {
-        filePath: resolve2(cwd, "server/routes", `${name}.ts`),
-        content: generateRouteTemplate(name)
-      };
-    case "action":
-      return {
-        filePath: resolve2(cwd, "server/actions", `${name}.ts`),
-        content: generateActionTemplate(name)
-      };
-    case "page":
-      return { filePath: resolve2(cwd, `app/${name}/page.tsx`), content: generatePageTemplate(name) };
-    case "ws":
-      return {
-        filePath: resolve2(cwd, "server/ws", `${name}.ts`),
-        content: generateWsTemplate(name)
-      };
-    case "controller":
-      return {
-        filePath: resolve2(cwd, "server/controllers", `${name}.controller.ts`),
-        content: generateControllerTemplate(name)
-      };
-    case "agent":
-      return {
-        filePath: resolve2(cwd, "server/agents", `${name}.agent.ts`),
-        content: generateAgentTemplate(name)
-      };
-    case "toolbox":
-      return {
-        filePath: resolve2(cwd, "server/toolboxes", `${name}.tools.ts`),
-        content: generateToolboxTemplate(name)
-      };
-    default:
-      return null;
+var SINGLE_FILE_KINDS = {
+  // Agent-capability generators. These live UNDER `agents/` — they are facets of the agent domain,
+  // not standalone top-level concerns — and the folder-semantic scanner treats each as composition
+  // (never a phantom route).
+  workflow: { path: (name) => `agents/workflows/${name}.ts`, template: generateWorkflowTemplate },
+  eval: { path: (name) => `agents/evals/${name}.ts`, template: generateEvalTemplate },
+  sandbox: { path: (name) => `agents/sandbox/${name}.ts`, template: generateSandboxTemplate },
+  memory: { path: (name) => `agents/memory/${name}.ts`, template: generateMemoryTemplate },
+  route: { path: (name) => `server/routes/${name}.ts`, template: generateRouteTemplate },
+  action: { path: (name) => `server/actions/${name}.ts`, template: generateActionTemplate },
+  page: { path: (name) => `app/${name}/page.tsx`, template: generatePageTemplate },
+  ws: { path: (name) => `server/ws/${name}.ts`, template: generateWsTemplate },
+  controller: {
+    path: (name) => `server/controllers/${name}.controller.ts`,
+    template: generateControllerTemplate
+  },
+  agent: { path: (name) => `server/agents/${name}.agent.ts`, template: generateAgentTemplate },
+  toolbox: {
+    path: (name) => `server/toolboxes/${name}.tools.ts`,
+    template: generateToolboxTemplate
   }
+};
+function resolveTemplate(cwd, kind, name) {
+  const spec = SINGLE_FILE_KINDS[kind];
+  if (spec === void 0) return null;
+  return { filePath: resolve4(cwd, spec.path(name)), content: spec.template(name) };
 }
 function generateActionTestTemplate(name) {
   const camel = toCamelCase(name);
@@ -588,15 +676,17 @@ function generateWsTemplate(_name) {
     ``
   ].join("\n");
 }
-async function generate(opts) {
-  const { cwd, type, name } = opts;
-  if (!existsSync2(resolve2(cwd, "theo.config.ts")) && !existsSync2(resolve2(cwd, "theo.config.js"))) {
+function isGeneratorType(value) {
+  return VALID_TYPES.includes(value);
+}
+function refuseOptions({ cwd, type, name }) {
+  if (!existsSync2(resolve4(cwd, "theo.config.ts")) && !existsSync2(resolve4(cwd, "theo.config.js"))) {
     return {
       status: "not_a_project",
       message: "Not a Theo project. cwd has no theo.config.ts or theo.config.js"
     };
   }
-  if (!VALID_TYPES.includes(type)) {
+  if (!isGeneratorType(type)) {
     return {
       status: "invalid_kind",
       message: `Invalid generator type "${type}". Available: ${VALID_TYPES.join(", ")}`
@@ -605,7 +695,7 @@ async function generate(opts) {
   if (!name || !toKebabCase(name)) {
     return {
       status: "invalid_name",
-      message: `Invalid name "${name}". Use kebab-case: lowercase letters, numbers, hyphens.`
+      message: `Invalid name "${name}". Use kebab-case: lowercase letters, numbers, hyphens. Example: my-route`
     };
   }
   if (hasReservedSegment(name)) {
@@ -614,25 +704,21 @@ async function generate(opts) {
       message: `Reserved name "${name}" \u2014 basename collides with built-in identifier (index/constructor/__proto__/prototype/hasOwnProperty).`
     };
   }
-  if (type === "resource") {
-    return generateResource(cwd, name, opts.fields ?? []);
-  }
-  const resolved = resolveTemplate(cwd, type, name);
-  if (resolved === null) {
-    return { status: "invalid_kind", message: `Unknown type: ${type}` };
-  }
-  const { filePath, content } = resolved;
-  const relativeFromCwd = filePath.startsWith(resolve2(cwd)) ? filePath.slice(resolve2(cwd).length + 1) : filePath;
-  if (!isPathInside(cwd, relativeFromCwd)) {
-    return {
-      status: "invalid_name",
-      message: `Path traversal denied: "${name}" would escape project root.`
-    };
-  }
+  return void 0;
+}
+async function resolveTarget(cwd, type, name) {
+  if (type === "schedule") return resolveScheduleTarget(cwd, name);
+  const target = resolveTemplate(cwd, type, name);
+  if (target === null) return { status: "invalid_kind", message: `Unknown type: ${type}` };
+  return target;
+}
+function writeTarget(cwd, type, name, { filePath, content }) {
+  const escaped = pathTraversalRefusal(cwd, filePath);
+  if (escaped !== void 0) return escaped;
   if (existsSync2(filePath)) {
     return { status: "already_exists", filePath, kind: type, name };
   }
-  mkdirSync2(dirname2(filePath), { recursive: true });
+  mkdirSync2(dirname3(filePath), { recursive: true });
   writeFileSync2(filePath, content);
   if (type === "action") {
     const testPath = filePath.replace(/\.ts$/, ".test.ts");
@@ -642,31 +728,43 @@ async function generate(opts) {
   }
   return { status: "created", filePath, kind: type, name };
 }
+async function generate(opts) {
+  const refused = refuseOptions(opts);
+  if (refused !== void 0) return refused;
+  const { cwd, name } = opts;
+  const kind = opts.type;
+  if (kind === "resource") {
+    return generateResource(cwd, name, opts.fields ?? []);
+  }
+  const resolved = await resolveTarget(cwd, kind, name);
+  if ("status" in resolved) return resolved;
+  return writeTarget(cwd, kind, name, resolved);
+}
+var CLI_REFUSALS = {
+  not_a_project: () => "Not a Theo project. Run this from a project root with theo.config.ts",
+  invalid_kind: (result) => result.message ?? "Invalid kind",
+  // `generate` returns invalid_name for a malformed name, a reserved name and a path that
+  // resolves outside the project; each message says which, so the CLI must not replace it.
+  invalid_name: (result, name) => result.message ?? `Invalid name "${name}"`,
+  invalid_config: (result) => result.message ?? "Invalid theo.config.ts",
+  agent_not_found: (result) => result.message ?? "No chat agent found"
+};
 async function generateCommand(type, name, fields) {
   const result = await generate({ cwd: process.cwd(), type, name, fields });
-  switch (result.status) {
-    case "not_a_project":
-      throw new Error("Not a Theo project. Run this from a project root with theo.config.ts");
-    case "invalid_kind":
-      throw new Error(result.message ?? "Invalid kind");
-    case "invalid_name":
-      throw new Error(
-        `Invalid name "${name}". Use kebab-case: lowercase letters, numbers, hyphens. Example: my-route`
-      );
-    case "already_exists":
-      console.log(`
+  if (result.status === "already_exists") {
+    console.log(`
   \u26A0 ${result.filePath} already exists. Skipping.
 `);
-      return;
-    case "created":
-      console.log(`
+  } else if (result.status === "created") {
+    console.log(`
   \u2713 Created ${type}: ${result.filePath}
 `);
-      return;
+  } else {
+    throw new Error(CLI_REFUSALS[result.status](result, name));
   }
 }
 export {
   generate,
   generateCommand
 };
-//# sourceMappingURL=generate-EN6EDITF.js.map
+//# sourceMappingURL=generate-RW3NO3NR.js.map