@pixerate/editor 0.135.0 → 0.137.0

package/dist/chunk-I52DRGGJ.js

@@ -0,0 +1,727 @@
+// src/generation/capabilities.ts
+var REFERENCE_ROLE_NAME_REGEX = /^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$/;
+function isReferenceRoleName(value) {
+  return typeof value === "string" && value.length <= 64 && REFERENCE_ROLE_NAME_REGEX.test(value);
+}
+var REFERENCE_ROLES = [
+  "start_frame",
+  "end_frame",
+  "style_ref",
+  "character_ref",
+  "background_ref",
+  "mask",
+  "image_ref",
+  "video_ref",
+  "audio_ref"
+];
+var REFERENCE_ROLE_LABELS = {
+  start_frame: "Start frame",
+  end_frame: "End frame",
+  style_ref: "Style reference",
+  character_ref: "Character reference",
+  background_ref: "Background reference",
+  mask: "Mask",
+  image_ref: "Image reference",
+  video_ref: "Video reference",
+  audio_ref: "Audio reference"
+};
+var REFERENCE_ROLE_ALIASES = {
+  reference: "image_ref",
+  image: "image_ref",
+  style: "style_ref",
+  character: "character_ref",
+  background: "background_ref",
+  "start-frame": "start_frame",
+  "first-frame": "start_frame",
+  first_frame: "start_frame",
+  "end-frame": "end_frame",
+  "last-frame": "end_frame",
+  last_frame: "end_frame",
+  "style-ref": "style_ref",
+  "character-ref": "character_ref",
+  "background-ref": "background_ref",
+  "image-ref": "image_ref",
+  "video-ref": "video_ref",
+  "audio-ref": "audio_ref",
+  video: "video_ref",
+  audio: "audio_ref"
+};
+var isBuiltinRole = (role) => REFERENCE_ROLES.includes(role);
+function referenceRoleLabel(role, caps) {
+  const declared = caps?.references?.roles[role]?.label;
+  if (declared) return declared;
+  if (isBuiltinRole(role)) return REFERENCE_ROLE_LABELS[role];
+  const words = String(role).replace(/[_-]+/g, " ").trim();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function normalizeReferenceRole(role, caps) {
+  const name = String(role).trim();
+  if (caps ? !!caps.references?.roles[name] : isBuiltinRole(name)) return name;
+  const lower = name.toLowerCase();
+  if (caps?.references?.roles[lower]) return lower;
+  if (!caps && isBuiltinRole(lower)) return lower;
+  return REFERENCE_ROLE_ALIASES[lower] ?? (isBuiltinRole(lower) ? lower : name);
+}
+function mediaTypeMatches(mediaType, accepts) {
+  if (!accepts || accepts.length === 0) return true;
+  if (!mediaType) return false;
+  const type = mediaType.split(";")[0].trim().toLowerCase();
+  const kind = type.split("/")[0];
+  return accepts.some((entry) => {
+    const pattern = entry.trim().toLowerCase();
+    if (pattern === "*" || pattern === "*/*" || pattern === type) return true;
+    if (!pattern.includes("/")) return pattern === kind;
+    if (pattern.endsWith("/*")) return pattern.slice(0, -2) === kind;
+    return false;
+  });
+}
+var GENERATION_REQUEST_FIELDS = [
+  "model",
+  "prompt",
+  "negativePrompt",
+  "systemPrompt",
+  "aspectRatio",
+  "resolution",
+  "quality",
+  "count",
+  "duration",
+  "seed",
+  "mode",
+  "references",
+  "params"
+];
+function textFieldCapability(value) {
+  if (!value) return null;
+  return value === true ? {} : value;
+}
+function seedCapability(value) {
+  if (!value) return null;
+  return value === true ? {} : value;
+}
+function supportedReferenceRoles(caps) {
+  const roles = caps.references?.roles ?? {};
+  const builtin = REFERENCE_ROLES.filter((role) => (roles[role]?.max ?? 0) > 0);
+  const custom = Object.keys(roles).filter(
+    (role) => !isBuiltinRole(role) && isReferenceRoleName(role) && (roles[role]?.max ?? 0) > 0
+  );
+  return [...builtin, ...custom];
+}
+function supportedModes(caps) {
+  const modes = ["generate"];
+  if (caps.editing) modes.push("edit");
+  if (caps.inpainting) modes.push("inpaint");
+  return modes;
+}
+var PRESENTATION_KEYS = ["name", "description", "badges", "icon", "group"];
+function mergeCapabilities(remote, overlay = []) {
+  const overlayById = new Map(overlay.map((entry) => [entry.id, entry]));
+  const remoteIds = new Set(remote.map((model) => model.id));
+  const merged = remote.map((model) => {
+    const extra = overlayById.get(model.id);
+    if (!extra) return { ...model };
+    const next = { ...model };
+    for (const key of PRESENTATION_KEYS) {
+      if (extra[key] !== void 0) next[key] = extra[key];
+    }
+    return next;
+  });
+  for (const entry of overlay) {
+    if (remoteIds.has(entry.id) || !entry.media) continue;
+    remoteIds.add(entry.id);
+    merged.push({ ...entry });
+  }
+  return merged;
+}
+
+// src/generation/plan.ts
+var EPSILON = 1e-9;
+function aspectRatioRank(value) {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*[:x/×]\s*(\d+(?:\.\d+)?)\s*$/i.exec(String(value));
+  if (!match) return void 0;
+  const w = Number(match[1]);
+  const h = Number(match[2]);
+  if (!(w > 0) || !(h > 0)) return void 0;
+  return Math.log(w / h);
+}
+function resolutionRank(value) {
+  const text = String(value).trim().toLowerCase();
+  let pixels;
+  let match = /^(\d+(?:\.\d+)?)\s*[x×*]\s*(\d+(?:\.\d+)?)$/.exec(text);
+  if (match) pixels = Number(match[1]) * Number(match[2]);
+  else if (match = /^(\d+(?:\.\d+)?)p$/.exec(text)) pixels = Number(match[1]) ** 2 * 16 / 9;
+  else if (match = /^(\d+(?:\.\d+)?)k$/.exec(text)) pixels = (Number(match[1]) * 1024) ** 2;
+  return pixels && pixels > 0 ? Math.log(pixels) : void 0;
+}
+function resolutionMegapixels(value) {
+  const rank = resolutionRank(value);
+  return rank === void 0 ? void 0 : Math.exp(rank) / 1e6;
+}
+var QUALITY_LADDER = {
+  draft: 0,
+  preview: 0,
+  low: 1,
+  fast: 1,
+  turbo: 1,
+  standard: 2,
+  normal: 2,
+  medium: 2,
+  balanced: 2,
+  high: 3,
+  hd: 3,
+  quality: 3,
+  ultra: 4,
+  max: 5,
+  best: 5
+};
+function qualityRank(value) {
+  return QUALITY_LADDER[String(value).trim().toLowerCase()];
+}
+var numberRank = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+function snapToOption(value, options, rank, tie) {
+  const target = rank(value);
+  if (target === void 0) return void 0;
+  let best;
+  for (const option of options) {
+    const r = rank(option);
+    if (r === void 0) continue;
+    const distance = Math.abs(r - target);
+    if (!best || distance < best.distance - EPSILON || Math.abs(distance - best.distance) <= EPSILON && (tie === "lower" ? r < best.rank : r > best.rank)) {
+      best = { option, distance, rank: r };
+    }
+  }
+  return best?.option;
+}
+function truncateText(text, max) {
+  if (text.length <= max) return text;
+  let end = max;
+  const code = text.charCodeAt(end - 1);
+  if (end > 0 && code >= 55296 && code <= 56319) end -= 1;
+  return text.slice(0, end);
+}
+function cloneRequest(request) {
+  const copy = { ...request };
+  if (request.references) copy.references = request.references.map((ref) => ({ ...ref }));
+  if (request.params) copy.params = { ...request.params };
+  return copy;
+}
+var describe = (value) => typeof value === "string" ? `"${value}"` : JSON.stringify(value);
+var list = (options) => options.map(describe).join(", ");
+var Planner = class {
+  constructor(caps, request, options, strategy) {
+    this.caps = caps;
+    this.request = request;
+    this.options = options;
+    this.strategy = strategy;
+    this.tie = strategy === "downgrade" ? "lower" : "higher";
+    this.strict = strategy === "error";
+  }
+  caps;
+  request;
+  options;
+  strategy;
+  adjustments = [];
+  errors = [];
+  tie;
+  strict;
+  adjust(field, from, to, kind, reason) {
+    this.adjustments.push({ field, from, to, kind, reason });
+  }
+  error(field, value, message) {
+    this.errors.push({ field, value, message });
+  }
+  /** Removes an unsupported field (or reports it under `error`). */
+  unsupported(field, message) {
+    const value = this.request[field];
+    if (this.strict) {
+      this.error(field, value, message);
+      return;
+    }
+    delete this.request[field];
+    this.adjust(field, value, void 0, "dropped", message);
+  }
+  defaulted(field, value, set) {
+    if (!this.options.fillDefaults || value === void 0) return;
+    set();
+    this.adjust(field, void 0, value, "defaulted", "Filled with the model default.");
+  }
+  planText(field, maxLength, measured) {
+    const value = this.request[field];
+    if (value === void 0 || maxLength === void 0) return;
+    if (typeof value !== "string") {
+      this.error(field, value, `Expected text.`);
+      return;
+    }
+    const text = measured ?? value;
+    if (text.length <= maxLength) return;
+    if (this.strict || measured !== void 0) {
+      this.error(
+        field,
+        text.length,
+        `${measured !== void 0 ? "Resolved text" : "Text"} is ${text.length} characters; the model accepts at most ${maxLength}.`
+      );
+      return;
+    }
+    const next = truncateText(value, maxLength);
+    this.request[field] = next;
+    this.adjust(field, value.length, next.length, "truncated", `Truncated to the model's ${maxLength}-character limit.`);
+  }
+  planEnum(field, cap, rank, label) {
+    const value = this.request[field];
+    if (value === void 0) {
+      if (cap) this.defaulted(field, cap.default, () => this.request[field] = cap.default);
+      return;
+    }
+    if (!cap || cap.options.length === 0) {
+      this.unsupported(field, `The model does not take a ${label}.`);
+      return;
+    }
+    if (cap.options.includes(value)) return;
+    if (this.strict) {
+      this.error(field, value, `${describe(value)} is not a supported ${label}; supported: ${list(cap.options)}.`);
+      return;
+    }
+    const snapped = snapToOption(value, cap.options, rank, this.tie);
+    const next = snapped ?? cap.default ?? cap.options[0];
+    this.request[field] = next;
+    this.adjust(
+      field,
+      value,
+      next,
+      "snapped",
+      snapped !== void 0 ? `${describe(value)} is not supported; using the nearest ${label}.` : `${describe(value)} is not supported; using ${cap.default !== void 0 ? "the default" : "the first option"}.`
+    );
+  }
+  /** Clamps/rounds/snaps a number. Returns the next value or `undefined` after an error. */
+  planNumber(field, value, spec, label) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      this.error(field, value, `Expected a number for ${label}.`);
+      return void 0;
+    }
+    const options = spec.options?.filter(
+      (o) => (spec.min === void 0 || o >= spec.min) && (spec.max === void 0 || o <= spec.max)
+    );
+    if (options && options.length > 0) {
+      if (options.includes(value)) return { value, changed: false };
+      if (this.strict) {
+        this.error(field, value, `${value} is not a supported ${label}; supported: ${list(options)}.`);
+        return void 0;
+      }
+      const next2 = snapToOption(value, options, numberRank, this.tie);
+      this.adjust(field, value, next2, "snapped", `${value} is not supported; using the nearest ${label}.`);
+      return { value: next2, changed: true };
+    }
+    let next = value;
+    if (spec.step !== void 0 && spec.step > 0) {
+      const base = spec.min ?? 0;
+      const steps = (next - base) / spec.step;
+      const rounded = Math.abs(steps - Math.trunc(steps) - 0.5) < EPSILON ? this.tie === "lower" ? Math.floor(steps) : Math.ceil(steps) : Math.round(steps);
+      next = Number((base + rounded * spec.step).toPrecision(12));
+    }
+    if (spec.integer && !Number.isInteger(next)) {
+      const frac = next - Math.floor(next);
+      next = Math.abs(frac - 0.5) < EPSILON ? this.tie === "lower" ? Math.floor(next) : Math.ceil(next) : Math.round(next);
+    }
+    let kind = "snapped";
+    if (spec.min !== void 0 && next < spec.min) {
+      next = spec.min;
+      kind = "clamped";
+    }
+    if (spec.max !== void 0 && next > spec.max) {
+      next = spec.max;
+      kind = "clamped";
+    }
+    if (next === value) return { value, changed: false };
+    const range = `${spec.min ?? "-\u221E"}\u2013${spec.max ?? "\u221E"}`;
+    if (this.strict) {
+      this.error(
+        field,
+        value,
+        kind === "clamped" ? `${label} must be within ${range}.` : `${value} is not a valid ${label} (try ${next}).`
+      );
+      return void 0;
+    }
+    this.adjust(
+      field,
+      value,
+      next,
+      kind,
+      kind === "clamped" ? `Clamped to the supported range ${range}.` : `Rounded to a supported ${label}.`
+    );
+    return { value: next, changed: true };
+  }
+  planCount() {
+    const value = this.request.count;
+    const cap = this.caps.count;
+    if (value === void 0) {
+      if (cap) this.defaulted("count", cap.default, () => this.request.count = cap.default);
+      return;
+    }
+    if (!cap) {
+      if (value === 1) return;
+      this.unsupported("count", "The model produces one output per request.");
+      return;
+    }
+    const result = this.planNumber("count", value, { min: 1, max: cap.max, integer: true, options: cap.options }, "output count");
+    if (result) this.request.count = result.value;
+  }
+  planDuration() {
+    const value = this.request.duration;
+    const cap = this.caps.duration;
+    if (value === void 0) {
+      if (cap) this.defaulted("duration", cap.default, () => this.request.duration = cap.default);
+      return;
+    }
+    if (!cap) {
+      this.unsupported("duration", "The model does not take a duration.");
+      return;
+    }
+    const result = this.planNumber("duration", value, cap, "duration");
+    if (result) this.request.duration = result.value;
+  }
+  planSeed() {
+    const value = this.request.seed;
+    if (value === void 0) return;
+    const cap = seedCapability(this.caps.seed);
+    if (!cap) {
+      this.unsupported("seed", "The model does not take a seed.");
+      return;
+    }
+    const result = this.planNumber("seed", value, { ...cap, integer: true }, "seed");
+    if (result) this.request.seed = result.value;
+  }
+  planMode() {
+    const mode = this.request.mode;
+    if (mode === void 0) return;
+    const modes = supportedModes(this.caps);
+    if (!modes.includes(mode)) {
+      this.error("mode", mode, `The model does not support ${describe(mode)}; supported: ${list(modes)}.`);
+    }
+  }
+  roleCapability(role) {
+    const cap = this.caps.references?.roles[role];
+    if (cap && cap.max > 0) return cap;
+    if (role === "mask" && this.caps.inpainting) return { max: 1 };
+    return void 0;
+  }
+  /** Turns `options.mentions` into references (appended after the request's own). */
+  addMentions() {
+    const mentions = this.options.mentions;
+    if (!mentions?.length) return;
+    const refs = [...this.request.references ?? []];
+    for (const mention of mentions) {
+      if (!mention || typeof mention.id !== "string" || mention.id === "") continue;
+      let role = mention.role ?? void 0;
+      if (!role) {
+        role = this.options.defaultMentionRole ?? this.inferRole(mention.mediaType);
+        this.adjust(
+          `references.${role}`,
+          void 0,
+          role,
+          "defaulted",
+          `@${mention.label ?? mention.id} has no role; using ${role}.`
+        );
+      }
+      refs.push({
+        id: mention.id,
+        role,
+        ...mention.url !== void 0 ? { url: mention.url } : {},
+        ...mention.mediaType !== void 0 ? { mediaType: mention.mediaType } : {},
+        ...mention.contentHash !== void 0 ? { contentHash: mention.contentHash } : {}
+      });
+    }
+    this.request.references = refs;
+  }
+  /** First role of the model (other than `mask`) whose `accepts` matches `mediaType`. */
+  inferRole(mediaType) {
+    for (const role of supportedReferenceRoles(this.caps)) {
+      if (role === "mask") continue;
+      const cap = this.roleCapability(role);
+      if (cap && (mediaType === void 0 || mediaTypeMatches(mediaType, cap.accepts))) return role;
+    }
+    return "image_ref";
+  }
+  planReferences() {
+    const refs = this.request.references;
+    const allowDrop = !this.strict && (this.options.dropUnsupportedReferences ?? (this.strategy === "nearest" || this.strategy === "downgrade"));
+    const byRole = /* @__PURE__ */ new Map();
+    const kept = [];
+    const unsupported = /* @__PURE__ */ new Map();
+    for (const [index, original] of (refs ?? []).entries()) {
+      let ref = original;
+      if (!ref || typeof ref.id !== "string" || ref.id === "" || !isReferenceRoleName(ref.role)) {
+        this.error(`references.${index}`, ref, "Each reference needs an `id` and a valid `role`.");
+        continue;
+      }
+      if (!this.roleCapability(ref.role)) {
+        const alias = normalizeReferenceRole(ref.role, this.caps);
+        if (alias !== ref.role && this.roleCapability(alias)) {
+          if (this.strict) {
+            this.error(`references.${ref.role}`, ref.role, `The model calls this role ${describe(alias)}.`);
+            continue;
+          }
+          this.adjust(
+            `references.${ref.role}`,
+            ref.role,
+            alias,
+            "snapped",
+            `Using the model's ${alias} role for ${describe(ref.role)}.`
+          );
+          ref = { ...ref, role: alias };
+        } else {
+          unsupported.set(ref.role, (unsupported.get(ref.role) ?? 0) + 1);
+          continue;
+        }
+      }
+      const cap = this.roleCapability(ref.role);
+      if (ref.mediaType !== void 0 && !mediaTypeMatches(ref.mediaType, cap.accepts)) {
+        const message = `${describe(ref.id)} is ${describe(ref.mediaType)}; ${ref.role} accepts ${list(cap.accepts ?? [])}.`;
+        if (allowDrop) this.adjust(`references.${ref.role}`, ref.id, void 0, "dropped", message);
+        else this.error(`references.${ref.role}`, ref.id, message);
+        continue;
+      }
+      const group = byRole.get(ref.role) ?? [];
+      if (group.some((other) => other.id === ref.id)) {
+        this.adjust(`references.${ref.role}`, ref.id, void 0, "dropped", `Duplicate reference "${ref.id}" removed.`);
+        continue;
+      }
+      group.push(ref);
+      byRole.set(ref.role, group);
+      kept.push(ref);
+    }
+    for (const [role, count] of unsupported) {
+      const message = this.caps.media === "text" || !this.caps.references ? `The ${this.caps.media} model "${this.caps.id}" does not accept reference inputs (${role}).` : `The model does not accept ${role} references.`;
+      if (allowDrop) this.adjust(`references.${role}`, count, 0, "dropped", message);
+      else this.error(`references.${role}`, count, message);
+    }
+    const removed = /* @__PURE__ */ new Set();
+    const custom = supportedReferenceRoles(this.caps).filter(
+      (role) => !REFERENCE_ROLES.includes(role)
+    );
+    for (const role of [...REFERENCE_ROLES, ...custom]) {
+      const cap = this.roleCapability(role);
+      const group = byRole.get(role) ?? [];
+      if (!cap) continue;
+      if (group.length > cap.max) {
+        if (this.strict) {
+          this.error(`references.${role}`, group.length, `At most ${cap.max} ${role} reference(s) are supported.`);
+        } else {
+          group.slice(cap.max).forEach((ref) => removed.add(ref));
+          this.adjust(
+            `references.${role}`,
+            group.length,
+            cap.max,
+            "truncated",
+            `Kept the first ${cap.max} ${role} reference(s); the model accepts no more.`
+          );
+        }
+      }
+      if (cap.min !== void 0 && group.length < cap.min) {
+        this.error(`references.${role}`, group.length, `At least ${cap.min} ${role} reference(s) are required.`);
+      }
+    }
+    let next = kept.filter((ref) => !removed.has(ref));
+    const maxTotal = this.caps.references?.maxTotal;
+    if (maxTotal !== void 0 && next.length > maxTotal) {
+      if (this.strict) {
+        this.error("references", next.length, `At most ${maxTotal} references are supported in total.`);
+      } else {
+        this.adjust(
+          "references",
+          next.length,
+          maxTotal,
+          "truncated",
+          `Kept the first ${maxTotal} references; the model accepts no more in total.`
+        );
+        next = next.slice(0, maxTotal);
+      }
+    }
+    if (this.request.mode === "inpaint" && !next.some((ref) => ref.role === "mask")) {
+      this.error("references.mask", 0, "Inpainting needs a `mask` reference.");
+    }
+    if (refs === void 0) return;
+    if (!this.strict) {
+      if (next.length > 0) this.request.references = next;
+      else delete this.request.references;
+    }
+  }
+  planParam(name, spec, value) {
+    const field = `params.${name}`;
+    if (!spec) {
+      if (this.strict) this.error(field, value, `Unknown parameter "${name}".`);
+      else this.adjust(field, value, void 0, "dropped", `The model has no "${name}" parameter.`);
+      return void 0;
+    }
+    const label = spec.label ?? name;
+    if (spec.type === "boolean") {
+      if (typeof value !== "boolean") this.error(field, value, `Expected true or false for ${label}.`);
+      return value;
+    }
+    if (spec.type === "enum") {
+      if (spec.options.includes(value)) return value;
+      if (this.strict) {
+        this.error(field, value, `${describe(value)} is not a supported ${label}; supported: ${list(spec.options)}.`);
+        return value;
+      }
+      const numeric = spec.options.every((o) => typeof o === "number");
+      const snapped = numeric ? snapToOption(value, spec.options, numberRank, this.tie) : void 0;
+      const next = snapped ?? spec.default ?? spec.options[0];
+      this.adjust(
+        field,
+        value,
+        next,
+        "snapped",
+        snapped !== void 0 ? `Using the nearest supported ${label}.` : `${describe(value)} is not supported; using ${spec.default !== void 0 ? "the default" : "the first option"}.`
+      );
+      return next;
+    }
+    const result = this.planNumber(field, value, { ...spec, integer: spec.type === "integer" }, label);
+    return result ? result.value : value;
+  }
+  planParams() {
+    const params = this.request.params;
+    const specs = this.caps.params ?? {};
+    const next = {};
+    for (const [name, value] of Object.entries(params ?? {})) {
+      if (value === void 0) continue;
+      const planned = this.planParam(name, specs[name], value);
+      if (planned !== void 0) next[name] = planned;
+      else if (this.strict) next[name] = value;
+    }
+    if (this.options.fillDefaults) {
+      for (const [name, spec] of Object.entries(specs)) {
+        if (next[name] === void 0 && spec.default !== void 0) {
+          next[name] = spec.default;
+          this.adjust(`params.${name}`, void 0, spec.default, "defaulted", "Filled with the model default.");
+        }
+      }
+    }
+    if (Object.keys(next).length > 0) this.request.params = next;
+    else delete this.request.params;
+  }
+  run() {
+    const { caps, request } = this;
+    for (const key of Object.keys(request)) {
+      if (GENERATION_REQUEST_FIELDS.includes(key)) continue;
+      const value = request[key];
+      if (this.strict) this.error(key, value, `Unknown request field "${key}".`);
+      else {
+        delete request[key];
+        this.adjust(key, value, void 0, "dropped", `Unknown request field "${key}".`);
+      }
+    }
+    if (request.model !== void 0 && request.model !== caps.id) {
+      this.error("model", request.model, `The request targets "${request.model}" but the plan is for "${caps.id}".`);
+    }
+    request.model = caps.id;
+    const promptCap = caps.prompt ?? {};
+    if (promptCap.required && !(request.prompt ?? "").trim()) {
+      this.error("prompt", request.prompt, "A prompt is required.");
+    }
+    const countResolved = promptCap.countResolved ?? true;
+    const measured = countResolved && this.options.resolvedPrompt !== void 0 && this.options.resolvedPrompt !== request.prompt ? this.options.resolvedPrompt : void 0;
+    this.planText("prompt", promptCap.maxLength, measured);
+    for (const field of ["negativePrompt", "systemPrompt"]) {
+      if (request[field] === void 0) continue;
+      const cap = textFieldCapability(caps[field]);
+      if (!cap) {
+        this.unsupported(field, `The model does not take a ${field === "negativePrompt" ? "negative" : "system"} prompt.`);
+        continue;
+      }
+      this.planText(field, cap.maxLength);
+    }
+    this.planEnum("aspectRatio", caps.aspectRatios, aspectRatioRank, "aspect ratio");
+    this.planEnum("resolution", caps.resolutions, resolutionRank, "resolution");
+    this.planEnum("quality", caps.quality, qualityRank, "quality");
+    this.planCount();
+    this.planDuration();
+    this.planSeed();
+    this.planMode();
+    this.addMentions();
+    this.planReferences();
+    this.planParams();
+  }
+};
+function planGenerationRequest(request, caps, options = {}) {
+  const strategy = options.strategy ?? "nearest";
+  const planner = new Planner(caps, cloneRequest(request ?? {}), options, strategy);
+  planner.run();
+  return {
+    ok: planner.errors.length === 0,
+    request: planner.request,
+    adjustments: planner.adjustments,
+    errors: planner.errors,
+    model: caps.id,
+    strategy
+  };
+}
+
+// src/generation/hash.ts
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : stableStringify(item)).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.keys(value).filter((key) => value[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+var FNV_PRIME = 16777619;
+function hashText(text) {
+  let a = 2166136261;
+  let b = 789454171;
+  for (let i = 0; i < text.length; i++) {
+    const unit = text.charCodeAt(i);
+    a = Math.imul(a ^ unit & 255, FNV_PRIME);
+    a = Math.imul(a ^ unit >>> 8, FNV_PRIME);
+    b = Math.imul(b ^ unit >>> 8, FNV_PRIME);
+    b = Math.imul(b ^ unit & 255, FNV_PRIME);
+    b ^= b >>> 15;
+  }
+  a ^= a >>> 16;
+  a = Math.imul(a, 2246822507);
+  a ^= a >>> 13;
+  b ^= b >>> 16;
+  b = Math.imul(b, 3266489909);
+  b ^= b >>> 13;
+  const hex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+  return `h1-${hex(a)}${hex(b)}`;
+}
+function hashValue(value) {
+  return hashText(stableStringify(value));
+}
+var PRESENTATION_ONLY = /* @__PURE__ */ new Set(["name", "description", "badges", "icon", "group", "timing"]);
+function hashCapabilities(caps) {
+  const relevant = {};
+  for (const key of Object.keys(caps)) {
+    if (!PRESENTATION_ONLY.has(key)) relevant[key] = caps[key];
+  }
+  return hashValue(relevant);
+}
+
+export {
+  REFERENCE_ROLE_NAME_REGEX,
+  isReferenceRoleName,
+  REFERENCE_ROLES,
+  REFERENCE_ROLE_LABELS,
+  REFERENCE_ROLE_ALIASES,
+  referenceRoleLabel,
+  normalizeReferenceRole,
+  mediaTypeMatches,
+  GENERATION_REQUEST_FIELDS,
+  textFieldCapability,
+  seedCapability,
+  supportedReferenceRoles,
+  supportedModes,
+  mergeCapabilities,
+  aspectRatioRank,
+  resolutionRank,
+  resolutionMegapixels,
+  QUALITY_LADDER,
+  qualityRank,
+  snapToOption,
+  planGenerationRequest,
+  stableStringify,
+  hashText,
+  hashValue,
+  hashCapabilities
+};
+//# sourceMappingURL=chunk-I52DRGGJ.js.map