@koda-sl/baker-cli 0.532.0 → 0.534.0-dev.911a80433

package/dist/funnel-QEZWKSFR.js

@@ -0,0 +1,397 @@
+import {
+  FUNNEL_VERTICALS,
+  funnelRequestSchema
+} from "./chunk-LAL4PKNJ.js";
+import {
+  flowEventKeys
+} from "./chunk-CWZ2ODJQ.js";
+import {
+  flowDataPath,
+  listFlowSlugs
+} from "./chunk-5G5QFFJY.js";
+import {
+  parseEventKey
+} from "./chunk-PILLZPNC.js";
+import "./chunk-NKQWDEB7.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-LV7EU6HM.js";
+import "./chunk-DYOUJERF.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MUS2UTWU.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import {
+  registerSchema
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/funnel/index.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/funnel/formMoments.ts
+function offeredEndings(form) {
+  return flowEventKeys(form.tree, form.slug).filter((ending) => ending.isCompletion || ending.nodeId === null);
+}
+function formMoments(events, forms, counted) {
+  const endings = /* @__PURE__ */ new Map();
+  for (const form of forms) {
+    for (const ending of offeredEndings(form)) endings.set(ending.eventKey, { slug: form.slug, ending });
+  }
+  const known = events.map((event) => {
+    const found = endings.get(event.eventKey);
+    if (found === void 0) return event;
+    endings.delete(event.eventKey);
+    return { ...event, step: found.ending.nodeName };
+  });
+  const unfired = [...endings.values()].map(({ slug, ending }) => {
+    const countedAs = counted.get(ending.eventKey);
+    return {
+      eventKey: ending.eventKey,
+      origin: "site",
+      flowSlug: slug,
+      ...ending.nodeType === null ? {} : { nodeType: ending.nodeType },
+      events: 0,
+      sessions: 0,
+      step: ending.nodeName,
+      seen: false,
+      ...countedAs === void 0 ? {} : { countedAs }
+    };
+  });
+  return [...known, ...unfired];
+}
+function withFormMoments(moments, forms, counted) {
+  return { ...moments, events: formMoments(moments.events, forms, counted) };
+}
+function formsNamedHere(forms) {
+  return forms.filter((form) => flowEventKeys(form.tree, form.slug).length > 0).map((form) => form.slug);
+}
+function unplacedFormHints(steps, forms, counted) {
+  const onAStep = new Set(
+    steps.flatMap((step) => (step.triggers ?? []).flatMap((trigger) => trigger.eventKey ? [trigger.eventKey] : []))
+  );
+  const unplaced = [];
+  for (const form of forms) {
+    const endings = flowEventKeys(form.tree, form.slug);
+    if (endings.length === 0 || endings.some((ending) => onAStep.has(ending.eventKey))) continue;
+    const countedOn = endings.filter((ending) => counted.has(ending.eventKey));
+    unplaced.push(
+      countedOn.length === 0 ? form.slug : `${form.slug} (counted as ${countedOn.map((ending) => `"${counted.get(ending.eventKey)}" on \`${ending.eventKey}\``).join(", ")})`
+    );
+  }
+  if (unplaced.length === 0) return [];
+  return [
+    `${unplaced.length} Form(s) in this workspace reach no funnel step, so they move nobody along it however many people finish them: ${unplaced.join("; ")}. Which ending moves somebody to which step is your call: \`baker funnel --moments\` lists every Form's endings by the step each happens on, and when the step names do not make it obvious \u2014 a Form that branches into a rejection and a confirmation \u2014 ask the person which one means a lead or a customer. Place it with \`baker funnel --add-trigger <step> --event <key>\`. A Form already counted as a page conversion goes on the funnel by THAT SAME key, or the two numbers disagree for ever.`
+  ];
+}
+
+// src/commands/funnel/funnelArgs.ts
+var FunnelArgsError = class extends Error {
+  /** Structured remediation, in the shape the CLI's error envelope carries. */
+  fix;
+  constructor(message, fix) {
+    super(message);
+    this.name = "FunnelArgsError";
+    if (fix) {
+      this.fix = fix;
+    }
+  }
+};
+function parseFunnelArgs(raw) {
+  const steps = parseSteps(raw.steps);
+  const step = parseStep(raw.step);
+  const removeStep = parseRemoveStep(raw["remove-step"] ?? raw.removeStep);
+  const preset = parsePreset(raw.preset);
+  const addTrigger = parseWayIn(raw["add-trigger"] ?? raw.addTrigger, raw.event, "--add-trigger");
+  const removeTrigger = parseWayIn(raw["remove-trigger"] ?? raw.removeTrigger, raw.event, "--remove-trigger");
+  const doors = [steps, step, removeStep, preset, addTrigger, removeTrigger].filter(
+    (door) => door !== void 0
+  ).length;
+  if (doors > 1) {
+    throw new FunnelArgsError(
+      "Give one of --steps, --step, --remove-step, --preset, --add-trigger or --remove-trigger, not two."
+    );
+  }
+  const days = raw.days === void 0 ? void 0 : Number(raw.days);
+  if (days !== void 0 && (!Number.isInteger(days) || days <= 0 || days > 400)) {
+    throw new FunnelArgsError("--days must be a whole number of days, from 1 to 400.");
+  }
+  return {
+    ...steps === void 0 ? {} : { steps },
+    ...step === void 0 ? {} : { step },
+    ...removeStep === void 0 ? {} : { removeStep },
+    ...preset === void 0 ? {} : { preset },
+    ...addTrigger === void 0 ? {} : { addTrigger },
+    ...removeTrigger === void 0 ? {} : { removeTrigger },
+    templates: raw.templates === true,
+    moments: raw.moments === true,
+    ...days === void 0 ? {} : { days }
+  };
+}
+function funnelWrite(args2) {
+  const body = {
+    ...args2.steps === void 0 ? {} : { steps: args2.steps },
+    ...args2.step === void 0 ? {} : { step: args2.step },
+    ...args2.removeStep === void 0 ? {} : { removeStep: args2.removeStep },
+    ...args2.preset === void 0 ? {} : { preset: args2.preset },
+    ...args2.addTrigger === void 0 ? {} : { addTrigger: args2.addTrigger },
+    ...args2.removeTrigger === void 0 ? {} : { removeTrigger: args2.removeTrigger },
+    ...args2.templates ? { templates: true } : {},
+    ...args2.moments ? { moments: true } : {},
+    ...args2.days === void 0 ? {} : { days: args2.days }
+  };
+  const parsed = funnelRequestSchema.safeParse(body);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    throw new FunnelArgsError(
+      `That funnel cannot be sent \u2014 ${issue?.path.join(".") || "steps"}: ${issue?.message ?? "invalid"}`,
+      {
+        action: "read_the_schema",
+        explanation: "Run `baker schema funnel` for the exact shape of one step, or `baker funnel --templates` for sixteen worked examples plus every field an event carries."
+      }
+    );
+  }
+  return parsed.data;
+}
+function parseSteps(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw new FunnelArgsError("--steps takes a JSON array of steps.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new FunnelArgsError(`--steps is not valid JSON: ${cause instanceof Error ? cause.message : "parse failed"}`, {
+      action: "quote_the_json",
+      explanation: `Wrap the whole array in single quotes so the shell leaves the double quotes alone: --steps '[{"key":"lead",...}]'.`
+    });
+  }
+  if (!Array.isArray(parsed)) {
+    throw new FunnelArgsError("--steps takes an ARRAY of steps, even when the funnel has one step.");
+  }
+  refuseRetiredShapes(parsed);
+  return parsed;
+}
+function parseStep(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw new FunnelArgsError("--step takes one step as a JSON object.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new FunnelArgsError(`--step is not valid JSON: ${cause instanceof Error ? cause.message : "parse failed"}`, {
+      action: "quote_the_json",
+      explanation: `Wrap the object in single quotes so the shell leaves the double quotes alone: --step '{"key":"demo",...}'.`
+    });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new FunnelArgsError("--step takes ONE step as an object. To restate several, use --steps with an array.");
+  }
+  refuseRetiredShapes([parsed]);
+  return parsed;
+}
+function parseRemoveStep(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new FunnelArgsError("--remove-step takes the key of the step to take off, as `baker funnel` lists it.");
+  }
+  return raw.trim();
+}
+function refuseRetiredShapes(steps) {
+  for (const step of steps) {
+    if (typeof step !== "object" || step === null) continue;
+    const key = String(step.key ?? "?");
+    if ("offlineConversions" in step) {
+      throw new FunnelArgsError(`Step "${key}" puts sends on the step, and a send belongs to the conversion.`, {
+        action: "set_sends_on_the_conversion",
+        explanation: "Drop `offlineConversions`. Name the outcome with `baker analytics conversions`, then `baker analytics sends --set --conversion <name> --platform <p> --tag <tagId> --event <e>`; the step reads its conversions' sends back as `sends[]`."
+      });
+    }
+    const triggers = step.triggers;
+    if (!Array.isArray(triggers)) continue;
+    const kinds = triggers.map(
+      (trigger) => typeof trigger === "object" && trigger !== null ? trigger.kind : void 0
+    );
+    if (kinds.includes("analytics") || kinds.includes("conversion")) {
+      const word = kinds.includes("analytics") ? "analytics" : "conversion";
+      throw new FunnelArgsError(
+        `Step "${key}" has a \`${word}\` trigger, and a step is reached by an event or a landing only.`,
+        {
+          action: "use_an_event_trigger",
+          explanation: 'Pick the moment from `baker funnel --moments` and write it as `{"kind":"event","eventKey":"<from moments.events or moments.sources>"}` \u2014 nothing has to be named first. A landing is `{"kind":"landing","landingId":"<from moments.landings>"}`.'
+        }
+      );
+    }
+  }
+}
+function parsePreset(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || !FUNNEL_VERTICALS.includes(raw)) {
+    throw new FunnelArgsError(`--preset must be one of: ${FUNNEL_VERTICALS.join(", ")}`, {
+      action: "list_the_presets",
+      explanation: "Run `baker funnel --templates` to see what each preset contains before picking one."
+    });
+  }
+  return raw;
+}
+function parseWayIn(stepKey, eventKey, flag) {
+  if (stepKey === void 0) return void 0;
+  if (typeof stepKey !== "string" || stepKey.trim() === "") {
+    throw new FunnelArgsError(`${flag} takes the key of the step to change: \`${flag} lead\`.`);
+  }
+  if (typeof eventKey !== "string" || eventKey.trim() === "") {
+    throw new FunnelArgsError(`${flag} needs --event, naming what gets somebody there.`, {
+      action: "read_the_moments",
+      explanation: `Run \`baker funnel --moments\` and copy an \`events[].eventKey\` \u2014 a Form's own outcome is listed there at zero before anybody has filled it in. Then: \`${flag} ${stepKey.trim()} --event "<key>"\`.`
+    });
+  }
+  const key = eventKey.trim();
+  if (flag === "--add-trigger" && parseEventKey(key) === null) {
+    throw new FunnelArgsError(`"${key}" is not an event key, so nothing would ever reach that step through it.`, {
+      action: "read_the_moments",
+      explanation: "Run `baker funnel --moments` and copy an `events[].eventKey`. They look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or view:<landing>."
+    });
+  }
+  return { stepKey: stepKey.trim(), eventKey: key };
+}
+
+// src/commands/funnel/index.ts
+var args = {
+  steps: {
+    type: "string",
+    description: 'The WHOLE funnel, as a JSON array. One object per step: {"key":"meeting_held","displayName":"Demo held","stepClass":"engaged","after":["lead"],"triggers":[{"id":"t1","kind":"event","eventKey":"page:demo_held"}]}. It REPLACES the funnel rather than adding to it, so read first and restate everything you want to keep. `key` is permanent and reaches reporting and URLs (lowercase, digits, underscores); `displayName` is the client\'s own words and can be anything. `stepClass` is the stage, one of visited, lead, engaged, customer, repeat, lost \u2014 six plain words every business has, used to compare one company\'s funnel with another\'s. `after` is a LIST, so two ways into one step is expressible and normal. `triggers` is what MOVES somebody onto the step, any one of them being enough, and there are three kinds: `{"id":"t1","kind":"event","eventKey":"submit:contact"}` for anything the company\'s Forms, pages or systems produced, used by its own key with nothing named first; `{"id":"t2","kind":"landing","landingId":"<from --moments>"}` for one landing page being viewed; `{"id":"t3","kind":"any_landing"}` for any landing being viewed. Take every key and id from `--moments`. A trigger carries no amount: an event is worth what it says, and a step is worth the sum. Where a step SENDS its people is not written here: a send belongs to the system\'s event (`baker analytics sends`), and the step reads it back as `sends[]`',
+    required: false
+  },
+  step: {
+    type: "string",
+    description: 'ONE step as a JSON object, in the same shape as an entry of --steps. It is added to the funnel as it now stands, or replaces the step with the same `key`, and every other step is left exactly as it is \u2014 the door for adding or changing a stage without restating the rest. Example: --step \'{"key":"demo","displayName":"Demo held","stepClass":"engaged","after":["lead"],"triggers":[{"id":"t1","kind":"event","eventKey":"page:demo_held"}]}\'',
+    required: false
+  },
+  "add-trigger": {
+    type: "string",
+    description: 'The key of ONE step to add a way in to, with `--event` naming what gets somebody there: `--add-trigger lead --event "submit:contact"`. Start here for "this Form should count as a lead" \u2014 it adds that one way in and leaves the step\'s name, stage, `after[]` and every other trigger exactly as they are. Prefer it to `--step`, which takes a WHOLE step and therefore silently removes any trigger the restatement forgets. Adding a key the step already listens for changes nothing. Take the key from `--moments`, never from memory',
+    required: false
+  },
+  "remove-trigger": {
+    type: "string",
+    description: 'The key of ONE step to take a way in OFF, with `--event` naming which: `--remove-trigger lead --event "submit:contact"`. By event key rather than by trigger id, because the id is not something you ever saw. Everything else about the step is untouched',
+    required: false
+  },
+  event: {
+    type: "string",
+    description: "The event key `--add-trigger` or `--remove-trigger` acts on \u2014 an `events[].eventKey` from `--moments`, never invented. Every Form's endings are listed there by the step each happens on, at zero before anybody has filled the Form in; which one means the step is your decision",
+    required: false
+  },
+  "remove-step": {
+    type: "string",
+    description: "The key of one step to take off the funnel. Whatever came after it moves up to whatever came before it, so the chain stays joined. The response lists it under `removed`",
+    required: false
+  },
+  preset: {
+    type: "string",
+    description: `Draw one of the ready-made graphs instead of stating steps: b2b_sales, b2b_inbound, saas_self_serve, saas_sales_assisted, ecommerce_purchase. It draws over the whole funnel \u2014 every company already has one, so prefer --step to change a step. Run --templates first to see what each one contains. With a Shopify store connected, ecommerce_purchase comes wired to the store's own events (page:view_item, page:add_to_cart, page:begin_checkout, and page:purchase for a paid order); "Ordered again" stays unwired`,
+    required: false
+  },
+  moments: {
+    type: "boolean",
+    description: "Also return everything a trigger can name, so a trigger is PICKED rather than invented: `events` (every event this company's Forms, pages and systems produced in the window, with volume, the Form it belongs to, `origin` \u2014 `site` for a page or Form, `systems` for the client's own server, `both` \u2014 and `countedAs` when the company also counts it as a page conversion, which a trigger does not need; PLUS **every workspace Form's endings** \u2014 each step's completion and its `submit:` \u2014 with the `step` each happens on, at zero and `seen: false` until somebody fires one, so a Form built minutes ago is pickable with nothing set up first, and `countedAs` when the company already counts it. Nothing is marked as the outcome: which ending means a step is YOUR decision \u2014 read the step names, and ask the person when they do not make it obvious (a Form that branches into \u201CNot a fit\u201D and \u201CQuote confirmed\u201D). If the Form is already counted, use that same key, so the step and the conversion agree. `baker analytics conversions --flow <slug>` also lists a widget's housekeeping), `sources` (the client's own systems that post events to Baker, by the `page:<name>` key each raises, pickable before its first send arrives) and `landings` (its pages, by the id a `landing` trigger takes). Use this before writing any `triggers`: a key typed from memory saves, publishes and counts nobody forever. A Form's events need NOTHING set up first \u2014 no Source, no conversion: a Baker page raises them by itself",
+    required: false
+  },
+  days: {
+    type: "string",
+    description: "How many days the counts beside each step cover (default 30, up to 400). Every step comes back with `people` (reached it), `atLeast` (reached it or anything after it), `before` (got as far as the step before) and `share` (atLeast / before) \u2014 counted in PEOPLE across visits and devices, not in visits",
+    required: false
+  },
+  templates: {
+    type: "boolean",
+    description: "Also return the libraries: the suggested steps with their stages, the presets, and `stages[]` (the six stages with the test to apply). Where a step can be sent is not here \u2014 a send belongs to the system's event, and `baker analytics sends` lists the platforms and the tags that can send",
+    required: false
+  }
+};
+registerSchema({
+  command: "funnel",
+  description: "Read the company's funnel, or draw one",
+  args
+});
+var funnelCommand = defineCommand({
+  meta: {
+    name: "funnel",
+    description: 'Start here: run with no flags to see the funnel this company has, with the last 30 days of PEOPLE counted beside every step \u2014 `people` reached it, `atLeast` got at least that far, `before` got as far as the step before, `share` is the ratio, and `worstStep` names where the most people are lost. Every company has one from the day it exists: Visited (any landing) \u2192 Became a lead \u2192 Became a customer, the last two with no way in until somebody gives them one. Then `--moments` for everything a trigger can name (every event the company\'s Forms, pages and systems produced, its sources, its landings, plus each Form\'s own outcome at zero). **To make an event count on a step \u2014 the usual job \u2014 use `--add-trigger <step> --event <key>`:** it adds that one way in and touches nothing else about the step. `--step \'<json>\'` is for adding or renaming a STEP; it replaces the step with that key, so it means restating its `after` and every trigger it keeps, and one left out is gone. A step is reached by three kinds of thing and nothing else: an event by its own key (`{"id":"t1","kind":"event","eventKey":"<from moments.events or moments.sources>"}`), one landing being viewed (`{"id":"t2","kind":"landing","landingId":"<from moments.landings>"}`) or any landing (`{"id":"t3","kind":"any_landing"}`). Nothing has to be named first. Pick every trigger from `--moments`, never from memory. A step with no `triggers` advances NOBODY and reports zero forever without warning \u2014 that is what the hints keep pointing at. There is no default door: a Form is only counted where a trigger names it. Keep it true: a chat that adds a Form, a Source or an event that moves people forward places it on its step in the same chat. Each step comes back with `sends[]`, read-only: where the people who reach it are sent and what happened, read off the system events behind its ways in. A send is set on the event with `baker analytics sends`, never on a step, and once published it spends ad budget \u2014 a failed one is named in the hints. Everything here is STAGED: it becomes the company\'s funnel in one piece when the chat is published \u2014 the client sees it on the canvas in this chat and can edit it there too \u2014 and the previous version stays on file so what was already measured under it is not lost.'
+  },
+  args,
+  run: async ({ args: raw }) => {
+    try {
+      const parsed = parseFunnelArgs(raw);
+      const forms = workspaceForms();
+      const namedByCaller = formsNamedHere(forms);
+      const request = {
+        ...funnelWrite(parsed),
+        ...namedByCaller.length === 0 ? {} : { namedByCaller }
+      };
+      const response = await apiPost("/api/funnel", request);
+      const counted = new Map((response.data.counted ?? []).map((row) => [row.eventKey, row.name]));
+      const data = response.data.moments === void 0 ? response.data : { ...response.data, moments: withFormMoments(response.data.moments, forms, counted) };
+      const hints = [...response.hints ?? [], ...unplacedFormHints(response.data.steps ?? [], forms, counted)];
+      writeJsonEnvelope({
+        ok: true,
+        data,
+        ...hints.length > 0 ? { hints } : {}
+      });
+    } catch (err) {
+      handleError(err);
+    }
+  }
+});
+function handleError(err) {
+  if (err instanceof FunnelArgsError) {
+    writeJsonEnvelope({
+      ok: false,
+      error: { code: "VALIDATION_ERROR", message: err.message, ...err.fix ? { fix: err.fix } : {} }
+    });
+    process.exit(1);
+  }
+  if (err instanceof ApiError) {
+    writeJsonEnvelope({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  writeJsonEnvelope({
+    ok: false,
+    error: { code: "NETWORK_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+  });
+  process.exit(1);
+}
+function workspaceForms() {
+  const forms = [];
+  for (const slug of listFlowSlugs()) {
+    try {
+      forms.push({ slug, tree: JSON.parse(readFileSync(flowDataPath(slug), "utf-8")) });
+    } catch {
+    }
+  }
+  return forms;
+}
+export {
+  funnelCommand
+};
+//# sourceMappingURL=funnel-QEZWKSFR.js.map

package/dist/generate-HOMLLUCN.js

@@ -0,0 +1,263 @@
+import {
+  IMAGE_MODEL_IDS,
+  IMAGE_QUALITIES,
+  IMAGE_SIZES,
+  resolveLibraryImageIds
+} from "./chunk-Z3Y67AH6.js";
+import {
+  awaitBatch,
+  batchHints,
+  projectBatch,
+  resolveMaxWaitMs,
+  waitingHint
+} from "./chunk-6CQOHJZW.js";
+import {
+  failStudioCommand
+} from "./chunk-FESQ5TXU.js";
+import "./chunk-Z6T6VDDA.js";
+import "./chunk-PHZOMTI6.js";
+import {
+  DEFAULT_IMAGE_GENERATE_MODEL,
+  MODEL_REGISTRY,
+  canonicalModelId,
+  maxInputReferences
+} from "./chunk-F3CZFUXZ.js";
+import "./chunk-L763CNKH.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/studio/generate.ts
+import { defineCommand } from "citty";
+var MODEL_LIST = IMAGE_MODEL_IDS;
+var DEFAULT_MAX_WAIT_MS = 24e4;
+registerSchema({
+  command: "studio.generate",
+  description: "Start here to make an image. Opens a Studio batch: the images are ingested into the media library as they render and the whole batch shows up in the dashboard Studio for the client, labelled with this conversation. Default model google/gemini-3.1-flash-image \u2014 fast, reference editing, extreme aspect ratios. --reference is the biggest quality lever: pass library image ids, local file paths, and/or image URLs to ground the render in real imagery.",
+  args: {
+    prompt: {
+      type: "string",
+      description: "What to generate \u2014 full art direction, not a keyword. Length caps are per model (Recraft 10,000 characters, gpt-image 32,000, Gemini publishes none) and a --skill or --brand block counts toward them; `baker studio models` has the number.",
+      required: true
+    },
+    model: {
+      type: "string",
+      description: `Model (default google/gemini-3.1-flash-image). They accept genuinely different things \u2014 check with \`baker studio models\` rather than assuming. One of: ${MODEL_LIST.join(", ")}`,
+      required: false,
+      enum: MODEL_LIST
+    },
+    "aspect-ratio": {
+      type: "string",
+      // Snapped, not refused: ask for the ad shape you want and the backend
+      // moves it to the nearest one the chosen model renders (gpt-image-2 has no
+      // 4:5, so a 4:5 request becomes 3:4 rather than failing).
+      description: "Aspect ratio, e.g. 1:1 (default), 16:9, 9:16, 4:5, 3:2 \u2014 Gemini flash also does 1:4 / 8:1. Snapped to the nearest shape the chosen model renders, so ask for the ad format you want (4:5 on gpt-image-2 or Recraft becomes 3:4, neither renders it). Must be width:height.",
+      required: false
+    },
+    count: { type: "number", description: "Takes to render, 1-8 (default 1)", required: false, default: 1 },
+    avatar: {
+      type: "string",
+      description: "Cast one of the company's avatars by short name (e.g. marta). Grounds the render on their identity sheet and reuses their subject description verbatim \u2014 do this instead of passing the sheet through --reference, which skips both and leaves the batch unattributed. `baker avatars list` shows who there is.",
+      required: false
+    },
+    reference: {
+      type: "string",
+      description: "Comma-separated visual references, in order: library image ids, local file paths, and/or image URLs. Paths and URLs are added to the media library first, so the reference is reusable and the client can see what grounded the render. How many are allowed is per model \u2014 Gemini takes 14, gpt-image 16, Recraft exactly 1.",
+      required: false
+    },
+    skill: {
+      type: "string",
+      description: "Craft direction by id (run `baker studio skills`), e.g. product-pack-shot, ugc-selfie-hook",
+      required: false
+    },
+    brand: {
+      type: "boolean",
+      description: "Append the company palette and visual style. Off by default \u2014 you are writing the art direction yourself and a brand block appended after it fights what you just specified.",
+      required: false,
+      default: false
+    },
+    "image-size": {
+      type: "string",
+      // No default: left unset the provider picks the pixels from the ratio.
+      // gpt-image-2 has no resolution setting at all and REFUSES this flag.
+      description: `Output resolution \u2014 only on models that have one (gpt-image-2 and Recraft have none and REFUSE this). The tiers differ per model: Lite renders 1K only, Pro 1K-4K, Gemini flash also 0.5K. One of: ${IMAGE_SIZES.join(", ")}`,
+      required: false,
+      enum: IMAGE_SIZES
+    },
+    quality: {
+      type: "string",
+      description: `Rendering quality \u2014 the OpenAI models only; every Gemini tier and Recraft REFUSE it. One of: ${IMAGE_QUALITIES.join(", ")}`,
+      required: false,
+      enum: IMAGE_QUALITIES
+    },
+    strength: { type: "number", description: "Recraft vector only: vectorization strength 0-1", required: false },
+    "rgb-colors": {
+      type: "string",
+      description: 'Recraft only: JSON array of [r,g,b] palette triples, each channel a whole number 0-255, e.g. "[[10,10,10],[255,80,0]]"',
+      required: false
+    },
+    "bg-rgb": {
+      type: "string",
+      description: 'Recraft only: JSON [r,g,b] background colour, e.g. "[255,255,255]"',
+      required: false
+    },
+    wait: {
+      type: "string",
+      description: "Pass false to get the batch id back immediately instead of waiting for the takes",
+      required: false,
+      default: "true"
+    },
+    "max-wait": {
+      type: "number",
+      description: "Max ms to wait for the takes (default 240000). 0 returns the id immediately.",
+      required: false,
+      default: DEFAULT_MAX_WAIT_MS
+    },
+    full: { type: "boolean", description: "Include settings, references and attribution", required: false }
+  }
+});
+function parseJsonArg(raw, flag) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new ApiError("VALIDATION_ERROR", `--${flag} must be valid JSON (got: ${raw})`);
+  }
+}
+function referenceLimitFor(model) {
+  const chosen = model ?? DEFAULT_IMAGE_GENERATE_MODEL;
+  const max = maxInputReferences("image_generate", chosen);
+  if (max === void 0) return void 0;
+  const label = MODEL_REGISTRY.image_generate[canonicalModelId(chosen)]?.label ?? chosen;
+  return {
+    max,
+    refuse: (count) => max === 1 ? `${label} takes exactly one reference image \u2014 you passed ${count}. Pick the one that matters, or switch to a model that reads several.` : `${label} takes up to ${max} reference images \u2014 you passed ${count}. Drop the weakest ones.`
+  };
+}
+async function effectiveModel(pinned, skillId, fetchSkills = () => apiGet("/api/studio/skills")) {
+  if (pinned || !skillId) return pinned;
+  try {
+    const { skills } = await fetchSkills();
+    return skills.find((skill) => skill.id === skillId)?.defaults.model;
+  } catch {
+    return void 0;
+  }
+}
+function buildGenerateBody(args, prompt) {
+  const body = { prompt };
+  if (args.model) body.model = args.model;
+  if (args["aspect-ratio"]) body.aspectRatio = args["aspect-ratio"];
+  if (args.count !== void 0 && args.count !== "") body.count = Number(args.count);
+  if (args.avatar) body.avatar = args.avatar;
+  if (args.skill) body.skillId = args.skill;
+  if (args.brand) body.useBrand = true;
+  if (args["image-size"]) body.imageSize = args["image-size"];
+  if (args.quality) body.quality = args.quality;
+  if (args.strength !== void 0 && args.strength !== "") body.strength = Number(args.strength);
+  if (args["rgb-colors"]) {
+    body.rgbColors = parseJsonArg(args["rgb-colors"], "rgb-colors");
+  }
+  if (args["bg-rgb"]) {
+    body.backgroundRgbColor = parseJsonArg(
+      args["bg-rgb"],
+      "bg-rgb"
+    );
+  }
+  return body;
+}
+var generateCommand = defineCommand({
+  meta: {
+    name: "generate",
+    description: "Start here to make an image. Renders 1-8 takes of one brief, ingests each into the media library as it lands, and shows the batch in the dashboard Studio next to the ones the client ran.\n\nModel choice: google/gemini-3.1-flash-image (default \u2014 fast, best at editing a reference and at extreme ratios), google/gemini-3-pro-image (highest fidelity, slower), openai/gpt-image-2 (photoreal and the cleanest in-image text \u2014 no --image-size, no 4:5 / 5:4), recraft/recraft-v4.1-pro-vector (vector/flat marks with palette control).\n\n--reference is the biggest quality lever there is: a real logo, product shot, Pinterest pin or sandbox screenshot beats any amount of adjectives.\n\nExamples:\n  baker studio generate 'matte black bottle on wet marble, hard studio light, 35mm' --aspect-ratio 3:2 --count 3\n  baker studio generate 'this bottle on a sunlit kitchen counter' --reference './src/brand/product.png,https://\u2026/kitchen.jpg'\n  baker studio generate 'founder-style selfie, kitchen background, natural light' --skill ugc-selfie-hook\n  baker studio generate 'flat geometric mascot, brand palette' --model recraft/recraft-v4.1-pro-vector --rgb-colors '[[10,10,10],[255,80,0]]'"
+  },
+  args: {
+    avatar: {
+      type: "string",
+      description: "Cast an avatar by short name \u2014 grounds the image on their identity sheet",
+      required: false
+    },
+    prompt: { type: "positional", description: "What to generate", required: false },
+    model: { type: "string", description: "Model id (default google/gemini-3.1-flash-image)", required: false },
+    "aspect-ratio": { type: "string", description: "Aspect ratio (default 1:1)", required: false },
+    count: { type: "string", description: "Takes to render, 1-8 (default 1)", required: false },
+    reference: {
+      type: "string",
+      description: "Comma-separated library image ids, local file paths, and/or image URLs",
+      required: false
+    },
+    skill: { type: "string", description: "Craft direction id (`baker studio skills`)", required: false },
+    brand: { type: "boolean", description: "Append the company palette and style", required: false },
+    "image-size": {
+      type: "string",
+      description: `Output resolution, models that have one only: ${IMAGE_SIZES.join(" | ")}`,
+      required: false
+    },
+    quality: {
+      type: "string",
+      description: `Rendering quality, models that honour it only: ${IMAGE_QUALITIES.join(" | ")}`,
+      required: false
+    },
+    strength: { type: "string", description: "Recraft vectorization strength 0-1", required: false },
+    "rgb-colors": { type: "string", description: "Recraft palette JSON", required: false },
+    "bg-rgb": { type: "string", description: "Recraft background JSON", required: false },
+    wait: { type: "string", description: "false to return the batch id immediately", required: false },
+    "max-wait": { type: "string", description: "Max ms to wait (default 240000, 0 = no wait)", required: false },
+    full: { type: "boolean", description: "Include settings, references and attribution", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const prompt = args.prompt;
+      if (!prompt) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "A prompt is required" } });
+        process.exit(1);
+      }
+      const body = buildGenerateBody(args, prompt);
+      if (args.reference) {
+        const model = await effectiveModel(body.model, body.skillId);
+        const { imageIds } = await resolveLibraryImageIds(args.reference, referenceLimitFor(model));
+        if (imageIds.length > 0) body.referenceImageIds = imageIds;
+      }
+      const start = await apiPost("/api/studio/generate", body);
+      const maxWaitMs = resolveMaxWaitMs(args.wait, args["max-wait"], DEFAULT_MAX_WAIT_MS);
+      if (maxWaitMs === 0) {
+        writeJson({
+          ok: true,
+          data: start,
+          hints: [`Rendering ${start.count} take(s). Read them with \`baker studio get ${start.generationId}\`.`]
+        });
+        return;
+      }
+      const outcome = await awaitBatch(start.generationId, maxWaitMs);
+      if (outcome.kind !== "settled") {
+        writeJson({
+          ok: true,
+          data: { ...start, status: "running" },
+          hints: [waitingHint(outcome, start.generationId, maxWaitMs)]
+        });
+        return;
+      }
+      writeJson({
+        ok: true,
+        data: projectBatch(outcome.generation, args.full === true),
+        hints: batchHints(outcome.generation)
+      });
+    } catch (error) {
+      failStudioCommand(error, { withFix: true });
+    }
+  }
+});
+export {
+  buildGenerateBody,
+  effectiveModel,
+  generateCommand,
+  referenceLimitFor
+};
+//# sourceMappingURL=generate-HOMLLUCN.js.map