@koda-sl/baker-cli 0.575.0-dev.85f21462e → 0.576.0

package/dist/chunk-MCJ5I5LR.js

@@ -0,0 +1,3187 @@
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-YQSBHWOI.js";
+
+// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js
+var require_safe_stable_stringify = __commonJS({
+  "../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js"(exports, module) {
+    "use strict";
+    var { hasOwnProperty } = Object.prototype;
+    var stringify = configure2();
+    stringify.configure = configure2;
+    stringify.stringify = stringify;
+    stringify.default = stringify;
+    exports.stringify = stringify;
+    exports.configure = configure2;
+    module.exports = stringify;
+    var strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+    function strEscape(str) {
+      if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) {
+        return `"${str}"`;
+      }
+      return JSON.stringify(str);
+    }
+    function sort(array, comparator) {
+      if (array.length > 200 || comparator) {
+        return array.sort(comparator);
+      }
+      for (let i = 1; i < array.length; i++) {
+        const currentValue = array[i];
+        let position = i;
+        while (position !== 0 && array[position - 1] > currentValue) {
+          array[position] = array[position - 1];
+          position--;
+        }
+        array[position] = currentValue;
+      }
+      return array;
+    }
+    var typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(
+      Object.getPrototypeOf(
+        Object.getPrototypeOf(
+          new Int8Array()
+        )
+      ),
+      Symbol.toStringTag
+    ).get;
+    function isTypedArrayWithEntries(value) {
+      return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
+    }
+    function stringifyTypedArray(array, separator, maximumBreadth) {
+      if (array.length < maximumBreadth) {
+        maximumBreadth = array.length;
+      }
+      const whitespace = separator === "," ? "" : " ";
+      let res = `"0":${whitespace}${array[0]}`;
+      for (let i = 1; i < maximumBreadth; i++) {
+        res += `${separator}"${i}":${whitespace}${array[i]}`;
+      }
+      return res;
+    }
+    function getCircularValueOption(options) {
+      if (hasOwnProperty.call(options, "circularValue")) {
+        const circularValue = options.circularValue;
+        if (typeof circularValue === "string") {
+          return `"${circularValue}"`;
+        }
+        if (circularValue == null) {
+          return circularValue;
+        }
+        if (circularValue === Error || circularValue === TypeError) {
+          return {
+            toString() {
+              throw new TypeError("Converting circular structure to JSON");
+            }
+          };
+        }
+        throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
+      }
+      return '"[Circular]"';
+    }
+    function getDeterministicOption(options) {
+      let value;
+      if (hasOwnProperty.call(options, "deterministic")) {
+        value = options.deterministic;
+        if (typeof value !== "boolean" && typeof value !== "function") {
+          throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
+        }
+      }
+      return value === void 0 ? true : value;
+    }
+    function getBooleanOption(options, key) {
+      let value;
+      if (hasOwnProperty.call(options, key)) {
+        value = options[key];
+        if (typeof value !== "boolean") {
+          throw new TypeError(`The "${key}" argument must be of type boolean`);
+        }
+      }
+      return value === void 0 ? true : value;
+    }
+    function getPositiveIntegerOption(options, key) {
+      let value;
+      if (hasOwnProperty.call(options, key)) {
+        value = options[key];
+        if (typeof value !== "number") {
+          throw new TypeError(`The "${key}" argument must be of type number`);
+        }
+        if (!Number.isInteger(value)) {
+          throw new TypeError(`The "${key}" argument must be an integer`);
+        }
+        if (value < 1) {
+          throw new RangeError(`The "${key}" argument must be >= 1`);
+        }
+      }
+      return value === void 0 ? Infinity : value;
+    }
+    function getItemCount(number) {
+      if (number === 1) {
+        return "1 item";
+      }
+      return `${number} items`;
+    }
+    function getUniqueReplacerSet(replacerArray) {
+      const replacerSet = /* @__PURE__ */ new Set();
+      for (const value of replacerArray) {
+        if (typeof value === "string" || typeof value === "number") {
+          replacerSet.add(String(value));
+        }
+      }
+      return replacerSet;
+    }
+    function getStrictOption(options) {
+      if (hasOwnProperty.call(options, "strict")) {
+        const value = options.strict;
+        if (typeof value !== "boolean") {
+          throw new TypeError('The "strict" argument must be of type boolean');
+        }
+        if (value) {
+          return (value2) => {
+            let message = `Object can not safely be stringified. Received type ${typeof value2}`;
+            if (typeof value2 !== "function") message += ` (${value2.toString()})`;
+            throw new Error(message);
+          };
+        }
+      }
+    }
+    function configure2(options) {
+      options = { ...options };
+      const fail = getStrictOption(options);
+      if (fail) {
+        if (options.bigint === void 0) {
+          options.bigint = false;
+        }
+        if (!("circularValue" in options)) {
+          options.circularValue = Error;
+        }
+      }
+      const circularValue = getCircularValueOption(options);
+      const bigint = getBooleanOption(options, "bigint");
+      const deterministic = getDeterministicOption(options);
+      const comparator = typeof deterministic === "function" ? deterministic : void 0;
+      const maximumDepth = getPositiveIntegerOption(options, "maximumDepth");
+      const maximumBreadth = getPositiveIntegerOption(options, "maximumBreadth");
+      function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
+        let value = parent[key];
+        if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
+          value = value.toJSON(key);
+        }
+        value = replacer.call(parent, key, value);
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            let res = "";
+            let join = ",";
+            const originalIndentation = indentation;
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              if (spacer !== "") {
+                indentation += spacer;
+                res += `
+${indentation}`;
+                join = `,
+${indentation}`;
+              }
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += join;
+              }
+              const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              if (spacer !== "") {
+                res += `
+${originalIndentation}`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            let whitespace = "";
+            let separator = "";
+            if (spacer !== "") {
+              indentation += spacer;
+              join = `,
+${indentation}`;
+              whitespace = " ";
+            }
+            const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (deterministic && !isTypedArrayWithEntries(value)) {
+              keys = sort(keys, comparator);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
+                separator = join;
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
+              separator = join;
+            }
+            if (spacer !== "" && separator.length > 1) {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "undefined":
+            return void 0;
+          case "bigint":
+            if (bigint) {
+              return String(value);
+            }
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
+        if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
+          value = value.toJSON(key);
+        }
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            const originalIndentation = indentation;
+            let res = "";
+            let join = ",";
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              if (spacer !== "") {
+                indentation += spacer;
+                res += `
+${indentation}`;
+                join = `,
+${indentation}`;
+              }
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += join;
+              }
+              const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              if (spacer !== "") {
+                res += `
+${originalIndentation}`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            stack.push(value);
+            let whitespace = "";
+            if (spacer !== "") {
+              indentation += spacer;
+              join = `,
+${indentation}`;
+              whitespace = " ";
+            }
+            let separator = "";
+            for (const key2 of replacer) {
+              const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
+                separator = join;
+              }
+            }
+            if (spacer !== "" && separator.length > 1) {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "undefined":
+            return void 0;
+          case "bigint":
+            if (bigint) {
+              return String(value);
+            }
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringifyIndent(key, value, stack, spacer, indentation) {
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (typeof value.toJSON === "function") {
+              value = value.toJSON(key);
+              if (typeof value !== "object") {
+                return stringifyIndent(key, value, stack, spacer, indentation);
+              }
+              if (value === null) {
+                return "null";
+              }
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            const originalIndentation = indentation;
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              indentation += spacer;
+              let res2 = `
+${indentation}`;
+              const join2 = `,
+${indentation}`;
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+                res2 += tmp2 !== void 0 ? tmp2 : "null";
+                res2 += join2;
+              }
+              const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+              res2 += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res2 += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              res2 += `
+${originalIndentation}`;
+              stack.pop();
+              return `[${res2}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            indentation += spacer;
+            const join = `,
+${indentation}`;
+            let res = "";
+            let separator = "";
+            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (isTypedArrayWithEntries(value)) {
+              res += stringifyTypedArray(value, join, maximumBreadth);
+              keys = keys.slice(value.length);
+              maximumPropertiesToStringify -= value.length;
+              separator = join;
+            }
+            if (deterministic) {
+              keys = sort(keys, comparator);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}${strEscape(key2)}: ${tmp}`;
+                separator = join;
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
+              separator = join;
+            }
+            if (separator !== "") {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "undefined":
+            return void 0;
+          case "bigint":
+            if (bigint) {
+              return String(value);
+            }
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringifySimple(key, value, stack) {
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (typeof value.toJSON === "function") {
+              value = value.toJSON(key);
+              if (typeof value !== "object") {
+                return stringifySimple(key, value, stack);
+              }
+              if (value === null) {
+                return "null";
+              }
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            let res = "";
+            const hasLength = value.length !== void 0;
+            if (hasLength && Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifySimple(String(i), value[i], stack);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += ",";
+              }
+              const tmp = stringifySimple(String(i), value[i], stack);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `,"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            let separator = "";
+            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (hasLength && isTypedArrayWithEntries(value)) {
+              res += stringifyTypedArray(value, ",", maximumBreadth);
+              keys = keys.slice(value.length);
+              maximumPropertiesToStringify -= value.length;
+              separator = ",";
+            }
+            if (deterministic) {
+              keys = sort(keys, comparator);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifySimple(key2, value[key2], stack);
+              if (tmp !== void 0) {
+                res += `${separator}${strEscape(key2)}:${tmp}`;
+                separator = ",";
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "undefined":
+            return void 0;
+          case "bigint":
+            if (bigint) {
+              return String(value);
+            }
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringify2(value, replacer, space) {
+        if (arguments.length > 1) {
+          let spacer = "";
+          if (typeof space === "number") {
+            spacer = " ".repeat(Math.min(space, 10));
+          } else if (typeof space === "string") {
+            spacer = space.slice(0, 10);
+          }
+          if (replacer != null) {
+            if (typeof replacer === "function") {
+              return stringifyFnReplacer("", { "": value }, [], replacer, spacer, "");
+            }
+            if (Array.isArray(replacer)) {
+              return stringifyArrayReplacer("", value, [], getUniqueReplacerSet(replacer), spacer, "");
+            }
+          }
+          if (spacer.length !== 0) {
+            return stringifyIndent("", value, [], spacer, "");
+          }
+        }
+        return stringifySimple("", value, []);
+      }
+      return stringify2;
+    }
+  }
+});
+
+// ../canvas-contract/src/adPlacements.ts
+var AD_PLATFORMS = [
+  "meta",
+  "google_display",
+  "google_pmax",
+  "google_demandgen",
+  "google_search",
+  "youtube",
+  "linkedin",
+  "tiktok",
+  "x",
+  "reddit",
+  "pinterest",
+  "snapchat",
+  "chatgpt"
+];
+var AD_PLATFORM_LEAD = {
+  meta: "4:5",
+  google_display: "1:1",
+  google_pmax: "1:1",
+  google_demandgen: "1:1",
+  google_search: "1:1",
+  youtube: "1.91:1",
+  linkedin: "1:1",
+  tiktok: "9:16",
+  x: "1.91:1",
+  reddit: "1:1",
+  pinterest: "2:3",
+  snapchat: "9:16",
+  chatgpt: "1:1"
+};
+var AD_PLATFORM_NAMES = {
+  meta: "Meta",
+  google_display: "Google Display",
+  google_pmax: "Performance Max",
+  google_demandgen: "Demand Gen",
+  google_search: "Google Search",
+  youtube: "YouTube",
+  linkedin: "LinkedIn",
+  tiktok: "TikTok",
+  x: "X",
+  reddit: "Reddit",
+  pinterest: "Pinterest",
+  snapchat: "Snapchat",
+  chatgpt: "ChatGPT"
+};
+var FEED_MARGIN = { top: 0.04, bottom: 0.04, left: 0.04, right: 0.04 };
+var size = (width, height, required = true) => ({ width, height, required });
+var AD_PLACEMENTS = [
+  {
+    id: "meta_feed",
+    platform: "meta",
+    name: "Facebook and Instagram feeds",
+    sizes: [size(1080, 1350), size(1080, 1080, false)],
+    safe: FEED_MARGIN,
+    source: "https://www.facebook.com/business/ads-guide/update/image/instagram-feed"
+  },
+  {
+    id: "meta_stories",
+    platform: "meta",
+    name: "Facebook and Instagram Stories",
+    sizes: [size(1080, 1920)],
+    safe: { top: 0.16, bottom: 0.22, left: 0.04, right: 0.04 },
+    cover: { top: 0.09, bottom: 0.15 },
+    source: "https://www.facebook.com/business/ads-guide/update/image/instagram-story"
+  },
+  {
+    id: "meta_reels",
+    platform: "meta",
+    name: "Facebook and Instagram Reels",
+    sizes: [size(1080, 1920)],
+    safe: { top: 0.16, bottom: 0.37, left: 0.04, right: 0.04 },
+    cover: { top: 0.09, bottom: 0.32, rail: { width: 0.08, from: 0.6 } },
+    railMargin: { width: 0.1, from: 0.55 },
+    source: "https://www.facebook.com/business/ads-guide/update/image/instagram-reels"
+  },
+  {
+    id: "meta_right_column",
+    platform: "meta",
+    name: "Facebook right column, Marketplace and search results",
+    sizes: [size(1080, 1080), size(1200, 628, false)],
+    safe: FEED_MARGIN,
+    optIn: true,
+    source: "https://www.facebook.com/business/ads-guide/update/image/facebook-right-column"
+  },
+  {
+    id: "google_display_responsive",
+    platform: "google_display",
+    name: "Responsive display ads (Google Display Network)",
+    sizes: [size(1200, 628), size(1200, 1200), size(900, 1600, false)],
+    safe: FEED_MARGIN,
+    rule: "Text may cover at most 20% of the image; Google crops up to 5% from each side.",
+    source: "https://support.google.com/google-ads/answer/9823397"
+  },
+  {
+    id: "google_display_banners",
+    platform: "google_display",
+    name: "Uploaded display banners",
+    sizes: [
+      size(300, 250),
+      size(728, 90),
+      size(320, 50),
+      size(336, 280, false),
+      size(300, 600, false),
+      size(160, 600, false),
+      size(320, 100, false),
+      size(970, 250, false)
+    ],
+    safe: FEED_MARGIN,
+    rule: "Each banner is exactly its pixel size, 150 KB at most.",
+    source: "https://support.google.com/google-ads/answer/7031480"
+  },
+  {
+    id: "google_pmax",
+    platform: "google_pmax",
+    name: "Performance Max asset group",
+    sizes: [size(1200, 628), size(1200, 1200), size(960, 1200, false)],
+    safe: FEED_MARGIN,
+    rule: "Google crops up to 5% from each side; keep text and logos off the edges.",
+    source: "https://support.google.com/google-ads/answer/13676244"
+  },
+  {
+    id: "google_demandgen",
+    platform: "google_demandgen",
+    name: "Demand Gen (YouTube, Discover, Gmail)",
+    sizes: [size(1200, 628), size(1200, 1200), size(960, 1200, false)],
+    safe: FEED_MARGIN,
+    source: "https://support.google.com/google-ads/answer/13547298"
+  },
+  {
+    id: "google_search_images",
+    platform: "google_search",
+    name: "Image assets on Search ads",
+    sizes: [size(1200, 1200), size(1200, 628, false)],
+    safe: FEED_MARGIN,
+    rule: "No overlaid text, logos or buttons on the image.",
+    source: "https://support.google.com/google-ads/answer/12118270"
+  },
+  {
+    id: "youtube_feed",
+    platform: "youtube",
+    name: "YouTube home and watch-next feeds",
+    sizes: [size(1200, 628), size(1200, 1200, false)],
+    safe: FEED_MARGIN,
+    source: "https://support.google.com/google-ads/answer/13547298"
+  },
+  {
+    id: "youtube_shorts",
+    platform: "youtube",
+    name: "YouTube Shorts",
+    sizes: [size(1080, 1920)],
+    safe: { top: 0.12, bottom: 0.35, left: 0.05, right: 0.05 },
+    cover: { top: 0.08, bottom: 0.3, rail: { width: 0.14, from: 0.45 } },
+    railMargin: { width: 0.16, from: 0.4 },
+    source: "https://support.google.com/youtube/answer/10059070"
+  },
+  {
+    id: "linkedin_feed",
+    platform: "linkedin",
+    name: "LinkedIn feed (single image)",
+    sizes: [size(1200, 1200), size(1200, 627, false), size(720, 900, false)],
+    safe: FEED_MARGIN,
+    source: "https://www.linkedin.com/help/lms/answer/a426534"
+  },
+  {
+    id: "tiktok_feed",
+    platform: "tiktok",
+    name: "TikTok For You feed",
+    sizes: [size(1080, 1920)],
+    safe: { top: 0.1, bottom: 0.3, left: 0.06, right: 0.06 },
+    cover: { top: 0.07, bottom: 0.25, rail: { width: 0.13, from: 0.45 } },
+    railMargin: { width: 0.15, from: 0.4 },
+    source: "https://ads.tiktok.com/help/article/tiktok-ads-safe-zone"
+  },
+  {
+    id: "x_timeline",
+    platform: "x",
+    name: "X timeline (image and website card)",
+    sizes: [size(1200, 628), size(1200, 1200, false)],
+    safe: FEED_MARGIN,
+    source: "https://business.x.com/en/help/campaign-setup/creative-ad-specifications"
+  },
+  {
+    id: "reddit_feed",
+    platform: "reddit",
+    name: "Reddit feed and conversation pages",
+    sizes: [size(1080, 1080), size(1080, 1350, false), size(1200, 628, false)],
+    safe: FEED_MARGIN,
+    source: "https://business.reddithelp.com/s/article/image-ad-specs"
+  },
+  {
+    id: "pinterest_feed",
+    platform: "pinterest",
+    name: "Pinterest home feed and search (standard pin)",
+    sizes: [size(1e3, 1500), size(1e3, 1e3, false)],
+    safe: FEED_MARGIN,
+    source: "https://help.pinterest.com/en/business/article/pinterest-product-specs"
+  },
+  {
+    id: "snapchat_snap_ads",
+    platform: "snapchat",
+    name: "Snapchat Snap Ads",
+    sizes: [size(1080, 1920)],
+    safe: { top: 0.11, bottom: 0.21, left: 0.04, right: 0.04 },
+    cover: { top: 0.08, bottom: 0.18 },
+    source: "https://businesshelp.snapchat.com/s/article/single-image-video-specs"
+  },
+  {
+    id: "chatgpt_card",
+    platform: "chatgpt",
+    name: "ChatGPT sponsored card",
+    sizes: [size(1200, 1200)],
+    safe: FEED_MARGIN,
+    rule: "The card shows a square of the image; keep everything that matters inside it.",
+    source: "https://help.openai.com/en/articles/chatgpt-ads"
+  }
+];
+var RATIOS = [
+  ["1:1", 1],
+  ["4:5", 4 / 5],
+  ["9:16", 9 / 16],
+  ["16:9", 16 / 9],
+  ["1.91:1", 1.91],
+  ["2:3", 2 / 3],
+  ["3:4", 3 / 4],
+  ["4:3", 4 / 3]
+];
+function ratioLabel(width, height) {
+  const r = width / height;
+  const known = RATIOS.find(([, value]) => Math.abs(Math.log(r / value)) < 0.01);
+  return known ? known[0] : `${width}x${height}`;
+}
+function placementsFor(names) {
+  const placements = [];
+  const unknown = [];
+  for (const raw of names) {
+    const name = raw.trim().toLowerCase();
+    if (!name) continue;
+    const found = AD_PLACEMENTS.filter((p) => p.id === name || p.platform === name && !p.optIn);
+    if (found.length === 0) unknown.push(raw.trim());
+    for (const p of found) if (!placements.includes(p)) placements.push(p);
+  }
+  return { placements, unknown };
+}
+function addSize(into, format, size2, placement) {
+  const existing = into.find((f) => f.format === format);
+  if (!existing) {
+    into.push({ format, width: size2.width, height: size2.height, placements: [placement] });
+    return;
+  }
+  if (!existing.placements.includes(placement)) existing.placements.push(placement);
+  if (size2.width > existing.width) Object.assign(existing, { width: size2.width, height: size2.height });
+}
+function leadOf(names) {
+  for (const raw of names) {
+    const name = raw.trim().toLowerCase();
+    if (name in AD_PLATFORM_LEAD) return AD_PLATFORM_LEAD[name];
+    const placement = AD_PLACEMENTS.find((p) => p.id === name);
+    const first = placement?.sizes.find((s) => s.required);
+    if (first) return ratioLabel(first.width, first.height);
+  }
+  return void 0;
+}
+function leadFirst(formats, lead) {
+  const at = formats.findIndex((f) => f.format === lead);
+  return at <= 0 ? formats : [formats[at], ...formats.filter((_, i) => i !== at)];
+}
+function deliveryPlan(names, asked) {
+  const { placements, unknown } = placementsFor(names);
+  const { required, shown, banners } = sizesOf(placements);
+  const { formats, refused } = asked && asked.length > 0 ? askedSizes(asked, shown, placements) : { formats: required, refused: [] };
+  const platformLead = leadOf(names);
+  const lead = formats.some((f) => f.format === platformLead) ? platformLead : formats[0]?.format;
+  const delivered = leadFirst(formats, lead);
+  const served = new Set(delivered.flatMap((f) => f.placements));
+  return {
+    lead: lead ?? "",
+    formats: delivered,
+    banners,
+    placements: placements.map((p) => p.id).filter((id) => served.has(id)),
+    unknown,
+    refused,
+    cropped: placements.filter((p) => ratioSized(p) && !served.has(p.id)).map((p) => p.id)
+  };
+}
+function sizesOf(placements) {
+  const required = [];
+  const shown = [];
+  const banners = [];
+  for (const placement of placements) {
+    for (const s of placement.sizes) {
+      const format = ratioLabel(s.width, s.height);
+      if (isBanner(format)) {
+        if (s.required) addSize(banners, format, s, placement.id);
+        continue;
+      }
+      addSize(shown, format, s, placement.id);
+      if (s.required) addSize(required, format, s, placement.id);
+    }
+  }
+  return { required, shown, banners };
+}
+function askedSizes(asked, shown, placements) {
+  const where = [...new Set(placements.map((p) => AD_PLATFORM_NAMES[p.platform]))].join(" or ") || "No placement named";
+  const formats = [];
+  const refused = [];
+  for (const format of new Set(asked.map((f) => f.trim()))) {
+    const found = shown.find((f) => f.format === format);
+    if (found) formats.push(found);
+    else refused.push({ format, why: `${where} shows no ${format} picture` });
+  }
+  return { formats, refused };
+}
+var isBanner = (format) => format.includes("x");
+var ratioSized = (p) => p.sizes.some((s) => s.required && !isBanner(ratioLabel(s.width, s.height)));
+function verticalCover(placementIds) {
+  const covering = AD_PLACEMENTS.filter((p) => placementIds.includes(p.id) && p.cover);
+  if (covering.length === 0) return null;
+  const max = (pick) => Math.max(...covering.map((p) => pick(p) ?? 0));
+  const rails = covering.filter((p) => p.cover?.rail);
+  const margins = covering.filter((p) => p.railMargin);
+  return {
+    top: max((p) => p.cover?.top),
+    bottom: max((p) => p.cover?.bottom),
+    ...rails.length > 0 ? {
+      rail: {
+        width: max((p) => p.cover?.rail?.width),
+        from: Math.min(...rails.map((p) => p.cover?.rail?.from ?? 1))
+      }
+    } : {},
+    ...margins.length > 0 ? {
+      railMargin: {
+        width: max((p) => p.railMargin?.width),
+        from: Math.min(...margins.map((p) => p.railMargin?.from ?? 1))
+      }
+    } : {},
+    safe: {
+      top: max((p) => p.safe.top),
+      bottom: max((p) => p.safe.bottom),
+      left: max((p) => p.safe.left),
+      right: max((p) => p.safe.right)
+    }
+  };
+}
+
+// ../canvas-contract/src/adRead.ts
+var AD_DESCRIBE_FOCUS = "FIRST, WHY THIS AD WINS, in layers, in `why_it_wins` { disguise (what it pretends to be: a note, a tweet, a newspaper, a chat, a plain ad), voice (who speaks, and how), trigger (the emotion or need it pulls: a free gift, a hidden loss, status, curiosity), attention (what stops the scroll), logic (why it convinces: reciprocity, social proof, a comparison, a price anchor) }, one short phrase each; and in `load_bearing` the 1-4 elements it stops working without (never decoration), each { element, needs: what it takes to carry it } (a free gift, a real peer's face, priced tiers, a native disguise). THEN the LAYOUT: the column/row grid, which region holds what (describe each by what fills it and where it sits, never by percentages or pixel figures), any panel splits, and for EVERY text block its string verbatim, its size relative to the other text (x_large | large | medium | small), weight, case, colour in words, and placement, including small bottom-corner fine print, and whether it is lettered on something in the scene (`surface`). Also: the EXPRESSION and emotion of every person/animal (capture exaggerated or AI-edited faces), the ad_intent, logos by brand, and all visible text verbatim. The TYPOGRAPHY as a first-class identity signal: for EVERY distinct typeface record a `fonts` entry (which text blocks use it, its classification, a best-guess family or close lookalike, its weight/case/styling), and whether the advertiser's LOGO appears in more than one lockup (a square/icon MARK and a horizontal WORDMARK are two assets: capture BOTH). Capture as a photographer would describe it in words (phone or studio, the height and angle, the light and its direction), never as lens or exposure figures. CRITICAL: name the MECHANISM, the one device that makes THIS ad work on a stranger rather than a generic ad (VERBAL: a rhyme, pun, repetition, antithesis; VISUAL: an unexpected crop or scale, a visual gag, a before/after or comparison, bold negative space; STRUCTURAL: an unusual hook, order or reveal). Record every device in `winning_mechanisms` as { kind: verbal|visual|structural, device, why_it_works } and the strongest one in `mechanism`. And read WHO the ad is for, in `audience`: the viewer it speaks to, their awareness stage, how warm they must already be, and whether the copy only works if they already know this brand or offer (`presumes_brand_knowledge`), so a rebuild for a different audience knows what to change";
+var AD_SELECT_SYSTEM = 'You identify the MAIN, identity-critical visual elements of an advertisement from its JSON blueprint \u2014 the things a faithful reproduction must supply as REAL reference images instead of letting a model invent them. Output ONLY a JSON object of the form { "elements": [ ... ] }, no prose.';
+var AD_SELECT_PROMPT = `AD BLUEPRINT (from image_describe):
+{{blueprint}}
+
+From this blueprint, list ONLY the elements that are prominent, important, and identity-bearing \u2014 the ones a reproduction must ground in a real asset:
+- the brand logo/wordmark (from brands_logos with function_in_image = advertiser_brand) -> type "logo". A brand often ships its logo in TWO lockups \u2014 a square/icon MARK and a horizontal WORDMARK \u2014 and an ad may use both (e.g. an icon in a product mock plus the wordmark in the sign-off). When more than one distinct lockup of the SAME advertiser appears, emit a SEPARATE logo element for each (label them by lockup, e.g. LOGO_MARK and LOGO_WORDMARK) so the reproduction can drop the right file in each slot instead of stretching one logo to cover both.
+- trust/rating/certification/app-store/review badges (brands_logos with function_in_image = trust_badge | review_platform | certification_or_seal | app_store_badge | payment_method) -> type "badge"
+- a showcased/hero product or package (a foreground entry in subjects that the ad is selling) -> type "product"
+- a foreground person (from people) \u2014 keep it when its identity matters OR it is the emotional/hero focal point of the ad, even a generic one with no brand identity -> type "person". Describe them as a castable, invented everyday person (age band, look, wardrobe, expression) \u2014 never the source person's identity: unless a company avatar is cast, the render draws this person from your words alone
+- a foreground animal/character (from subjects) \u2014 keep it when it carries a specific expression OR it is the emotional/hero focal point, even a generic one -> type "animal"
+  (For an animal: a free-generated muzzle or teeth reads as AI and grows artifacts \u2014 malformed mouths, foam \u2014 so the emotional hero needs the STRONGEST real grounding, not the weakest; "it's just a generic dog/person" is never a reason to drop either.)
+
+DROP background extras, decorative props, generic scenery, and anything small or incidental. Keep at most ~6. If there are none, return an empty list.
+
+For each kept element return: { "type": one of logo|product|person|animal|badge, "label": a short UPPER_SNAKE_CASE name (e.g. LOGO, PRODUCT, HERO_DOG, TRUSTPILOT), "description": a concrete reusable description to source/shoot the real asset (include the exact expression for a living subject, and its castable attributes \u2014 breed/species for an animal, apparent age band, apparent origin/ethnicity, and wardrobe/setting for a person \u2014 so it can be recast to fit OUR audience/market), "expression": the facial expression for a living subject or null, "reason": why it is identity-critical, "locator": the blueprint entry this element came from as { "collection": one of "subjects" | "people" | "brands_logos", "index": its 0-based position in that array } (people -> people; logos/badges -> brands_logos; products/animals/objects -> subjects). Output ONLY the JSON object.`;
+
+// ../canvas-contract/src/castName.ts
+function withoutCastName(text, names) {
+  let out = text;
+  for (const name of names) {
+    const token = name.trim();
+    if (token.length < 3) continue;
+    const pattern = new RegExp(`(?<![\\p{L}\\p{N}])${escapeForPattern(token)}(?![\\p{L}\\p{N}])`, "giu");
+    out = out.replace(pattern, "the person in the reference");
+  }
+  return out;
+}
+function escapeForPattern(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ../canvas-contract/src/adPlatformFormats.ts
+var AD_FORMAT_PLATFORMS = [
+  "meta_feed",
+  "meta_feed_stories",
+  "meta_all",
+  "linkedin",
+  "google_search",
+  "google_demandgen",
+  "tiktok",
+  "youtube"
+];
+var AD_PLATFORM_FORMAT_PRESETS = {
+  meta_feed: { formats: ["4:5"], note: "Meta/Instagram feed static." },
+  meta_feed_stories: { formats: ["4:5", "9:16"], note: "Meta feed + Stories/Reels." },
+  meta_all: { formats: ["4:5", "9:16", "1:1"], note: "Meta feed + Stories/Reels + square." },
+  linkedin: { formats: ["1:1"], note: "LinkedIn single-image feed (square)." },
+  google_search: {
+    // Search image assets: 1:1 is the required one, 1.91:1 the optional landscape.
+    // 16:9 is rendered only as the crop source for that landscape — Search never serves 16:9 itself.
+    formats: ["1:1", "16:9"],
+    offGrid: ["1.91:1"],
+    note: "Google Search image assets (the image extension on a text ad); 1:1 required, 1.91:1 landscape \u2014 crop that from the rendered 16:9. Stage 3+ per campaign."
+  },
+  google_demandgen: {
+    // Renders 16:9 too so the off-grid 1.91:1 landscape has a native source to crop from.
+    formats: ["1:1", "4:5", "16:9"],
+    offGrid: ["1.91:1"],
+    note: "Google Demand Gen; also wants 1.91:1 landscape \u2014 crop that from the rendered 16:9."
+  },
+  tiktok: { formats: ["9:16"], note: "TikTok full-screen vertical." },
+  youtube: { formats: ["16:9"], note: "YouTube in-stream / companion display." }
+};
+function platformFormats(platform) {
+  return AD_PLATFORM_FORMAT_PRESETS[platform].formats;
+}
+function resolveAdaptFormats(params) {
+  if (params.platform) return platformFormats(params.platform);
+  return params.formats ?? [];
+}
+
+// ../canvas-contract/src/registry.ts
+var OPENROUTER_ROUTE = { provider: "openrouter" };
+var USAGE_BILLED = { kind: "usage" };
+var MIN_BILLED_SECONDS = 5;
+var SEEDANCE_FACE_RECOVERY_ROUTE = {
+  provider: "fal",
+  wireModel: "bytedance/seedance-2.5/reference-to-video"
+};
+var OPENROUTER_IMAGE_AR = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];
+var OPENROUTER_IMAGE_AR_EXTREME = [...OPENROUTER_IMAGE_AR, "1:4", "4:1", "1:8", "8:1"];
+var OPENROUTER_IMAGE_AR_GPT = ["1:1", "2:3", "3:2", "3:4", "4:3", "9:16", "16:9", "21:9"];
+var GPT_IMAGE_PROMPT_MAX = 32e3;
+var RECRAFT_PROMPT_MAX = 1e4;
+var SEEDANCE_PROMPT_MAX = 4e3;
+var KLING_PROMPT_MAX = 2500;
+var UINT32_MAX = 4294967295;
+var VEO_SEED_MAX = UINT32_MAX;
+var GPT_IMAGE_MAX_REFERENCES = 16;
+var GEMINI_IMAGE_MAX_REFERENCES = 14;
+var RECRAFT_MAX_REFERENCES = 1;
+var SEEDANCE_MAX_REFERENCES = 9;
+var OPENROUTER_IMAGE_SIZE = ["1K", "2K", "4K"];
+var OPENROUTER_IMAGE_SIZES = ["0.5K", ...OPENROUTER_IMAGE_SIZE];
+var OPENROUTER_IMAGE_SIZE_EXTENDED = OPENROUTER_IMAGE_SIZES;
+var GEMINI_LITE_IMAGE_SIZE = ["1K"];
+var OPENROUTER_IMAGE_QUALITY = ["auto", "low", "medium", "high"];
+var OPENROUTER_IMAGE_QUALITY_25 = ["auto", "low", "medium", "high", "xhigh", "max"];
+var OPENROUTER_IMAGE_N = { kind: "number", integer: true, min: 1, max: 10 };
+var RECRAFT_IMAGE_AR = ["1:1", "4:3", "3:4", "16:9", "9:16"];
+var SEEDANCE_DURATIONS = [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+var SEEDANCE_25_DURATIONS = [
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  26,
+  27,
+  28,
+  29,
+  30
+];
+var SEEDANCE_25_ASPECT_RATIOS = ["1:1", "3:4", "9:16", "4:3", "16:9", "21:9"];
+var SEEDANCE_25_RESOLUTIONS = ["480p", "720p"];
+var SEEDANCE_25_MAX_IMAGE_REFERENCES = 30;
+var SEEDANCE_25_MAX_VIDEO_REFERENCES = 10;
+var SEEDANCE_25_MAX_AUDIO_REFERENCES = 10;
+var KLING_DURATIONS = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+var GEMINI_OMNI_DURATIONS = [3, 4, 5, 6, 7, 8, 9, 10];
+var GEMINI_OMNI_ASPECT_RATIOS = ["16:9", "9:16"];
+var GEMINI_OMNI_RESOLUTIONS = ["360p", "720p", "1080p", "4k"];
+var GEMINI_OMNI_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp"];
+var GROK_IMAGINE_DURATIONS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+var WAN_27_DURATIONS = [2, 3, 4, 5, 6, 7, 8, 9, 10];
+var HAPPYHORSE_DURATIONS = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+var WAN_30_DURATIONS = [
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  26,
+  27,
+  28,
+  29,
+  30
+];
+var GROK_IMAGINE_15_DURATIONS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+var RUNWAY_45_DURATIONS = [2, 3, 4, 5, 6, 7, 8, 9, 10];
+var ELEVENLABS_OUTPUT_FORMATS = [
+  "mp3_22050_32",
+  "mp3_44100_32",
+  "mp3_44100_64",
+  "mp3_44100_96",
+  "mp3_44100_128",
+  "mp3_44100_192"
+];
+var ELEVENLABS_MAX_TEXT_CHARS = 45454;
+var ELEVENLABS_MAX_MUSIC_LENGTH_MS = 454545;
+var ELEVENLABS_MUSIC_ENGINE = "music_v2";
+var OPENROUTER_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
+var OPENROUTER_VIDEO_REFERENCE_MIMES = ["video/mp4", "video/quicktime", "video/webm"];
+var OPENROUTER_AUDIO_REFERENCE_MIMES = ["audio/mpeg", "audio/mp3", "audio/wav"];
+var REPLICATE_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp"];
+var REPLICATE_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
+var DECONSTRUCT_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
+var REPLICATE_AUDIO_MIMES = ["audio/wav", "audio/mpeg", "audio/mp3"];
+var IMAGE_GENERATE_MODELS = [
+  "openai/gpt-image-2.5-sunburst",
+  "openai/gpt-image-2",
+  "google/gemini-3.1-flash-image",
+  "google/gemini-3.1-flash-lite-image",
+  "google/gemini-3-pro-image",
+  "recraft/recraft-v4.1-pro-vector"
+];
+var DEFAULT_IMAGE_GENERATE_MODEL = "google/gemini-3.1-flash-image";
+var IMAGE_PRICE_TIER = {
+  "openai/gpt-image-2.5-sunburst": "standard",
+  "openai/gpt-image-2": "standard",
+  "google/gemini-3.1-flash-image": "standard",
+  "google/gemini-3.1-flash-lite-image": "standard",
+  "google/gemini-3-pro-image": "pro",
+  "recraft/recraft-v4.1-pro-vector": "standard"
+};
+var IMAGE_TIER_CREDITS = { pro: 20, standard: 5 };
+function imagePictureCredits(model) {
+  const tier = IMAGE_PRICE_TIER[canonicalModelId(model)] ?? "standard";
+  return IMAGE_TIER_CREDITS[tier];
+}
+var VIDEO_GENERATE_MODELS = [
+  "bytedance/seedance-2.0",
+  "bytedance/seedance-2.5",
+  "google/gemini-omni-1.1-flash",
+  "google/gemini-omni-flash",
+  "google/veo-3.1",
+  "google/veo-3.1-fast",
+  "google/veo-3.1-lite",
+  "kwaivgi/kling-v3.0-pro",
+  "x-ai/grok-imagine-video",
+  "x-ai/grok-imagine-video-1.5",
+  "alibaba/wan-2.7",
+  "alibaba/wan-3.0",
+  "runway/gen-4.5",
+  "alibaba/happyhorse-1.1"
+];
+var DEFAULT_VIDEO_GENERATE_MODEL = "google/gemini-omni-1.1-flash";
+var REFERENCE_TO_VIDEO_MODELS = [
+  "bytedance/seedance-2.0",
+  "bytedance/seedance-2.5",
+  "google/gemini-omni-1.1-flash",
+  "google/gemini-omni-flash",
+  "x-ai/grok-imagine-video",
+  "alibaba/wan-2.7",
+  "alibaba/happyhorse-1.1"
+];
+function supportsReferenceToVideo(model) {
+  return REFERENCE_TO_VIDEO_MODELS.includes(model);
+}
+var DEFAULT_AVATAR_VIDEO_MODEL = "x-ai/grok-imagine-video";
+function isGeminiOmniModel(model) {
+  return model.startsWith("google/gemini-omni");
+}
+var GEMINI_OMNI_PREVIEW_MODEL = "google/gemini-omni-flash";
+function isGeminiOmniPreviewModel(model) {
+  return model === GEMINI_OMNI_PREVIEW_MODEL;
+}
+function isSeedance25Model(model) {
+  return model === "bytedance/seedance-2.5";
+}
+var LAST_FRAME_TO_VIDEO_MODELS = [
+  "bytedance/seedance-2.0",
+  "bytedance/seedance-2.5",
+  "google/veo-3.1",
+  "google/veo-3.1-fast",
+  "kwaivgi/kling-v3.0-pro"
+];
+function supportsLastFrame(model) {
+  return LAST_FRAME_TO_VIDEO_MODELS.includes(model);
+}
+var MODEL_REGISTRY = {
+  text_generate: {
+    "~google/gemini-flash-latest": {
+      label: "Google Gemini Flash (latest)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        system: { kind: "string" },
+        response_format: { kind: "string", enum: ["text", "json_object"] },
+        web_search: { kind: "boolean" },
+        temperature: { kind: "number", min: 0, max: 2 },
+        max_tokens: { kind: "number", min: 1 }
+      }
+    },
+    "~google/gemini-pro-latest": {
+      label: "Google Gemini Pro (latest)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        system: { kind: "string" },
+        response_format: { kind: "string", enum: ["text", "json_object"] },
+        web_search: { kind: "boolean" },
+        temperature: { kind: "number", min: 0, max: 2 },
+        max_tokens: { kind: "number", min: 1 }
+      }
+    }
+  },
+  image_describe: {
+    // Vision extraction — the Visual Architect system prompt lives on the
+    // backend, so there is no `prompt` param; `focus` appends emphasis only.
+    "~google/gemini-pro-latest": {
+      label: "Google Gemini Pro (latest, Vision)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: [],
+      params: {
+        focus: { kind: "string" },
+        context: { kind: "string" },
+        temperature: { kind: "number", min: 0, max: 2 },
+        max_tokens: { kind: "number", min: 1 }
+      }
+    },
+    "~google/gemini-flash-latest": {
+      label: "Google Gemini Flash (latest, Vision)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: [],
+      params: {
+        focus: { kind: "string" },
+        context: { kind: "string" },
+        temperature: { kind: "number", min: 0, max: 2 },
+        max_tokens: { kind: "number", min: 1 }
+      }
+    }
+  },
+  image_select: {
+    // Vision judgement — the selection contract (numbered images, JSON
+    // response) is baked into the backend prompt; `prompt` carries only the
+    // selection criteria. `count` has an engine-side default of 1, so it is
+    // not registry-required.
+    "~google/gemini-flash-latest": {
+      label: "Google Gemini Flash (latest, Vision)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        count: { kind: "number", min: 1 },
+        temperature: { kind: "number", min: 0, max: 2 },
+        max_tokens: { kind: "number", min: 1 }
+      }
+    },
+    "~google/gemini-pro-latest": {
+      label: "Google Gemini Pro (latest, Vision)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        count: { kind: "number", min: 1 },
+        temperature: { kind: "number", min: 0, max: 2 },
+        max_tokens: { kind: "number", min: 1 }
+      }
+    }
+  },
+  image_generate: {
+    // `seed` is omitted on every entry — OpenRouter's `image_config` schema
+    // has no `seed` slot for image-gen (different from video-gen), so passing
+    // it would be a silent no-op.
+    // The direct image model, not the `gpt-5.4-image-2` chat model that emitted
+    // images as a side effect. Notable capability gaps vs the Gemini entries:
+    // no `image_size` (OpenAI picks the pixel dimensions from the ratio, and a
+    // `resolution` is silently ignored) and the narrower `..._AR_GPT` ratio set.
+    "openai/gpt-image-2.5-sunburst": {
+      // Identical to the gpt-image-2 entry below except for the quality ladder and `n`
+      // (several images from one call) — the ratio set, the 16-reference ceiling, the missing `image_size` and the reasons
+      // `background` / `output_compression` stay undeclared all carry over unchanged.
+      label: "OpenAI GPT Image 2.5",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES, max: GPT_IMAGE_MAX_REFERENCES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string", maxLength: GPT_IMAGE_PROMPT_MAX },
+        aspect_ratio: { kind: "string", enum: OPENROUTER_IMAGE_AR_GPT },
+        quality: { kind: "string", enum: OPENROUTER_IMAGE_QUALITY_25 },
+        n: OPENROUTER_IMAGE_N
+      }
+    },
+    "openai/gpt-image-2": {
+      // Its live endpoint also advertises `background` (auto|opaque) and
+      // `output_compression` (0-100), which we deliberately do not declare. Not an
+      // oversight: a registry param is a promise the whole system keeps — the
+      // canvas node schema, the dashboard control, the CLI flag and the cost model
+      // all have to carry it — and neither knob changes what the picture IS.
+      // Declaring them would widen four surfaces to expose a file-size dial.
+      label: "OpenAI GPT Image 2",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES, max: GPT_IMAGE_MAX_REFERENCES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string", maxLength: GPT_IMAGE_PROMPT_MAX },
+        aspect_ratio: { kind: "string", enum: OPENROUTER_IMAGE_AR_GPT },
+        quality: { kind: "string", enum: OPENROUTER_IMAGE_QUALITY }
+      }
+    },
+    // The GA Nano Banana ids (2026-06-18). Same surface as the preview ids they replace
+    // — read off GET /api/v1/images/models/google/gemini-3.1-flash-image/endpoints and
+    // .../gemini-3-pro-image/endpoints — which is why those ids are plain aliases of
+    // these (`MODEL_ALIASES`): a canvas moves between them unchanged.
+    "google/gemini-3.1-flash-image": {
+      label: "Google Gemini 3.1 Flash Image (Nano Banana 2)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES, max: GEMINI_IMAGE_MAX_REFERENCES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: OPENROUTER_IMAGE_AR_EXTREME },
+        image_size: { kind: "string", enum: OPENROUTER_IMAGE_SIZE_EXTENDED }
+      }
+    },
+    "google/gemini-3-pro-image": {
+      label: "Google Gemini 3 Pro Image (Nano Banana Pro)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES, max: GEMINI_IMAGE_MAX_REFERENCES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: OPENROUTER_IMAGE_AR },
+        image_size: { kind: "string", enum: OPENROUTER_IMAGE_SIZE }
+        // No `quality`: OpenRouter's per-endpoint schema lists it for gpt-image and for
+        // NO Gemini image model, pro included. It is accepted-then-dropped, so declaring
+        // it invites the scaffolder to emit a param that does nothing.
+      }
+    },
+    "google/gemini-3.1-flash-lite-image": {
+      // Nano Banana 2 Lite. Same Gemini image family as the flash tier — same
+      // extreme aspect-ratio set, same reference editing — at HALF the output-token
+      // price ($0.00003 vs $0.00006 per output image token), which makes it the
+      // cheap-iteration tier for image work the way `veo-3.1-fast` is for video.
+      //
+      // The one thing it gives up is resolution: it renders 1K and nothing else.
+      // That is a hard provider 400, not a soft clamp, so it is gated here rather
+      // than discovered at dispatch. A 2K/4K hero frame belongs on the flash or pro
+      // tier. Unlike gpt-image it keeps 4:5 and 5:4, so Meta/Instagram portrait
+      // formats still come straight out of it.
+      //
+      // Reached through the normal OpenRouter image gateway (Google Vertex and
+      // Google AI Studio both serve it) — no direct-provider exception needed.
+      // Source: GET /api/v1/images/models/google/gemini-3.1-flash-lite-image/endpoints.
+      label: "Google Gemini 3.1 Flash Lite Image",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES, max: GEMINI_IMAGE_MAX_REFERENCES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: OPENROUTER_IMAGE_AR_EXTREME },
+        image_size: { kind: "string", enum: GEMINI_LITE_IMAGE_SIZE }
+      }
+    },
+    "recraft/recraft-v4.1-pro-vector": {
+      // The vector/logo tier, and the odd one out of this roster in three ways.
+      // All three are read off its live endpoint schema, and all three are the
+      // kind of fact that only shows up as a billed 400 if it is guessed:
+      //  - it renders FIVE ratios (no 4:5 / 5:4 / 2:3 / 3:2 / 21:9), so portrait
+      //    ad shapes snap to 3:4 rather than being sent as-is;
+      //  - it has NO resolution knob (`supported_parameters` lists none), so
+      //    `image_size` is refused here instead of accepted and ignored;
+      //  - it takes exactly ONE reference image, against 14-16 everywhere else.
+      // Its palette levers are real but arrive as provider passthrough
+      // (`controls`), which is why they are `json` rather than typed enums; the
+      // backend adapter builds that block in `buildImageGenBody`.
+      label: "Recraft v4.1 Pro Vector",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES, max: RECRAFT_MAX_REFERENCES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string", maxLength: RECRAFT_PROMPT_MAX },
+        aspect_ratio: { kind: "string", enum: RECRAFT_IMAGE_AR },
+        strength: { kind: "number", min: 0, max: 1 },
+        rgb_colors: { kind: "json" },
+        background_rgb_color: { kind: "json" }
+      }
+    }
+  },
+  image_reference_sheet: {
+    // Multi-view subject reference sheets (turnaround grids). The sheet prompt
+    // is baked into the backend handler — params here are semantic levers
+    // only. Both models consume MULTIPLE reference images via the `references`
+    // input slot (required: a sheet without source images is just image_generate).
+    "google/gemini-3-pro-image": {
+      label: "Google Gemini 3 Pro Image (Nano Banana Pro)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["subject_description", "subject_type"],
+      params: {
+        subject_description: { kind: "string" },
+        subject_type: { kind: "string", enum: ["character", "person", "product", "location"] },
+        views: { kind: "json" },
+        style: { kind: "string" },
+        prompt_override: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: OPENROUTER_IMAGE_AR },
+        image_size: { kind: "string", enum: OPENROUTER_IMAGE_SIZE }
+      }
+    },
+    "google/gemini-3.1-flash-image": {
+      label: "Google Gemini 3.1 Flash Image (Nano Banana 2)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["subject_description", "subject_type"],
+      params: {
+        subject_description: { kind: "string" },
+        subject_type: { kind: "string", enum: ["character", "person", "product", "location"] },
+        views: { kind: "json" },
+        style: { kind: "string" },
+        prompt_override: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: OPENROUTER_IMAGE_AR_EXTREME },
+        image_size: { kind: "string", enum: OPENROUTER_IMAGE_SIZE_EXTENDED }
+      }
+    }
+  },
+  image_aspect_adapt: {
+    // Multi-format adaptation of one creative. The recomposition prompt is
+    // baked into the backend handler. The target ratios come from EITHER an
+    // explicit `formats` list OR a `platform` preset that expands to the
+    // canonical set; exactly one of the two is required — that "one of" gate,
+    // and per-element ratio validation, live in the node's Zod schema (the
+    // registry can't express "one of" or gate array elements), so `formats`
+    // is not listed as registry-required. The source creative is a required
+    // input slot. `copy` (the exact lines the ad carries) and `safe_areas` (per
+    // format, the fractions each edge's interface covers) are set by the static
+    // scaffold so the reframe keeps every word, once, where the platform shows it.
+    "google/gemini-3-pro-image": {
+      label: "Google Gemini 3 Pro Image (Nano Banana Pro)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: [],
+      params: {
+        formats: { kind: "json" },
+        platform: { kind: "string", enum: AD_FORMAT_PLATFORMS },
+        guidance: { kind: "string" },
+        copy: { kind: "json" },
+        safe_areas: { kind: "json" },
+        image_size: { kind: "string", enum: OPENROUTER_IMAGE_SIZE }
+      }
+    },
+    "google/gemini-3.1-flash-image": {
+      label: "Google Gemini 3.1 Flash Image (Nano Banana 2)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: [],
+      params: {
+        formats: { kind: "json" },
+        platform: { kind: "string", enum: AD_FORMAT_PLATFORMS },
+        guidance: { kind: "string" },
+        copy: { kind: "json" },
+        safe_areas: { kind: "json" },
+        image_size: { kind: "string", enum: OPENROUTER_IMAGE_SIZE_EXTENDED }
+      }
+    }
+  },
+  video_generate: {
+    "bytedance/seedance-2.0": {
+      // Routed via Replicate's official `bytedance/seedance-2.0` model. NOTE:
+      // ByteDance's upstream likeness filter blocks photoreal human faces on ANY
+      // reseller, and it does NOT care whether the person is real: it classifies
+      // pixels, so an AI-generated face that looks photographic is refused
+      // exactly like a photograph (E005 / content_policy_blocked). Confirmed in
+      // production against faces we generated ourselves. The only escape is Veo
+      // — NOT a synthetic presenter, which an earlier version of this note
+      // wrongly recommended and which sends you round the same loop.
+      label: "ByteDance Seedance 2.0",
+      route: { provider: "replicate" },
+      billing: { kind: "formula", formula: "seedance-2.0" },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: REPLICATE_IMAGE_MIMES, max: SEEDANCE_MAX_REFERENCES }],
+      required: ["prompt"],
+      params: {
+        // Replicate's Seedance wrapper hard-caps the prompt at 4000 chars; gate
+        // it here so an over-length prompt fails validate (free) not the billed call.
+        prompt: { kind: "string", maxLength: SEEDANCE_PROMPT_MAX },
+        aspect_ratio: {
+          kind: "string",
+          enum: ["1:1", "3:4", "9:16", "4:3", "16:9", "21:9", "9:21"]
+        },
+        resolution: { kind: "string", enum: ["480p", "720p", "1080p", "4k"] },
+        duration: { kind: "number", enum: SEEDANCE_DURATIONS },
+        // Replicate types this `integer`, and a fractional seed is a schema
+        // rejection rather than a rounded one. No range is advertised, so none is
+        // invented — see `InputSpec.max` on why absent must stay ungated.
+        seed: { kind: "number", integer: true },
+        generate_audio: { kind: "boolean" }
+      }
+    },
+    "bytedance/seedance-2.5": {
+      // Seedance 2.5 — the LONG-FORM, MULTIMODAL tier, and the only curated video
+      // model reached through OpenRouter that is not frame-only.
+      //
+      // Routed through OpenRouter's video gateway (provider `seed`), NOT through
+      // Replicate like 2.0 — the gateway carries the multimodal reference surface
+      // 2.5 exists for, and Replicate's 2.0 wrapper only has `reference_images`.
+      // The backend branches on the exact 2.0 id for the Replicate path, so this
+      // model must never be folded into a `startsWith("bytedance/seedance")`
+      // routing test: that is one character away from sending 2.5 to a wrapper
+      // that cannot express half of what it is being asked to do.
+      //
+      // Same upstream likeness filter as 2.0 — ByteDance classifies PIXELS, so an
+      // AI-generated face that reads photographic is refused exactly like a
+      // photograph (content_policy_blocked). A reference-guided clip refused that
+      // way is re-rendered on fal, which serves the same model under a licence that
+      // takes faces; a frame-started one is reported, never moved to another model.
+      //
+      // No published prompt cap on this route, so none is invented: OpenRouter's
+      // request schema declares no `maxLength` and the model is sold on long,
+      // multi-shot briefs. A ceiling we made up would refuse the exact prompts
+      // this tier exists to render.
+      label: "ByteDance Seedance 2.5",
+      route: OPENROUTER_ROUTE,
+      billing: { kind: "formula", formula: "seedance-2.5" },
+      recoveryRoute: SEEDANCE_FACE_RECOVERY_ROUTE,
+      inputs: [],
+      optional_inputs: [
+        { kind: "image", mimes: OPENROUTER_IMAGE_MIMES, max: SEEDANCE_25_MAX_IMAGE_REFERENCES },
+        { kind: "video", mimes: OPENROUTER_VIDEO_REFERENCE_MIMES, max: SEEDANCE_25_MAX_VIDEO_REFERENCES },
+        { kind: "audio", mimes: OPENROUTER_AUDIO_REFERENCE_MIMES, max: SEEDANCE_25_MAX_AUDIO_REFERENCES }
+      ],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: SEEDANCE_25_ASPECT_RATIOS },
+        resolution: { kind: "string", enum: SEEDANCE_25_RESOLUTIONS },
+        duration: { kind: "number", enum: SEEDANCE_25_DURATIONS },
+        seed: { kind: "number", integer: true, min: 0, max: UINT32_MAX },
+        generate_audio: { kind: "boolean" },
+        // A visible AI watermark on an ad creative is a defect, and this is the
+        // only curated model that lets us turn one off: `watermark` is named in
+        // the model's own `allowed_passthrough_parameters`, so it rides as a
+        // top-level body field exactly like Kling's `cfg_scale` does.
+        watermark: { kind: "boolean" }
+      }
+    },
+    "google/gemini-omni-1.1-flash": {
+      // Google Gemini Omni 1.1 Flash — the DEFAULT video model. Natively
+      // multimodal: it reasons over text + images and renders video WITH
+      // synchronized audio in one call, and it is the only curated model that
+      // takes reference images through its own first-party API (task
+      // `reference_to_video`).
+      //
+      // It is a SEPARATE entry from `google/gemini-omni-flash` (the preview),
+      // not a rolling upgrade of it, because the two do not render the same
+      // things: 1.1 takes a `resolution` and the preview does not, and 1.1 bills
+      // the seconds it renders where the preview bills its whole 10s window. One
+      // shared key would have to promise the union of those, which means a canvas
+      // could ask the preview for 360p and be quoted a third of what it charges.
+      //
+      // NOT on OpenRouter. `GET /api/v1/videos/models` lists 17 video models and
+      // no Gemini Omni at either version, so this is the sanctioned direct-provider
+      // exception (see `convex/lib/geminiOmni.ts`): Google's Interactions API,
+      // `POST /v1beta/interactions`. Its own `generateContent` endpoint refuses it
+      // ("This model only supports Interactions API"), so the Veo `predictLongRunning`
+      // shape does not apply either.
+      //
+      // The param set below is deliberately short and was read off the live API,
+      // not off the docs — the knobs absent here are rejected with a pre-dispatch
+      // 400 (`Unknown parameter '<name>'`): no `seed`, no `negative_prompt`, no
+      // `generate_audio`, no `person_generation` / `enhance_prompt` /
+      // `conditioning_scale`. Audio is always on and cannot be turned off.
+      // Widening this list does not widen the model; it just moves a free
+      // validation error into a billed one.
+      //
+      // `duration` is the odd one out: Omni has no duration FIELD at any nesting
+      // level, but it honours a length named in the prompt (3-10s), so the adapter
+      // turns this param into a prompt directive. It is a real, billable knob.
+      //
+      // NO VIDEO INPUT SLOT, and that is a gate on our project rather than a gap
+      // in the model or a mistake in how we ask. 1.1 advertises video references,
+      // `edit` and `extend`, and every request carrying a video comes back 400
+      // `content_blocked`.
+      //
+      // The controlled version, run through the shape Google's own docs use
+      // (`{"type":"document","uri":<Files API uri>}`, no generation_config),
+      // changing only the uploaded file: an IMAGE returns 200 and renders a clip;
+      // a VIDEO returns `content_blocked`. Same route, same structure. So the
+      // request shape is right and video input specifically is refused. Also
+      // measured across inline base64, all three tasks, video AND text output,
+      // synthetic clips, Omni's own output, real camera footage, and both our
+      // keys. Full probe log: `.context/omni-1.1-measurements.md`.
+      //
+      // Adding `{ kind: "video", mimes: … }` below is the ONE line that turns the
+      // whole feature on — the "Build on" control, the reference picker taking an
+      // MP4, the drop target and the source-clip cost premium are all driven off
+      // this slot. Add it the day the 400 stops, not before: until then it offers
+      // a control whose every use is refused.
+      label: "Google Gemini Omni 1.1 Flash",
+      route: { provider: "google-interactions", wireModel: "gemini-omni-1.1-flash" },
+      billing: { kind: "formula", formula: "gemini-omni" },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: GEMINI_OMNI_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: GEMINI_OMNI_ASPECT_RATIOS },
+        resolution: { kind: "string", enum: GEMINI_OMNI_RESOLUTIONS },
+        duration: { kind: "number", enum: GEMINI_OMNI_DURATIONS }
+      }
+    },
+    "google/gemini-omni-flash": {
+      // LEGACY — the Omni PREVIEW (`gemini-omni-flash-preview`), superseded by
+      // `google/gemini-omni-1.1-flash` above. Kept so canvases authored before 1.1
+      // still validate and re-run unchanged (`baker canvas run --slug` restores a
+      // recorded canvas verbatim, so dropping this model would break every stored
+      // creative that used it). Don't reach for it in new work.
+      //
+      // Its param surface is the ORIGINAL one on purpose, and the omission that
+      // matters is `resolution`. This model renders 720p / 24fps and nothing else.
+      //
+      // It does NOT reject the field, which is the trap and the reason this is
+      // enforced here rather than left to the provider: asked for `360p` it
+      // returns HTTP 200, a 1280x720 clip, and a bill of 17,376 video tokens —
+      // the 720p rate, three times the 5,793 that tier costs on 1.1. Accepted,
+      // ignored, and charged for. Copying 1.1's enum across to make the two
+      // entries match would hand a canvas a quality dial that does nothing and a
+      // quote a third of the real charge.
+      label: "Google Gemini Omni Flash (legacy preview)",
+      route: { provider: "google-interactions", wireModel: "gemini-omni-flash-preview" },
+      billing: { kind: "formula", formula: "gemini-omni" },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: GEMINI_OMNI_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: GEMINI_OMNI_ASPECT_RATIOS },
+        duration: { kind: "number", enum: GEMINI_OMNI_DURATIONS }
+      }
+    },
+    "google/veo-3.1": {
+      // Photoreal CINE CEILING + the real-face fallback (Veo generates adult
+      // humans from a keyframe, dodging ByteDance's real-person filter). Same
+      // OpenRouter google-vertex routing as the fast tier; the quality dial is
+      // `resolution: 1080p` + `generate_audio` + a real `negative_prompt`, not a
+      // separate provider knob. Reach for this for hero beats and any clip that
+      // must carry a real human likeness.
+      label: "Google Veo 3.1",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        // Veo prices 4K far above the base tier, and 4K is a selectable resolution,
+        // so folding it into the base rate under-quotes the dearest clip we can make.
+        // A QUOTE only: the charge is the usage OpenRouter reports for the call.
+        usd: { silent: 0.2, audio: 0.4, byResolution: { "4K": { silent: 0.4, audio: 0.6 } } }
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        negative_prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16"] },
+        resolution: { kind: "string", enum: ["720p", "1080p", "4K"] },
+        duration: { kind: "number", enum: [4, 6, 8] },
+        // Vertex declares `seed` a uint32: "accepted range 0-4294967295".
+        seed: { kind: "number", integer: true, min: 0, max: VEO_SEED_MAX },
+        generate_audio: { kind: "boolean" },
+        person_generation: { kind: "string", enum: ["allow_all", "allow_adult"] },
+        enhance_prompt: { kind: "boolean" },
+        conditioning_scale: { kind: "number" }
+      }
+    },
+    "kwaivgi/kling-v3.0-pro": {
+      // Motion-transfer / dynamic multi-shot beats. Reachable through the default
+      // OpenRouter gateway (generic video body — no google-vertex block), so it
+      // needs no direct-provider exception. `cfg_scale` trades prompt adherence
+      // vs motion freedom; higher = closer to prompt.
+      //
+      // Params below are the ones OpenRouter actually advertises for this model
+      // (GET /api/v1/videos/models). Three were wrong before and each was a free
+      // 400 or a silently unsupported knob: it renders 720p ONLY (1080p was
+      // offered and rejected), it takes ANY duration from 3-15s (we allowed just
+      // 5 and 10), and it does not support `seed` at all.
+      label: "Kling 3.0",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        // One flat rate across every resolution and mode.
+        usd: { silent: 0.112, audio: 0.168 }
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        // Kling caps the prompt shorter than Seedance; gate it here so an
+        // over-length prompt fails validate (free) not the billed call. Its
+        // negative prompt is a SEPARATE 2,500 budget, not a shared one.
+        prompt: { kind: "string", maxLength: KLING_PROMPT_MAX },
+        negative_prompt: { kind: "string", maxLength: KLING_PROMPT_MAX },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16", "1:1"] },
+        resolution: { kind: "string", enum: ["720p"] },
+        duration: { kind: "number", enum: KLING_DURATIONS },
+        generate_audio: { kind: "boolean" },
+        cfg_scale: { kind: "number", min: 0, max: 1 }
+      }
+    },
+    "x-ai/grok-imagine-video": {
+      // The avatar workhorse. Measured best of the reference-capable models on
+      // identity retention AND aspect-ratio obedience, at the lowest rate of any
+      // video model we carry ($0.05/s at 480p). No audio at all — `generate_audio`
+      // is absent from its OpenRouter listing, so a talking head goes to Wan 2.7.
+      // NOTE: `x-ai/grok-imagine-video-1.5` is NOT a drop-in upgrade — it is
+      // described as plain image-to-video and drops the reference conditioning
+      // this entry exists for.
+      label: "Grok Imagine Video",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        usd: {
+          silent: 0.07,
+          audio: 0.07,
+          byResolution: { "480p": { silent: 0.05, audio: 0.05 }, "720p": { silent: 0.07, audio: 0.07 } }
+        }
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16", "1:1", "4:3", "3:4", "3:2", "2:3"] },
+        resolution: { kind: "string", enum: ["480p", "720p"] },
+        duration: { kind: "number", enum: GROK_IMAGINE_DURATIONS }
+      }
+    },
+    "alibaba/wan-2.7": {
+      // Reference-to-video AND native audio — the only model we carry with both,
+      // which makes it the landscape talking-head option.
+      //
+      // LANDSCAPE ONLY, measured. It advertises 9:16, 1:1, 4:3 and 3:4, and
+      // delivers 16:9 regardless: asked for vertical via `aspect_ratio: "9:16"`
+      // it returned 1280x720, and asked again via an explicit
+      // `size: "720x1280"` from its own `supported_sizes` it returned 1280x720
+      // again. The enum below is therefore what it DOES, not what it claims, so
+      // nobody pays for a vertical clip that comes back landscape. For a vertical
+      // avatar clip use `x-ai/grok-imagine-video` (silent) or animate a generated
+      // still with `google/veo-3.1-lite` (native audio, honours 9:16).
+      label: "Alibaba Wan 2.7",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        // Flat $0.10/s across resolutions and modes, audio included.
+        usd: { silent: 0.1, audio: 0.1 },
+        minBilledSeconds: MIN_BILLED_SECONDS
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        negative_prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9"] },
+        resolution: { kind: "string", enum: ["720p", "1080p"] },
+        duration: { kind: "number", enum: WAN_27_DURATIONS },
+        seed: { kind: "number" },
+        generate_audio: { kind: "boolean" }
+      }
+    },
+    "x-ai/grok-imagine-video-1.5": {
+      // NOT a replacement for the entry above, and deliberately absent from
+      // `AVATAR_VIDEO_MODELS` and `REFERENCE_TO_VIDEO_MODELS`: OpenRouter describes the
+      // older Grok as "text-, image-, and reference-conditioned" and 1.5 as taking "an
+      // optional starting image". Reference conditioning is the whole reason Grok carries
+      // avatars — it is what holds a face from the identity sheet — so swapping them
+      // would quietly cost every avatar clip its likeness.
+      //
+      // What it adds over the older one: 1080p, and 15s rather than 10.
+      label: "Grok Imagine Video 1.5",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        // `cents_per_video_output_second_*`: 8c, 14c and 25c. No audio, so both
+        // columns are the same rate rather than one being wrong.
+        usd: {
+          silent: 0.14,
+          audio: 0.14,
+          byResolution: {
+            "480p": { silent: 0.08, audio: 0.08 },
+            "720p": { silent: 0.14, audio: 0.14 },
+            "1080p": { silent: 0.25, audio: 0.25 }
+          }
+        }
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16", "1:1", "4:3", "3:4", "3:2", "2:3"] },
+        resolution: { kind: "string", enum: ["480p", "720p", "1080p"] },
+        duration: { kind: "number", enum: GROK_IMAGINE_15_DURATIONS }
+      }
+    },
+    "alibaba/wan-3.0": {
+      // 2.7's successor on every axis that matters: 2–30s against 2–10, 1080p and 480p
+      // as well as 720p, and it keeps the native audio that made 2.7 the landscape
+      // talking-head option.
+      //
+      // The ratios are what it ADVERTISES. 2.7 advertised five and delivered 16:9 for
+      // all of them — measured, twice, which is why its enum here is a single value. That
+      // was a different model and this one is not gated on its predecessor's lie, but
+      // the first vertical clip anyone renders here is worth looking at before a campaign
+      // is built on it.
+      //
+      // No `last_frame`: 2.7 takes one and 3.0 does not, so a canvas that ends a shot on
+      // a chosen frame stays on 2.7.
+      label: "Alibaba Wan 3.0",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        // Priced per resolution where 2.7 was flat, and the rate still includes
+        // audio: there is no separate audio SKU. `duration_seconds_480p|720p|1080p`.
+        usd: {
+          silent: 0.1,
+          audio: 0.1,
+          byResolution: {
+            "480p": { silent: 0.05, audio: 0.05 },
+            "720p": { silent: 0.1, audio: 0.1 },
+            "1080p": { silent: 0.2, audio: 0.2 }
+          }
+        }
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16", "1:1", "4:3", "3:4"] },
+        resolution: { kind: "string", enum: ["480p", "720p", "1080p"] },
+        duration: { kind: "number", enum: WAN_30_DURATIONS },
+        seed: { kind: "number" },
+        generate_audio: { kind: "boolean" }
+      }
+    },
+    "runway/gen-4.5": {
+      // One resolution, two shapes, and silent — `generate_audio: false` in its listing,
+      // so a talking head belongs on Wan or Omni. First frame only, no reference.
+      label: "Runway Gen-4.5",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        // One flat rate, one resolution: `cents_per_second_output: 12`. Silent.
+        usd: { silent: 0.12, audio: 0.12 }
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16"] },
+        resolution: { kind: "string", enum: ["720p"] },
+        duration: { kind: "number", enum: RUNWAY_45_DURATIONS },
+        seed: { kind: "number" }
+      }
+    },
+    "alibaba/happyhorse-1.1": {
+      // Third reference-capable option: strong identity, correct ratios, no audio.
+      // First-frame only (no `last_frame`), so it cannot close a beat on a
+      // specified end pose the way Wan and Veo can.
+      label: "Alibaba HappyHorse 1.1",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        usd: { silent: 0.1278, audio: 0.1278, byResolution: { "720p": { silent: 0.0988, audio: 0.0988 } } },
+        minBilledSeconds: MIN_BILLED_SECONDS
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16", "1:1", "4:3", "3:4", "21:9", "9:21"] },
+        resolution: { kind: "string", enum: ["720p", "1080p"] },
+        duration: { kind: "number", enum: HAPPYHORSE_DURATIONS },
+        seed: { kind: "number" }
+      }
+    },
+    "google/veo-3.1-lite": {
+      // The cheapest way to animate a still that carries a real face: same Veo
+      // family and the same escape from ByteDance's filter, at $0.05/s with audio
+      // at 720p against Veo 3.1's $0.40. That 8x is the difference between an
+      // avatar clip you iterate on and one you think twice about.
+      label: "Google Veo 3.1 Lite",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        usd: { silent: 0.05, audio: 0.08, byResolution: { "720p": { silent: 0.03, audio: 0.05 } } }
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        negative_prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16"] },
+        resolution: { kind: "string", enum: ["720p", "1080p"] },
+        duration: { kind: "number", enum: [4, 6, 8] },
+        seed: { kind: "number" },
+        generate_audio: { kind: "boolean" },
+        person_generation: { kind: "string", enum: ["allow_all", "allow_adult"] },
+        enhance_prompt: { kind: "boolean" },
+        conditioning_scale: { kind: "number" }
+      }
+    },
+    "google/veo-3.1-fast": {
+      // Cheap test/iteration model. Forwarded by the backend via
+      // `provider.options.google-vertex.parameters` (camelCased on the wire).
+      label: "Google Veo 3.1 Fast",
+      route: OPENROUTER_ROUTE,
+      billing: {
+        kind: "per_second",
+        usd: {
+          silent: 0.1,
+          audio: 0.12,
+          byResolution: { "720p": { silent: 0.08, audio: 0.1 }, "4K": { silent: 0.25, audio: 0.3 } }
+        }
+      },
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string" },
+        negative_prompt: { kind: "string" },
+        aspect_ratio: { kind: "string", enum: ["16:9", "9:16"] },
+        resolution: { kind: "string", enum: ["720p", "1080p", "4K"] },
+        duration: { kind: "number", enum: [4, 6, 8] },
+        seed: { kind: "number", integer: true, min: 0, max: VEO_SEED_MAX },
+        generate_audio: { kind: "boolean" },
+        // Image-to-video and EU/UK/CH/MENA regions cap this at `allow_adult`;
+        // `allow_all` is text-to-video only. Allow both so an image-conditioned
+        // Veo clip (the real-face fallback) validates.
+        person_generation: { kind: "string", enum: ["allow_all", "allow_adult"] },
+        enhance_prompt: { kind: "boolean" },
+        conditioning_scale: { kind: "number" }
+      }
+    }
+  },
+  video_deconstruct: {
+    // Replication-grade video extraction — the forensic system prompts live on
+    // the backend; `focus` appends emphasis only. Frames ride on a throwaway
+    // Mux asset; analysis runs on Gemini with the video as a file part.
+    "~google/gemini-flash-latest": {
+      label: "Google Gemini Flash (latest, Video)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "video", mimes: DECONSTRUCT_VIDEO_MIMES }],
+      required: [],
+      params: {
+        mode: { kind: "string", enum: ["full", "index"] },
+        language: { kind: "string" },
+        max_scenes: { kind: "number", min: 1, max: 60 },
+        focus: { kind: "string" },
+        start_s: { kind: "number", min: 0 },
+        end_s: { kind: "number", min: 0 },
+        max_clip_s: { kind: "number", min: 1, max: 60 },
+        transcriber: { kind: "string", enum: ["groq", "deepgram"] },
+        // Real visual shot-cut timestamps (seconds) from local PySceneDetect;
+        // scene boundaries snap onto them so frames never straddle a hard cut.
+        // Shape (number[]) is enforced by the node + backend Zod schemas.
+        shot_cuts: { kind: "json" }
+      }
+    },
+    "~google/gemini-pro-latest": {
+      label: "Google Gemini Pro (latest, Video)",
+      route: OPENROUTER_ROUTE,
+      billing: USAGE_BILLED,
+      inputs: [{ kind: "video", mimes: DECONSTRUCT_VIDEO_MIMES }],
+      required: [],
+      params: {
+        mode: { kind: "string", enum: ["full", "index"] },
+        language: { kind: "string" },
+        max_scenes: { kind: "number", min: 1, max: 60 },
+        focus: { kind: "string" },
+        start_s: { kind: "number", min: 0 },
+        end_s: { kind: "number", min: 0 },
+        max_clip_s: { kind: "number", min: 1, max: 60 },
+        transcriber: { kind: "string", enum: ["groq", "deepgram"] },
+        // See gemini-flash-latest above — local PySceneDetect shot-cut timestamps.
+        shot_cuts: { kind: "json" }
+      }
+    }
+  },
+  video_lipsync: {
+    // Formerly `fal/veed-lipsync`, which named a provider and a model it had stopped
+    // running on; that id stays accepted through `MODEL_ALIASES`.
+    "replicate/sync-lipsync-2": {
+      label: "Sync Labs Lipsync 2 (Replicate)",
+      route: { provider: "replicate", wireModel: "sync/lipsync-2" },
+      billing: { kind: "formula", formula: "lipsync-minutes" },
+      inputs: [
+        { kind: "video", mimes: REPLICATE_VIDEO_MIMES },
+        { kind: "audio", mimes: REPLICATE_AUDIO_MIMES }
+      ],
+      required: [],
+      params: {}
+    }
+  },
+  tts: {
+    "elevenlabs/eleven_v3": {
+      // eleven_v3 does NOT yet support context stitching
+      // (previous_text/next_text/*_request_ids). ElevenLabs returns a clean
+      // `unsupported_model` 400 if you pass them.
+      label: "ElevenLabs Eleven v3",
+      route: { provider: "elevenlabs", wireModel: "eleven_v3" },
+      billing: { kind: "formula", formula: "elevenlabs-characters" },
+      inputs: [],
+      required: ["text", "voice"],
+      params: {
+        text: { kind: "string", maxLength: ELEVENLABS_MAX_TEXT_CHARS },
+        voice: { kind: "string" },
+        language_code: { kind: "string" },
+        stability: { kind: "number", min: 0, max: 1 },
+        similarity_boost: { kind: "number", min: 0, max: 1 },
+        voice_settings: { kind: "json" },
+        seed: { kind: "number", min: 0, max: 4294967295 },
+        pronunciation_dictionary_locators: { kind: "json" },
+        apply_text_normalization: { kind: "string", enum: ["auto", "on", "off"] },
+        apply_language_text_normalization: { kind: "boolean" },
+        with_timestamps: { kind: "boolean" },
+        output_format: { kind: "string", enum: ELEVENLABS_OUTPUT_FORMATS }
+      }
+    }
+  },
+  audio_voice_convert: {
+    "elevenlabs/eleven_multilingual_sts_v2": {
+      // Speech-to-speech / Voice Changer: re-voice an existing audio clip in the
+      // TARGET voice, preserving timing/prosody. Used to normalize a talking-head
+      // clip's native (generator-chosen) voice into ONE consistent brand voice.
+      label: "ElevenLabs Voice Changer (multilingual STS v2)",
+      route: { provider: "elevenlabs", wireModel: "eleven_multilingual_sts_v2" },
+      billing: { kind: "formula", formula: "elevenlabs-voice-convert-minutes" },
+      inputs: [{ kind: "audio", mimes: REPLICATE_AUDIO_MIMES }],
+      required: ["voice"],
+      params: {
+        voice: { kind: "string" },
+        output_format: { kind: "string", enum: ELEVENLABS_OUTPUT_FORMATS },
+        remove_background_noise: { kind: "boolean" }
+      }
+    }
+  },
+  music: {
+    "elevenlabs/music-v1": {
+      label: "ElevenLabs Music v1 (Compose)",
+      route: { provider: "elevenlabs", wireModel: ELEVENLABS_MUSIC_ENGINE },
+      billing: { kind: "formula", formula: "elevenlabs-music-seconds" },
+      inputs: [],
+      required: [],
+      params: {
+        prompt: { kind: "string" },
+        composition_plan: { kind: "json" },
+        music_length_ms: { kind: "number", min: 3e3, max: ELEVENLABS_MAX_MUSIC_LENGTH_MS },
+        seed: { kind: "number" },
+        force_instrumental: { kind: "boolean" },
+        respect_sections_durations: { kind: "boolean" },
+        with_timestamps: { kind: "boolean" },
+        output_format: { kind: "string", enum: ELEVENLABS_OUTPUT_FORMATS }
+      }
+    },
+    "elevenlabs/video-background-music-v1": {
+      label: "ElevenLabs Video Background Music v1",
+      route: { provider: "elevenlabs", wireModel: ELEVENLABS_MUSIC_ENGINE },
+      billing: { kind: "formula", formula: "elevenlabs-music-seconds" },
+      inputs: [{ kind: "video", mimes: REPLICATE_VIDEO_MIMES }],
+      required: [],
+      params: {
+        description: { kind: "string" },
+        tags: { kind: "json" },
+        output_format: { kind: "string", enum: ELEVENLABS_OUTPUT_FORMATS }
+      }
+    }
+  },
+  dialogue: {
+    "elevenlabs/eleven_v3": {
+      label: "ElevenLabs Eleven v3 (Dialogue)",
+      route: { provider: "elevenlabs", wireModel: "eleven_v3" },
+      billing: { kind: "formula", formula: "elevenlabs-characters" },
+      inputs: [],
+      required: ["inputs"],
+      params: {
+        inputs: { kind: "json" },
+        language_code: { kind: "string" },
+        settings: { kind: "json" },
+        seed: { kind: "number", min: 0, max: 4294967295 },
+        apply_text_normalization: { kind: "string", enum: ["auto", "on", "off"] },
+        with_timestamps: { kind: "boolean" },
+        output_format: { kind: "string", enum: ELEVENLABS_OUTPUT_FORMATS }
+      }
+    }
+  },
+  sound_effect: {
+    "elevenlabs/eleven_text_to_sound_v2": {
+      label: "ElevenLabs Text-to-Sound v2",
+      route: { provider: "elevenlabs", wireModel: "eleven_text_to_sound_v2" },
+      billing: { kind: "formula", formula: "elevenlabs-sound-effect-seconds" },
+      inputs: [],
+      required: ["text"],
+      params: {
+        text: { kind: "string" },
+        duration_seconds: { kind: "number", min: 0.5, max: 30 },
+        prompt_influence: { kind: "number", min: 0, max: 1 },
+        loop: { kind: "boolean" },
+        output_format: { kind: "string", enum: ELEVENLABS_OUTPUT_FORMATS }
+      }
+    }
+  }
+};
+var MODEL_ALIASES = {
+  "fal/veed-lipsync": "replicate/sync-lipsync-2",
+  "fal/veed-video-background-removal": "replicate/birefnet-video",
+  "fal/birefnet-v2": "replicate/birefnet",
+  "google/gemini-3.1-flash-image-preview": "google/gemini-3.1-flash-image",
+  "google/gemini-3-pro-image-preview": "google/gemini-3-pro-image",
+  "openai/gpt-5.4-image-2": "openai/gpt-image-2.5-sunburst"
+};
+function canonicalModelId(model) {
+  return Object.keys(MODEL_ALIASES).includes(model) ? MODEL_ALIASES[model] : model;
+}
+function modelIdsAccepted(canonical) {
+  return [canonical, ...Object.keys(MODEL_ALIASES).filter((legacy) => MODEL_ALIASES[legacy] === canonical)];
+}
+function modelSpec(kind, model) {
+  return MODEL_REGISTRY[kind]?.[canonicalModelId(model)];
+}
+var NARROWED_ALIASES = ["openai/gpt-5.4-image-2"];
+function canonicalModelParams(kind, params) {
+  const model = params.model;
+  if (typeof model !== "string" || canonicalModelId(model) === model) return params;
+  const successor = canonicalModelId(model);
+  if (!NARROWED_ALIASES.includes(model)) return { ...params, model: successor };
+  const fitted = { ...params, model: successor };
+  if (typeof fitted.aspect_ratio === "string") {
+    fitted.aspect_ratio = nearestSupportedAspectRatio(kind, successor, fitted.aspect_ratio);
+  }
+  if (typeof fitted.image_size === "string") {
+    fitted.image_size = supportsParam(kind, successor, "image_size") ? nearestSupportedImageSize(kind, successor, fitted.image_size) : void 0;
+  }
+  if (typeof fitted.quality === "string") {
+    fitted.quality = bestSupportedQuality(kind, successor, fitted.quality);
+  }
+  return Object.fromEntries(Object.entries(fitted).filter(([, value]) => value !== void 0));
+}
+function perSecondBilling(model) {
+  const billing = MODEL_REGISTRY.video_generate[model]?.billing;
+  return billing?.kind === "per_second" ? billing : void 0;
+}
+var MODEL_ROLES = {
+  /** Ad frames and static-ad plates: the most faithful text and identity reproduction. */
+  adImage: { kind: "image_generate", model: "openai/gpt-image-2.5-sunburst" },
+  /**
+   * The multi-view reference sheet a recurring element is fused on. Gemini 3 Pro makes
+   * the cleanest, best-labelled turnaround, worth it for the ONE reference every frame
+   * of an ad grounds on.
+   */
+  referenceSheet: { kind: "image_reference_sheet", model: "google/gemini-3-pro-image" },
+  /** Re-framing a static ad whose copy is baked into the pixels. */
+  aspectAdapt: { kind: "image_aspect_adapt", model: "google/gemini-3-pro-image" },
+  /**
+   * The judge comparing candidate plates. Flash, not Pro: Pro measured 5 credits for
+   * one pick, a tenth of the render it judges.
+   */
+  plateJudge: { kind: "image_select", model: "~google/gemini-flash-latest" },
+  /**
+   * The static-ad blueprint extraction, and the fit of a reference to a company (`winning-ads fit`).
+   * Flash, not Pro: measured on 16 proven ads (dev, Oct 2026), Flash read as well, answered 11 describes
+   * of 12 (Pro 8: its preview model stopped answers part-way) and 16 fits of 16 (Pro 15), at under half
+   * the describe's cost and a fifth of the fit's; the fit kept or rejected the same ads 14 times of 15.
+   * A describe takes ~10 s longer (40 s), a fit ~12 s less (10 s).
+   */
+  adDescribe: { kind: "image_describe", model: "~google/gemini-flash-latest" },
+  /** The element-selection and layout passes over a blueprint. */
+  blueprintAnalysis: { kind: "text_generate", model: "~google/gemini-flash-latest" },
+  /**
+   * The viewer an ad reaches, played before a static ad renders (`baker canvas viewer-check`):
+   * says from the copy and the scene what is offered, to whom, and what to do next. Text
+   * only and asked once per ad and viewer, so Flash; the calibration set (E8) decides.
+   */
+  viewerCheck: { kind: "text_generate", model: "~google/gemini-flash-latest" },
+  /**
+   * Picks the customer truths out of reviews, testimonials and threads (`baker research
+   * customers`): returns exact spans the code then checks against the source. Text only and
+   * one call per batch, so Flash.
+   */
+  customerInsights: { kind: "text_generate", model: "~google/gemini-flash-latest" },
+  /**
+   * The same viewer shown the FINISHED static ad at phone size for about three seconds, with no
+   * brand and no brief: what is sold, whether it is for them, what to do next, what stopped them
+   * (`glance-check.ts`). One small picture per run, so Flash.
+   */
+  glanceCheck: { kind: "image_describe", model: "~google/gemini-flash-latest" },
+  /**
+   * Reads every line of text and the logo of a finished static ad WITH its box, for the
+   * copy and safe-area checks. Bench E10 (2026-09-30): word F1 0.994, box IoU 0.937, 4.3 s,
+   * about $0.005 an image on `google/gemini-3.8-flash`, which this alias resolves to;
+   * tesseract and PaddleOCR missed the 0.95 F1 gate.
+   */
+  textBoxReader: { kind: "image_describe", model: "~google/gemini-flash-latest" },
+  /**
+   * Reads where every person, face, animal and product sits in a static ad's picture, WITH its
+   * box, so each size is cut around them and its words kept off faces. The same reader and grid
+   * as `textBoxReader` (Gemini's `box_2d`), asked once per chosen picture.
+   */
+  subjectBoxReader: { kind: "image_describe", model: "~google/gemini-flash-latest" },
+  /**
+   * Compares one size of a finished static ad with its main size for what boxes cannot say: the
+   * same product and people, nothing shown twice, nobody stretched, never the main picture boxed in
+   * a bigger frame (`size-consistency.ts`). Flash: one small pair per drawn size; on 29 production
+   * pairs asked twice it flagged none and named 4 of 4 planted defects (Oct 2026).
+   */
+  sizeMatch: { kind: "image_describe", model: "~google/gemini-flash-latest" },
+  /**
+   * Scene-by-scene video extraction. Flash: ~2-3x faster per call than Pro, which keeps
+   * each per-scene step inside the action time budget.
+   */
+  videoDeconstruct: { kind: "video_deconstruct", model: "~google/gemini-flash-latest" },
+  /** The backend `image_search` agent loop that picks search tools and queries. */
+  imageSearch: { kind: "text_generate", model: "~google/gemini-flash-latest" },
+  voiceover: { kind: "tts", model: "elevenlabs/eleven_v3" },
+  soundEffect: { kind: "sound_effect", model: "elevenlabs/eleven_text_to_sound_v2" },
+  musicBed: { kind: "music", model: "elevenlabs/music-v1" },
+  /** Re-voices a talking clip's native audio into one consistent brand voice. */
+  voiceConvert: { kind: "audio_voice_convert", model: "elevenlabs/eleven_multilingual_sts_v2" },
+  /** The scored video router's candidates, one per job it can route to. */
+  videoRouterWorkhorse: { kind: "video_generate", model: "bytedance/seedance-2.0" },
+  videoRouterRealFace: { kind: "video_generate", model: "google/veo-3.1" },
+  videoRouterRealFaceEconomy: { kind: "video_generate", model: "google/veo-3.1-fast" },
+  videoRouterMotion: { kind: "video_generate", model: "kwaivgi/kling-v3.0-pro" },
+  imageDefault: { kind: "image_generate", model: DEFAULT_IMAGE_GENERATE_MODEL },
+  videoDefault: { kind: "video_generate", model: DEFAULT_VIDEO_GENERATE_MODEL },
+  avatarVideo: { kind: "video_generate", model: DEFAULT_AVATAR_VIDEO_MODEL }
+};
+var AD_IMAGE_MODEL = MODEL_ROLES.adImage.model;
+var REFERENCE_SHEET_MODEL = MODEL_ROLES.referenceSheet.model;
+var ASPECT_ADAPT_MODEL = MODEL_ROLES.aspectAdapt.model;
+var PLATE_JUDGE_MODEL = MODEL_ROLES.plateJudge.model;
+var AD_DESCRIBE_MODEL = MODEL_ROLES.adDescribe.model;
+var BLUEPRINT_ANALYSIS_MODEL = MODEL_ROLES.blueprintAnalysis.model;
+var VIEWER_CHECK_MODEL = MODEL_ROLES.viewerCheck.model;
+var CUSTOMER_INSIGHTS_MODEL = MODEL_ROLES.customerInsights.model;
+var GLANCE_CHECK_MODEL = MODEL_ROLES.glanceCheck.model;
+var TEXT_BOX_READER_MODEL = MODEL_ROLES.textBoxReader.model;
+var SUBJECT_BOX_READER_MODEL = MODEL_ROLES.subjectBoxReader.model;
+var SIZE_MATCH_MODEL = MODEL_ROLES.sizeMatch.model;
+var VIDEO_DECONSTRUCT_MODEL = MODEL_ROLES.videoDeconstruct.model;
+var IMAGE_SEARCH_MODEL = MODEL_ROLES.imageSearch.model;
+var VOICEOVER_MODEL = MODEL_ROLES.voiceover.model;
+var SOUND_EFFECT_MODEL = MODEL_ROLES.soundEffect.model;
+var MUSIC_BED_MODEL = MODEL_ROLES.musicBed.model;
+var VOICE_CONVERT_MODEL = MODEL_ROLES.voiceConvert.model;
+function isRegisteredModel(kind, model) {
+  return MODEL_REGISTRY[kind]?.[canonicalModelId(model)] !== void 0;
+}
+function imageGenerateAspectRatios() {
+  const seen = /* @__PURE__ */ new Set();
+  for (const model of IMAGE_GENERATE_MODELS) {
+    for (const ratio of supportedAspectRatios("image_generate", model) ?? []) seen.add(ratio);
+  }
+  return [...seen];
+}
+function supportsParam(kind, model, param) {
+  return modelSpec(kind, model)?.params[param] !== void 0;
+}
+var DEFAULT_CLIP_DURATION_S = 5;
+var SPOKEN_WORDS_PER_SECOND = 2.5;
+var SPOKEN_LINE = new RegExp(`(?<![\\p{L}\\p{N}])['"\\u201c\\u201d\\u2018\\u2019]((?:[^'"\\u201c\\u201d\\u2018\\u2019]|(?<=\\p{L})['\\u2019](?=\\p{L})){8,})['"\\u201c\\u201d\\u2018\\u2019](?![\\p{L}\\p{N}])`, "gu");
+function spokenWordsIn(prompt) {
+  if (!prompt) return 0;
+  const quoted = [...prompt.matchAll(SPOKEN_LINE)].map((m) => m[1] ?? "");
+  const text = quoted.join(" ").trim();
+  return text ? text.split(/\s+/).filter(Boolean).length : 0;
+}
+var SPOKEN_CLIP_DURATION_S = 8;
+function nearestClipDuration(model, preferred) {
+  const schema = MODEL_REGISTRY.video_generate[model]?.params.duration;
+  const allowed = schema?.kind === "number" ? schema.enum : void 0;
+  if (!allowed?.length || allowed.includes(preferred)) return preferred;
+  return [...allowed].sort((a, b) => Math.abs(a - preferred) - Math.abs(b - preferred) || a - b)[0];
+}
+var SILENT_VIDEO_MODELS = /* @__PURE__ */ new Set([
+  "runway/gen-4.5",
+  "x-ai/grok-imagine-video",
+  "x-ai/grok-imagine-video-1.5",
+  "alibaba/happyhorse-1.1"
+]);
+function clipAudioMode(model) {
+  if (supportsParam("video_generate", model, "generate_audio")) return "toggle";
+  return SILENT_VIDEO_MODELS.has(model) ? "never" : "always";
+}
+function clipDurationsFor(model) {
+  const schema = MODEL_REGISTRY.video_generate[model]?.params.duration;
+  const allowed = schema?.kind === "number" ? schema.enum : void 0;
+  return allowed?.length ? [...allowed].sort((a, b) => a - b) : void 0;
+}
+function maxClipSeconds(model) {
+  const allowed = clipDurationsFor(model);
+  return allowed ? allowed[allowed.length - 1] : void 0;
+}
+function splitScriptFor(words, model) {
+  const maxSeconds = maxClipSeconds(model);
+  if (!maxSeconds) return null;
+  const perClip = Math.floor(maxSeconds * SPOKEN_WORDS_PER_SECOND);
+  if (words <= perClip) return null;
+  const clips = Math.ceil(words / perClip);
+  return { clips, wordsPerClip: Math.ceil(words / clips), maxSeconds };
+}
+function promptMaxLength(kind, model) {
+  const schema = modelSpec(kind, model)?.params.prompt;
+  return schema?.kind === "string" ? schema.maxLength : void 0;
+}
+function inputSlot(kind, model, inputKind) {
+  const spec = modelSpec(kind, model);
+  return spec?.optional_inputs?.find((input) => input.kind === inputKind) ?? spec?.inputs.find((input) => input.kind === inputKind);
+}
+function maxInputSlot(kind, model, inputKind) {
+  return inputSlot(kind, model, inputKind)?.max;
+}
+function maxInputReferences(kind, model) {
+  return maxInputSlot(kind, model, "image");
+}
+function supportedQualities(kind, model) {
+  const schema = modelSpec(kind, model)?.params.quality;
+  return schema?.kind === "string" ? schema.enum : void 0;
+}
+function bestSupportedQuality(kind, model, want) {
+  const supported = supportedQualities(kind, model);
+  if (!supported) return void 0;
+  if (supported.includes(want)) return want;
+  const ladder = supported.filter((step) => step !== "auto");
+  const ceiling = ladder.indexOf(want);
+  const reachable = ceiling === -1 ? ladder : ladder.slice(0, ceiling);
+  return reachable[reachable.length - 1];
+}
+function supportedAspectRatios(kind, model) {
+  const schema = modelSpec(kind, model)?.params.aspect_ratio;
+  return schema?.kind === "string" ? schema.enum : void 0;
+}
+function ratioValue(ratio) {
+  const [w, h] = ratio.split(":").map(Number);
+  if (!w || !h || !Number.isFinite(w) || !Number.isFinite(h)) return null;
+  return w / h;
+}
+function nearestSupportedAspectRatio(kind, model, target) {
+  const supported = supportedAspectRatios(kind, model);
+  if (!supported || supported.includes(target)) return target;
+  const wanted = ratioValue(target);
+  if (wanted === null) return target;
+  let best = target;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const candidate of supported) {
+    const value = ratioValue(candidate);
+    if (value === null) continue;
+    const distance = Math.abs(Math.log(value / wanted));
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function supportedImageSizes(kind, model) {
+  const schema = modelSpec(kind, model)?.params.image_size;
+  return schema?.kind === "string" ? schema.enum : void 0;
+}
+var IMAGE_SIZE_ORDER = ["0.5K", "1K", "2K", "4K"];
+function nearestSupportedImageSize(kind, model, target) {
+  const supported = supportedImageSizes(kind, model);
+  if (!supported || supported.includes(target)) return target;
+  const wanted = IMAGE_SIZE_ORDER.indexOf(target);
+  if (wanted < 0) return target;
+  const ranked = supported.filter((s) => IMAGE_SIZE_ORDER.includes(s)).sort((a, b) => IMAGE_SIZE_ORDER.indexOf(a) - IMAGE_SIZE_ORDER.indexOf(b));
+  if (ranked.length === 0) return target;
+  const belowOrEqual = ranked.filter((s) => IMAGE_SIZE_ORDER.indexOf(s) <= wanted);
+  return belowOrEqual.length > 0 ? belowOrEqual[belowOrEqual.length - 1] : ranked[0];
+}
+
+// ../canvas-contract/src/credits.ts
+var CREDITS_PER_USD = 100;
+function usdToCredits(usd) {
+  if (!(usd > 0)) return 0;
+  return Math.ceil(Number((usd * CREDITS_PER_USD).toFixed(6)));
+}
+
+// ../canvas-contract/src/videoCost.ts
+var OPENING_FRAME_CREDITS = usdToCredits(0.03);
+var SEEDANCE_USD_PER_SECOND = {
+  "480p": 0.18,
+  "720p": 0.5,
+  "1080p": 0.62,
+  "4k": 0.62
+};
+var DEFAULT_VIDEO_RESOLUTION = "720p";
+var DEFAULT_VIDEO_DURATION_S = 5;
+function isSeedanceModel(model) {
+  return model.startsWith("bytedance/seedance");
+}
+var SEEDANCE_25_USD_PER_SECOND = {
+  "480p": 0.1075,
+  "720p": 0.2326
+};
+var SEEDANCE_25_FALLBACK_USD_PER_SECOND = 0.2326;
+function seedance25UsdPerSecond(resolution) {
+  return SEEDANCE_25_USD_PER_SECOND[resolution ?? DEFAULT_VIDEO_RESOLUTION] ?? SEEDANCE_25_FALLBACK_USD_PER_SECOND;
+}
+var FALLBACK_USD_PER_SECOND = 0.5;
+function billedSeconds(model, duration) {
+  const floor = perSecondBilling(model)?.minBilledSeconds;
+  return floor === void 0 ? duration : Math.max(duration, floor);
+}
+function seedanceUsdPerSecond(resolution) {
+  return SEEDANCE_USD_PER_SECOND[resolution ?? DEFAULT_VIDEO_RESOLUTION] ?? FALLBACK_USD_PER_SECOND;
+}
+var GEMINI_OMNI_USD_PER_1M_VIDEO_TOKENS = 17.5;
+var GEMINI_OMNI_VIDEO_TOKENS_PER_SECOND = 5792;
+var GEMINI_OMNI_RESOLUTION_MULTIPLIER = {
+  "360p": 1 / 3,
+  "720p": 1,
+  "1080p": 1.5,
+  "4k": 3
+};
+var GEMINI_OMNI_DEFAULT_RESOLUTION = "720p";
+var GEMINI_OMNI_OVERHEAD_TOKENS = 600;
+var GEMINI_OMNI_WINDOW_SECONDS = 10;
+var GEMINI_OMNI_USD_PER_SECOND = GEMINI_OMNI_VIDEO_TOKENS_PER_SECOND * GEMINI_OMNI_USD_PER_1M_VIDEO_TOKENS / 1e6;
+function geminiOmniUsdPerSecond(resolution) {
+  const multiplier = GEMINI_OMNI_RESOLUTION_MULTIPLIER[resolution ?? GEMINI_OMNI_DEFAULT_RESOLUTION] ?? 1;
+  return GEMINI_OMNI_USD_PER_SECOND * multiplier;
+}
+var VIDEO_SOURCE_COST_MULTIPLIER = 2.5;
+var FAL_SEEDANCE_USD_PER_1K_TOKENS = 0.0214;
+var SEEDANCE_SOURCE_CLIP_DISCOUNT = 0.6;
+var SEEDANCE_DEAREST_FRAME = {
+  "480p": { width: 992, height: 432 },
+  "720p": { width: 1112, height: 834 }
+};
+function falSeedanceUsdPerSecond(resolution, buildsOnSourceClip = false) {
+  const frame = SEEDANCE_DEAREST_FRAME[resolution ?? DEFAULT_VIDEO_RESOLUTION] ?? SEEDANCE_DEAREST_FRAME["720p"];
+  const tokensPerSecond = (frame?.width ?? 1112) * (frame?.height ?? 834) * 24 / 1024;
+  const rate = tokensPerSecond * FAL_SEEDANCE_USD_PER_1K_TOKENS / 1e3;
+  return buildsOnSourceClip ? rate * SEEDANCE_SOURCE_CLIP_DISCOUNT : rate;
+}
+function geminiOmniCostUsd(model, duration, resolution) {
+  const tier = isGeminiOmniPreviewModel(model) ? GEMINI_OMNI_DEFAULT_RESOLUTION : resolution;
+  const footage = geminiOmniUsdPerSecond(tier) * (duration ?? GEMINI_OMNI_WINDOW_SECONDS);
+  return footage + GEMINI_OMNI_OVERHEAD_TOKENS * GEMINI_OMNI_USD_PER_1M_VIDEO_TOKENS / 1e6;
+}
+function seedance20CostUsd(resolution, seconds, mayRouteToFal) {
+  const viaReplicate = seedanceUsdPerSecond(resolution) * seconds;
+  if (!mayRouteToFal) return viaReplicate;
+  const falTier = resolution === "480p" || resolution === "720p" ? resolution : void 0;
+  return Math.max(viaReplicate, falSeedanceUsdPerSecond(falTier) * seconds);
+}
+function estimateVideoCostUsd(input) {
+  const { model, duration, resolution, generateAudio, buildsOnSourceClip } = input;
+  const seconds = billedSeconds(model, duration ?? DEFAULT_VIDEO_DURATION_S);
+  const sourceClipPremium = buildsOnSourceClip ? VIDEO_SOURCE_COST_MULTIPLIER : 1;
+  if (isGeminiOmniModel(model)) return geminiOmniCostUsd(model, duration, resolution);
+  if (isSeedance25Model(model)) {
+    const viaOpenRouter = seedance25UsdPerSecond(resolution) * seconds * sourceClipPremium;
+    if (!input.mayRouteToFal) return viaOpenRouter;
+    return Math.max(viaOpenRouter, falSeedanceUsdPerSecond(resolution, buildsOnSourceClip) * seconds);
+  }
+  if (isSeedanceModel(model)) return seedance20CostUsd(resolution, seconds, input.mayRouteToFal === true);
+  const published = perSecondBilling(model)?.usd;
+  if (published) {
+    const rate = (resolution ? published.byResolution?.[resolution] : void 0) ?? published;
+    return (generateAudio ? rate.audio : rate.silent) * seconds;
+  }
+  const dearestKnownRate = Math.max(...Object.values(SEEDANCE_USD_PER_SECOND));
+  return dearestKnownRate * seconds;
+}
+function estimateVideoCredits(input) {
+  return usdToCredits(estimateVideoCostUsd(input));
+}
+
+// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/esm/wrapper.js
+var import__ = __toESM(require_safe_stable_stringify(), 1);
+var configure = import__.default.configure;
+var wrapper_default = import__.default;
+
+// ../canvas-contract/src/canonical.ts
+function canonicalize(value) {
+  const normalized = normalizeForCanonical(value);
+  const out = wrapper_default(normalized);
+  if (out === void 0) {
+    throw new Error("canonicalize: value serialized to undefined (top-level undefined?)");
+  }
+  return out;
+}
+function normalizeForCanonical(value) {
+  if (value === null) return null;
+  if (typeof value === "string") return value.normalize("NFC");
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`canonicalize: non-finite number ${value}`);
+    }
+    return value;
+  }
+  if (typeof value === "boolean") return value;
+  if (typeof value === "bigint") {
+    throw new Error("canonicalize: bigint not supported");
+  }
+  if (Array.isArray(value)) {
+    return value.map(normalizeForCanonical);
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === void 0) continue;
+      out[k.normalize("NFC")] = normalizeForCanonical(v);
+    }
+    return out;
+  }
+  return void 0;
+}
+
+// ../canvas-contract/src/clipWeight.ts
+var MB_PER_SECOND_720P = 2.13;
+var RESOLUTION_WEIGHT = {
+  "360p": 0.25,
+  "480p": 0.44,
+  "720p": 1,
+  "1080p": 2.25,
+  "4k": 9,
+  "4K": 9
+};
+var MAX_CLIP_INGEST_MB = 120;
+function estimateClipMb(durationSeconds, resolution) {
+  const weight = RESOLUTION_WEIGHT[resolution ?? "720p"] ?? 1;
+  return durationSeconds * MB_PER_SECOND_720P * weight;
+}
+function clipTooHeavyToIngest(durationSeconds, resolution) {
+  if (!durationSeconds) return null;
+  const mb = estimateClipMb(durationSeconds, resolution);
+  if (mb <= MAX_CLIP_INGEST_MB) return null;
+  const fits = Math.floor(MAX_CLIP_INGEST_MB / (estimateClipMb(1, resolution) || 1));
+  return `A ${durationSeconds}s clip at ${resolution ?? "720p"} comes to roughly ${Math.round(mb)} MB, more than the ${MAX_CLIP_INGEST_MB} MB we can take in \u2014 it would render, bill, and then fail on the way into the library. Shorten it to about ${fits}s at this resolution, or drop the resolution and keep the length.`;
+}
+
+// ../canvas-contract/src/frameRealism.ts
+function frameRealismDirection(opts = {}) {
+  return " Everything obeys real-world physics: paper, card and screens are OPAQUE with nothing showing through from behind, every object is at believable real-world scale next to the people handling it, and every object has its real-world form and construction \u2014 a phone has ONE screen and it is on the front." + // The worst of the three failures behind this, because the viewer reads the number: a
+  // model invents one whenever a screen or a document is in shot, and it contradicts the
+  // script it sits under. Frames simply do not get legible text; the captions carry the
+  // numbers.
+  //
+  // Default ON, and asked for explicitly rather than inferred: an ad frame with no
+  // person in it still sits under a script for an invented number to argue with. Only a
+  // plain Studio picture opts out — it has no script, and it may BE the poster somebody
+  // asked for, which the model picker sells GPT Image 2.5 on being able to render.
+  (opts.readableText === "allowed" ? "" : " NO readable text or numbers anywhere in frame \u2014 phone screens, documents and signage stay illegible or out of focus, because any figure the model invents will contradict the script.") + // Measured: one finished ad reported malformed hands or limbs in 8 of 12 sampled frames;
+  // another, a woman with an extra right arm and an unattached hand gripping a panel.
+  // Fiddly work at close range is where a video model breaks, every time.
+  " Hands are kept simple: no close-up of fingers manipulating small parts, no hand gripping the edge of an object, and each person has exactly TWO arms and TWO legs, all attached and all visible or all out of frame. Anyone working does so the way the trade actually does it: nobody stands or kneels on the equipment being installed, nothing is fitted overhanging an edge or floating unsupported, and every part rests on the structure that would really carry it." + // The newest clause, and the one no route had. A testimonial came back with the customer
+  // repairing the panel herself: nothing said she was not the installer, so the model cast
+  // her as one. Who someone IS in the picture has to be stated, or it is guessed.
+  (opts.role ? ` The person on camera is ${opts.role} \u2014 they are shown as that and never doing somebody else's job.` : "") + (opts.currency ? ` If a currency is unavoidably visible it is ${opts.currency}.` : "");
+}
+
+// ../canvas-contract/src/nodeCost.ts
+var ELEVENLABS_USD_PER_CHARACTER = 22e-5;
+var ELEVENLABS_MUSIC_USD_PER_SECOND = 0.022;
+var ELEVENLABS_SOUND_EFFECT_USD_PER_SECOND = 0.022;
+var ELEVENLABS_STS_USD_PER_MINUTE = 1e3 * ELEVENLABS_USD_PER_CHARACTER;
+var FALAI_LIPSYNC_PER_MIN_USD = 0.4;
+var FALAI_VIDEO_BG_REMOVE_REFINED_USD_PER_30_FRAMES = 0.012;
+var FALAI_VIDEO_BG_REMOVE_FAST_USD_PER_30_FRAMES = 8e-3;
+var FALAI_IMAGE_BG_REMOVE_USD_PER_CALL = 1e-3;
+var GROQ_WHISPER_COST_PER_HOUR = 0.04;
+var GROQ_WHISPER_MINIMUM_SECONDS = 10;
+var DEEPGRAM_NOVA3_COST_PER_MINUTE = 43e-4;
+var FIRECRAWL_COST_PER_SCRAPE = 1e-3;
+var DEFAULT_MUSIC_SECONDS = 30;
+var DEFAULT_SOUND_EFFECT_SECONDS = 5;
+var DEFAULT_BACKGROUND_REMOVE_SECONDS = 30;
+var DEFAULT_MEDIA_SECONDS = 60;
+function ttsCharactersUsd(characters) {
+  return characters * ELEVENLABS_USD_PER_CHARACTER;
+}
+function musicSecondsUsd(seconds) {
+  return seconds * ELEVENLABS_MUSIC_USD_PER_SECOND;
+}
+function soundEffectSecondsUsd(seconds) {
+  return seconds * ELEVENLABS_SOUND_EFFECT_USD_PER_SECOND;
+}
+function voiceConvertMinutes(durationMs) {
+  return Math.max(durationMs / 6e4, 0.1);
+}
+function voiceConvertUsd(minutes) {
+  return minutes * ELEVENLABS_STS_USD_PER_MINUTE;
+}
+function lipsyncMinutes(audioMs, videoMs) {
+  const durationMs = Math.max(audioMs ?? 0, videoMs ?? 0);
+  return durationMs > 0 ? durationMs / 6e4 : 1;
+}
+function lipsyncUsd(minutes) {
+  return minutes * FALAI_LIPSYNC_PER_MIN_USD;
+}
+function backgroundRemoveFrames(durationSeconds) {
+  return Math.max(30, Math.ceil((durationSeconds ?? DEFAULT_BACKGROUND_REMOVE_SECONDS) * 30));
+}
+function videoBackgroundRemoveUsd(durationSeconds, edgeRefinement) {
+  const unit = edgeRefinement ? FALAI_VIDEO_BG_REMOVE_REFINED_USD_PER_30_FRAMES : FALAI_VIDEO_BG_REMOVE_FAST_USD_PER_30_FRAMES;
+  return backgroundRemoveFrames(durationSeconds) / 30 * unit;
+}
+function transcriptionUsd(transcriber, seconds) {
+  if (seconds <= 0) return 0;
+  if (transcriber === "deepgram") return seconds / 60 * DEEPGRAM_NOVA3_COST_PER_MINUTE;
+  return Math.max(seconds, GROQ_WHISPER_MINIMUM_SECONDS) / 3600 * GROQ_WHISPER_COST_PER_HOUR;
+}
+function asBag(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function inputDurationMs(inputs, slot) {
+  const ref = asBag(inputs[slot]);
+  return num(ref.duration_ms) ?? num(asBag(ref.metadata).duration_ms);
+}
+function slotCount(inputs, slot) {
+  const value = inputs[slot];
+  if (Array.isArray(value)) return value.length;
+  return value ? 1 : 0;
+}
+function textLength(value) {
+  return typeof value === "string" ? value.length : 0;
+}
+function estimateVideoGenerateUsd(params, inputs, preferFal) {
+  const model = params.model;
+  if (typeof model !== "string") return null;
+  const referenceOnly = slotCount(inputs, "references") > 0 && !inputs.first_frame;
+  return estimateVideoCostUsd({
+    model,
+    duration: num(params.duration),
+    resolution: typeof params.resolution === "string" ? params.resolution : void 0,
+    generateAudio: typeof params.generate_audio === "boolean" ? params.generate_audio : void 0,
+    buildsOnSourceClip: slotCount(inputs, "video_references") > 0,
+    mayRouteToFal: isSeedanceModel(model) && (preferFal || referenceOnly)
+  });
+}
+function estimateMusicUsd(params, inputs) {
+  const pinnedMs = num(params.music_length_ms);
+  const scoredMs = params.model === "elevenlabs/video-background-music-v1" ? inputDurationMs(inputs, "video") : void 0;
+  const seconds = (pinnedMs ?? scoredMs ?? DEFAULT_MUSIC_SECONDS * 1e3) / 1e3;
+  return musicSecondsUsd(seconds);
+}
+function estimateDialogueUsd(params) {
+  if (!Array.isArray(params.inputs)) return null;
+  const characters = params.inputs.reduce((sum, line) => sum + textLength(asBag(line).text), 0);
+  return ttsCharactersUsd(characters);
+}
+function estimateNodeCostUsd(input) {
+  const params = asBag(input.params);
+  const inputs = asBag(input.inputs);
+  switch (input.nodeType) {
+    case "video_generate":
+      return estimateVideoGenerateUsd(params, inputs, input.preferFal === true);
+    case "tts":
+      return typeof params.text === "string" ? ttsCharactersUsd(params.text.length) : null;
+    case "dialogue":
+      return estimateDialogueUsd(params);
+    case "music":
+      return estimateMusicUsd(params, inputs);
+    case "sound_effect":
+      return soundEffectSecondsUsd(num(params.duration_seconds) ?? DEFAULT_SOUND_EFFECT_SECONDS);
+    case "audio_voice_convert": {
+      const ms = inputDurationMs(inputs, "audio") ?? DEFAULT_MEDIA_SECONDS * 1e3;
+      return voiceConvertUsd(voiceConvertMinutes(ms));
+    }
+    case "video_lipsync":
+      return lipsyncUsd(lipsyncMinutes(inputDurationMs(inputs, "audio"), inputDurationMs(inputs, "video")));
+    case "video_background_remove": {
+      const ms = inputDurationMs(inputs, "video");
+      return videoBackgroundRemoveUsd(ms === void 0 ? void 0 : ms / 1e3, params.edge_refinement !== false);
+    }
+    case "image_background_remove":
+      return FALAI_IMAGE_BG_REMOVE_USD_PER_CALL;
+    case "video_transcribe": {
+      const ms = inputDurationMs(inputs, "video") ?? DEFAULT_MEDIA_SECONDS * 1e3;
+      return transcriptionUsd(params.transcriber === "deepgram" ? "deepgram" : "groq", ms / 1e3);
+    }
+    case "ingest":
+      return params.strategy === "firecrawl" ? FIRECRAWL_COST_PER_SCRAPE : 0;
+    case "voice_select":
+    case "load_artifact":
+    case "save_artifact":
+    case "resize":
+    case "crop":
+      return 0;
+    default:
+      return null;
+  }
+}
+function estimateNodeCredits(input) {
+  const usd = estimateNodeCostUsd(input);
+  return usd === null ? null : usdToCredits(usd);
+}
+
+// ../canvas-contract/src/personRealism.ts
+var PHONE_CAMERA = "Shot on a phone, an iPhone or a Samsung Galaxy, with the main camera in the default photo mode (not portrait mode): slightly wide angle, held by a friend about a metre away or at arm's length, the background mostly in focus the way phone photos are, the phone's own processing \u2014 HDR evening out a bright window, a touch of over-sharpening, smoothed noise in the shadows, punchy everyday colour. Slightly imperfect framing. Not a professional camera: no bokeh or creamy background blur, no lens compression, no studio or flash lighting, no colour grade.";
+var REAL_SKIN = "Real skin and a real face: visible pores, fine lines, uneven tone, small marks, stray hairs, slight asymmetry. Clothes with real creases.";
+var NOT_A_MODEL = "Not stock photography, not a model or an influencer: no beauty retouching, no glowing or plastic skin, no perfectly symmetrical features.";
+function candidPersonPortraitPrompt(p) {
+  return [
+    `An unretouched candid phone photo of one ordinary, real person: ${p.subject}`,
+    p.wardrobe?.trim() ? `Wearing: ${p.wardrobe.trim()}` : null,
+    `Where: ${p.setting?.trim() || "an everyday place that fits who they are, in daylight"}, available light only. They look toward the lens mid-conversation with a relaxed, unposed expression. Framed from the head to mid-torso, face clearly visible.`,
+    PHONE_CAMERA,
+    REAL_SKIN,
+    NOT_A_MODEL,
+    "No text, logos or watermarks. One person only."
+  ].filter((line) => line !== null).join("\n");
+}
+
+// ../canvas-contract/src/validateParams.ts
+function isManagedNodeKind(nodeType) {
+  return Object.keys(MODEL_REGISTRY).includes(nodeType);
+}
+function checkRequiredParams(spec, params, model) {
+  const errors = [];
+  for (const req of spec.required) {
+    if (params[req] === void 0 || params[req] === null) {
+      errors.push({
+        code: "missing_required_param",
+        param: req,
+        message: `missing required param "${req}" for model "${model}"`
+      });
+    }
+  }
+  return errors;
+}
+function checkParamValues(spec, params, model) {
+  const errors = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (key === "model") continue;
+    if (value === void 0) continue;
+    const schema = spec.params[key];
+    if (!schema) {
+      errors.push({
+        code: "unknown_param",
+        param: key,
+        message: `param "${key}" is not supported by model "${model}"`
+      });
+      continue;
+    }
+    const valueErr = validateValue(key, value, schema, model);
+    if (valueErr) errors.push(valueErr);
+  }
+  return errors;
+}
+function validateModelParams(nodeType, model, params) {
+  const spec = MODEL_REGISTRY[nodeType][canonicalModelId(model)];
+  if (!spec) {
+    return {
+      ok: false,
+      errors: [{ code: "unknown_model", message: `unknown model "${model}" for node "${nodeType}"` }]
+    };
+  }
+  const fitted = canonicalModelParams(nodeType, { ...params, model });
+  const errors = [...checkRequiredParams(spec, fitted, model), ...checkParamValues(spec, fitted, model)];
+  if (errors.length > 0) return { ok: false, errors };
+  if (nodeType === "video_generate") {
+    const tooHeavy = clipTooHeavyToIngest(
+      typeof params.duration === "number" ? params.duration : void 0,
+      typeof params.resolution === "string" ? params.resolution : void 0
+    );
+    if (tooHeavy) return { ok: false, errors: [{ code: "clip_too_heavy", message: tooHeavy }] };
+  }
+  return { ok: true };
+}
+function validateModelInputs(nodeType, model, providedKinds) {
+  const spec = MODEL_REGISTRY[nodeType][canonicalModelId(model)];
+  if (!spec) {
+    return {
+      ok: false,
+      errors: [{ code: "unknown_model", message: `unknown model "${model}" for node "${nodeType}"` }]
+    };
+  }
+  const have = new Set(providedKinds);
+  const errors = [];
+  for (const inputSpec of spec.inputs) {
+    if (!have.has(inputSpec.kind)) {
+      errors.push({
+        code: "missing_input",
+        input: inputSpec.kind,
+        message: `model "${model}" requires input of kind "${inputSpec.kind}"`
+      });
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true };
+}
+function validateStringValue(key, value, schema, model) {
+  if (typeof value !== "string") {
+    return { code: "invalid_value", param: key, message: `${key}: expected string, got ${typeof value}` };
+  }
+  if (schema.enum && !schema.enum.includes(value)) {
+    return {
+      code: "invalid_value",
+      param: key,
+      message: `${key}: "${value}" not allowed by "${model}" (allowed: ${schema.enum.join(", ")})`
+    };
+  }
+  if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+    return {
+      code: "invalid_value",
+      param: key,
+      message: `${key}: ${value.length} characters exceeds max ${schema.maxLength} for "${model}"`
+    };
+  }
+  return null;
+}
+function validateNumberValue(key, value, schema, model) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return { code: "invalid_value", param: key, message: `${key}: expected number, got ${typeof value}` };
+  }
+  if (schema.enum && !schema.enum.includes(value)) {
+    return {
+      code: "invalid_value",
+      param: key,
+      message: `${key}: ${value} not allowed by "${model}" (allowed: ${schema.enum.join(", ")})`
+    };
+  }
+  if (schema.integer && !Number.isInteger(value)) {
+    return { code: "invalid_value", param: key, message: `${key}: ${value} must be a whole number` };
+  }
+  if (schema.min !== void 0 && value < schema.min) {
+    return { code: "invalid_value", param: key, message: `${key}: ${value} below min ${schema.min}` };
+  }
+  if (schema.max !== void 0 && value > schema.max) {
+    return { code: "invalid_value", param: key, message: `${key}: ${value} above max ${schema.max}` };
+  }
+  return null;
+}
+function validateValue(key, value, schema, model) {
+  switch (schema.kind) {
+    case "string":
+      return validateStringValue(key, value, schema, model);
+    case "number":
+      return validateNumberValue(key, value, schema, model);
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return { code: "invalid_value", param: key, message: `${key}: expected boolean, got ${typeof value}` };
+      }
+      return null;
+    case "json":
+      return null;
+    default: {
+      const _exhaustive = schema;
+      return _exhaustive;
+    }
+  }
+}
+
+// ../canvas-contract/src/videoBlueprint.ts
+import { z } from "zod";
+var FrameAssetSchema = z.object({ url: z.string().optional() }).loose().optional();
+var BlueprintDialogueLineSchema = z.object({
+  speaker: z.string().optional(),
+  line: z.string().optional(),
+  // Absolute seconds on the source timeline (the deconstruct emits both).
+  start_s: z.number().optional(),
+  end_s: z.number().optional(),
+  delivery: z.string().optional(),
+  voice_description: z.string().optional(),
+  // DECON-supplied: is this speaker's FACE visibly speaking in THIS scene? Element
+  // presence alone can't answer that — a founder pictured in a polaroid close-up is
+  // "present" yet the line is voiceover, and treating it as on-camera produced a
+  // native Seedance lip-sync clip of a still photograph. `false` pins the line to
+  // the VO path; absent keeps the presence-based decision (old blueprints).
+  on_camera: z.boolean().optional()
+}).loose();
+var SfxSchema = z.object({
+  at_s: z.number().optional(),
+  duration_s: z.number().optional(),
+  sound_effect_prompt: z.string().optional(),
+  description: z.string().optional()
+}).loose();
+var CompositionRegionSchema = z.object({
+  // full | top | bottom | left | right | inset
+  panel: z.string().optional(),
+  // 9-grid anchor for an `inset` presenter box.
+  position: z.string().optional(),
+  is_presenter: z.boolean().optional(),
+  // The cast id shown/speaking in this region (routes lip-sync + element refs).
+  cast_ref: z.string().optional(),
+  // What the region's content IS: camera | screen_capture | static_graphic |
+  // generated. Authoritative for routing when present (regex-over-prose fallback
+  // otherwise): screen_capture/static_graphic are rebuilt from REAL surfaces on the
+  // overlay layer, never AI-generated.
+  kind: z.string().optional(),
+  // Opaque id naming the SPECIFIC on-screen document/note/app-state this
+  // screen_capture region shows. Two scenes share it only when they show the SAME
+  // recording continuing (scrolling/typing/waiting within it) — a genuinely
+  // DIFFERENT document/note/recording (a source video splicing two screen captures)
+  // gets a different id. Breaks a persistent-layout run into separate surface stubs
+  // instead of asking the operator for one screenshot that can't cover both.
+  surface_id: z.string().optional(),
+  // Camera bubble(s)/inset(s) embedded INSIDE this region's surface (a Loom-style
+  // presenter bubble inside a screen recording) — video-in-video the reproduction
+  // must re-composite, not paint into the surface.
+  nested: z.array(z.object({}).loose()).optional(),
+  summary: z.string().optional(),
+  frame_prompt: z.string().optional(),
+  motion_prompt: z.string().optional()
+}).loose();
+var SceneCompositionSchema = z.object({
+  // full_frame (default) | split_screen | pip | keyed_overlay
+  layout: z.string().optional(),
+  // split_screen only: vertical (top/bottom) | horizontal (left/right).
+  split_axis: z.string().optional(),
+  regions: z.array(CompositionRegionSchema).optional()
+}).loose();
+var CameraMotionSchema = z.object({ movement: z.string().optional(), detail: z.string().optional() }).loose();
+var TranscriptWordSchema = z.object({ text: z.string().optional() }).loose();
+var SCENE_ROUTE_HINTS = ["brand_card"];
+var VideoSceneSchema = z.object({
+  start_s: z.number().optional(),
+  end_s: z.number().optional(),
+  duration_s: z.number().optional(),
+  summary: z.string().optional(),
+  action_detail: z.string().optional(),
+  // The scene's spatial layout. Absent/full_frame ⇒ one uncut shot (default path).
+  // A layered layout (split_screen/pip/keyed_overlay) with regions ⇒ the scaffold
+  // builds one clip per region and stacks/overlays them into the scene picture.
+  composition: SceneCompositionSchema.optional(),
+  // The capture "look" for this scene — selected from the ad-native shoot-mode
+  // grammar (the CLI's scaffold/lib/shoot-modes.ts). When absent the scaffold
+  // auto-derives a UGC/product mode; a human can override per scene by setting this.
+  shoot_mode: z.string().optional(),
+  // Diegetic ambient the clip's native audio should carry (no music). When
+  // absent the scene falls back to its shoot mode's default ambience.
+  ambient: z.string().optional(),
+  camera_motion: CameraMotionSchema.optional(),
+  start_frame_prompt: z.string().optional(),
+  end_frame_prompt: z.string().optional(),
+  motion_prompt: z.string().optional(),
+  // The scene's role in the ad's persuasion arc (DECON-supplied); drives the
+  // script re-craft checklist. Inferred from position when absent.
+  narrative_role: z.string().optional(),
+  // See `SceneRouteHint`.
+  route_hint: z.enum(SCENE_ROUTE_HINTS).optional(),
+  // DECON-supplied on the HOOK scene: the engineered physical/emotional state that
+  // makes the first frame stop the scroll (sweaty/breathless/urgent …). Injected
+  // into the hook's start-frame description so the generator renders that state,
+  // not a calm influencer (CCA-11).
+  hook_mechanic: z.object({ mechanic: z.string().optional(), why_it_stops_scroll: z.string().optional() }).loose().optional(),
+  // DECON-supplied per-scene location (so a gym hook isn't flattened to "home").
+  scene_setting: z.string().optional(),
+  // How this scene cuts to the next (DECON-supplied). A recognized non-cut type
+  // (fade/whip/zoom/dissolve/swipe) is reproduced as an ffmpeg xfade at the
+  // boundary; cut/match_cut/none/other stay hard cuts. The last scene's value is
+  // ignored (nothing follows it).
+  transition_out: z.object({ type: z.string().optional(), description: z.string().optional() }).loose().optional(),
+  dialogue: z.array(BlueprintDialogueLineSchema).optional(),
+  sfx: z.array(SfxSchema).optional(),
+  // Parsed element by element where they are read (`BlueprintOverlaySchema`,
+  // `BlueprintFloatingElementSchema`), so one malformed graphic never rejects the scene.
+  overlays: z.array(z.unknown()).optional(),
+  floating_elements: z.array(z.unknown()).optional(),
+  // DECON-supplied: how much the picture itself moves within the shot. Gates the
+  // flash-hold optimization — a sub-2s b-roll flash with REAL subject motion
+  // (pouring, spreading, hands working) must stay a real clip; freezing it turns
+  // a montage into a slideshow. Absent (old blueprints) keeps the cheap still.
+  motion_level: z.enum(["static", "subtle", "dynamic"]).optional(),
+  transcript_slice: z.array(TranscriptWordSchema).optional(),
+  start_frame_asset: FrameAssetSchema,
+  end_frame_asset: FrameAssetSchema,
+  // DECON-supplied: true when this scene is a length-split CONTINUATION of the
+  // previous one (the SAME physical shot, broken up only because it exceeded the
+  // clip ceiling). The scaffold then shares the splice keyframe — this scene's
+  // start frame IS the previous scene's end frame — so the join is seamless.
+  continues_previous: z.boolean().optional()
+}).loose();
+var VideoBlueprintSchema = z.object({
+  source: z.object({ aspect_ratio: z.string().optional(), duration_s: z.number().optional() }).loose().optional(),
+  global: z.object({
+    music: z.object({
+      present: z.boolean().optional(),
+      music_prompt: z.string().optional(),
+      // Absolute second the music enters in the reference (the bed often
+      // kicks in mid-ad, after the hook). We start the regenerated track here
+      // instead of at 0 so the timing matches.
+      starts_at_s: z.number().optional(),
+      // Populated by the deconstruct when AudD (Shazam-style) recognizes the
+      // reference track. We never reuse it — only style the regenerated bed.
+      identified_track: z.object({ title: z.string().optional(), artist: z.string().optional() }).loose().nullish()
+    }).loose().optional(),
+    cast: z.array(
+      z.object({
+        id: z.string().optional(),
+        description: z.string().optional(),
+        // The deconstruct's note on the target-market localization (e.g. "native
+        // French speaker") — read to derive the spoken-track language code.
+        market_localization_note: z.string().optional()
+      }).loose()
+    ).optional(),
+    voiceover: z.object({
+      // on_camera | mixed → mouths are on screen (lip-sync candidates);
+      // voiceover | none → narration over the picture (no lip-sync).
+      mode: z.string().optional(),
+      // Which variety of the language the speech is in. Stated because the model
+      // picks one otherwise: ads set in Spain came back in Latin American Spanish,
+      // and the pinned peninsular voice could not undo it — the re-voicing is
+      // speech-to-speech, so it carries the accent across and swaps only the timbre.
+      accent: z.string().optional(),
+      voice_description: z.string().optional(),
+      persona: z.string().optional()
+    }).loose().optional(),
+    // Visual palette — read only to colour a clean brand-card/CTA plate (the
+    // first hex is the dominant brand colour); never to drive frame generation.
+    style: z.object({ palette: z.array(z.object({ hex: z.string().optional() }).loose()).optional() }).loose().optional(),
+    // Written by `scaffold-ad` (the deconstruct names its own fields, e.g. `branding.brand_name`):
+    // the whole script as one string, where the ad is set, and the brand it closes on.
+    transcript: z.string().optional(),
+    market: z.string().optional(),
+    branding: z.object({ name: z.string().optional(), logo_path: z.string().optional() }).loose().optional()
+  }).loose().optional(),
+  // Written by `scaffold-ad`: what the beats add up to, so a short ad is caught before it renders.
+  estimated_duration_s: z.number().optional(),
+  scenes: z.array(VideoSceneSchema).min(1)
+}).loose();
+var OverlayStyleSchema = z.object({ color_hex: z.string().optional(), background: z.string().optional(), size: z.string().optional() }).loose();
+var BlueprintOverlaySchema = z.object({
+  text: z.string().optional(),
+  appears_at_s: z.number().optional(),
+  duration_s: z.number().optional(),
+  position: z.string().optional(),
+  role: z.string().optional(),
+  animation: z.string().optional(),
+  animation_detail: z.string().optional(),
+  style: OverlayStyleSchema.optional()
+}).loose();
+var BlueprintFloatingElementSchema = z.object({
+  kind: z.string().optional(),
+  description: z.string().optional(),
+  brand_name: z.string().nullish(),
+  what_it_represents: z.string().optional(),
+  appears_at_s: z.number().optional(),
+  duration_s: z.number().optional(),
+  position: z.string().optional()
+}).loose();
+
+export {
+  AD_PLATFORMS,
+  AD_PLATFORM_LEAD,
+  AD_PLACEMENTS,
+  deliveryPlan,
+  verticalCover,
+  AD_FORMAT_PLATFORMS,
+  platformFormats,
+  resolveAdaptFormats,
+  AD_DESCRIBE_FOCUS,
+  AD_SELECT_SYSTEM,
+  AD_SELECT_PROMPT,
+  canonicalize,
+  withoutCastName,
+  frameRealismDirection,
+  OPENROUTER_IMAGE_SIZES,
+  SEEDANCE_DURATIONS,
+  ELEVENLABS_OUTPUT_FORMATS,
+  ELEVENLABS_MAX_TEXT_CHARS,
+  ELEVENLABS_MAX_MUSIC_LENGTH_MS,
+  IMAGE_GENERATE_MODELS,
+  DEFAULT_IMAGE_GENERATE_MODEL,
+  IMAGE_TIER_CREDITS,
+  imagePictureCredits,
+  VIDEO_GENERATE_MODELS,
+  DEFAULT_VIDEO_GENERATE_MODEL,
+  supportsReferenceToVideo,
+  supportsLastFrame,
+  MODEL_REGISTRY,
+  canonicalModelId,
+  modelIdsAccepted,
+  MODEL_ROLES,
+  AD_IMAGE_MODEL,
+  REFERENCE_SHEET_MODEL,
+  ASPECT_ADAPT_MODEL,
+  PLATE_JUDGE_MODEL,
+  AD_DESCRIBE_MODEL,
+  BLUEPRINT_ANALYSIS_MODEL,
+  VIEWER_CHECK_MODEL,
+  CUSTOMER_INSIGHTS_MODEL,
+  GLANCE_CHECK_MODEL,
+  TEXT_BOX_READER_MODEL,
+  SUBJECT_BOX_READER_MODEL,
+  SIZE_MATCH_MODEL,
+  VIDEO_DECONSTRUCT_MODEL,
+  VOICEOVER_MODEL,
+  SOUND_EFFECT_MODEL,
+  MUSIC_BED_MODEL,
+  VOICE_CONVERT_MODEL,
+  isRegisteredModel,
+  imageGenerateAspectRatios,
+  supportsParam,
+  DEFAULT_CLIP_DURATION_S,
+  SPOKEN_WORDS_PER_SECOND,
+  spokenWordsIn,
+  SPOKEN_CLIP_DURATION_S,
+  nearestClipDuration,
+  clipAudioMode,
+  clipDurationsFor,
+  maxClipSeconds,
+  splitScriptFor,
+  promptMaxLength,
+  maxInputSlot,
+  maxInputReferences,
+  bestSupportedQuality,
+  supportedAspectRatios,
+  nearestSupportedAspectRatio,
+  nearestSupportedImageSize,
+  estimateVideoCredits,
+  DEFAULT_MUSIC_SECONDS,
+  DEFAULT_SOUND_EFFECT_SECONDS,
+  estimateNodeCredits,
+  candidPersonPortraitPrompt,
+  isManagedNodeKind,
+  validateModelParams,
+  validateModelInputs,
+  VideoBlueprintSchema,
+  BlueprintOverlaySchema,
+  BlueprintFloatingElementSchema
+};
+//# sourceMappingURL=chunk-MCJ5I5LR.js.map