@pixerate/editor 0.22.0 → 0.24.0

package/dist/generation/index.js

@@ -0,0 +1,1373 @@
+import {
+  getLatestVersion,
+  getTemplateBody,
+  resolvePrompt,
+  tokenizePrompt
+} from "../chunk-FPENXAEJ.js";
+import "../chunk-P6ODPZ4W.js";
+import {
+  validateJsonSchema
+} from "../chunk-ARRTP33I.js";
+
+// src/generation/capabilities.ts
+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 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 ?? {};
+  return REFERENCE_ROLES.filter((role) => (roles[role]?.max ?? 0) > 0);
+}
+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;
+  }
+  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, ref] of (refs ?? []).entries()) {
+      if (!ref || typeof ref.id !== "string" || ref.id === "" || !REFERENCE_ROLES.includes(ref.role)) {
+        this.error(`references.${index}`, ref, "Each reference needs an `id` and a known `role`.");
+        continue;
+      }
+      if (!this.roleCapability(ref.role)) {
+        unsupported.set(ref.role, (unsupported.get(ref.role) ?? 0) + 1);
+        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();
+    for (const role of REFERENCE_ROLES) {
+      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.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/schema.ts
+function enumSchema(cap, description) {
+  return {
+    type: "string",
+    enum: [...cap.options],
+    ...cap.default !== void 0 ? { default: cap.default } : {},
+    description
+  };
+}
+function paramSchema(name, spec) {
+  const description = spec.description ?? spec.label ?? name;
+  if (spec.type === "boolean") {
+    return { type: "boolean", description, ...spec.default !== void 0 ? { default: spec.default } : {} };
+  }
+  if (spec.type === "enum") {
+    const numeric = spec.options.every((o) => typeof o === "number");
+    return {
+      type: numeric ? "number" : "string",
+      enum: [...spec.options],
+      description,
+      ...spec.default !== void 0 ? { default: spec.default } : {}
+    };
+  }
+  return {
+    type: spec.type,
+    description: spec.step !== void 0 ? `${description} (step ${spec.step})` : description,
+    ...spec.min !== void 0 ? { minimum: spec.min } : {},
+    ...spec.max !== void 0 ? { maximum: spec.max } : {},
+    ...spec.default !== void 0 ? { default: spec.default } : {}
+  };
+}
+function capabilitiesToJsonSchema(caps) {
+  const properties = {
+    model: { type: "string", const: caps.id, description: "Model id." }
+  };
+  const required = [];
+  const prompt = caps.prompt ?? {};
+  const countResolved = prompt.countResolved ?? true;
+  properties.prompt = {
+    type: "string",
+    description: prompt.maxLength !== void 0 ? `Prompt text. At most ${prompt.maxLength} characters${countResolved ? " after templates and variables are resolved" : ""}.` : "Prompt text.",
+    ...prompt.maxLength !== void 0 && !countResolved ? { maxLength: prompt.maxLength } : {},
+    ...prompt.required ? { minLength: 1 } : {}
+  };
+  if (prompt.required) required.push("prompt");
+  const negative = textFieldCapability(caps.negativePrompt);
+  if (negative) {
+    properties.negativePrompt = {
+      type: "string",
+      description: "What to avoid in the output.",
+      ...negative.maxLength !== void 0 ? { maxLength: negative.maxLength } : {}
+    };
+  }
+  const system = textFieldCapability(caps.systemPrompt);
+  if (system) {
+    properties.systemPrompt = {
+      type: "string",
+      description: "System instructions.",
+      ...system.maxLength !== void 0 ? { maxLength: system.maxLength } : {}
+    };
+  }
+  if (caps.aspectRatios?.options.length) properties.aspectRatio = enumSchema(caps.aspectRatios, "Aspect ratio (width:height).");
+  if (caps.resolutions?.options.length) properties.resolution = enumSchema(caps.resolutions, "Output resolution, low to high.");
+  if (caps.quality?.options.length) properties.quality = enumSchema(caps.quality, "Quality level, low to high.");
+  if (caps.count) {
+    const options = caps.count.options?.filter((o) => o >= 1 && o <= caps.count.max);
+    properties.count = options?.length ? { type: "integer", enum: options, description: "Number of outputs." } : { type: "integer", minimum: 1, maximum: caps.count.max, description: "Number of outputs." };
+    if (caps.count.default !== void 0) properties.count.default = caps.count.default;
+  }
+  if (caps.duration) {
+    const d = caps.duration;
+    const options = d.options?.filter((o) => (d.min === void 0 || o >= d.min) && (d.max === void 0 || o <= d.max));
+    properties.duration = options?.length ? { type: "number", enum: options, description: "Duration in seconds." } : {
+      type: "number",
+      description: d.step !== void 0 ? `Duration in seconds (step ${d.step}).` : "Duration in seconds.",
+      ...d.min !== void 0 ? { minimum: d.min } : {},
+      ...d.max !== void 0 ? { maximum: d.max } : {}
+    };
+    if (d.default !== void 0) properties.duration.default = d.default;
+  }
+  const seed = seedCapability(caps.seed);
+  if (seed) {
+    properties.seed = {
+      type: "integer",
+      description: "Random seed for reproducible output.",
+      ...seed.min !== void 0 ? { minimum: seed.min } : {},
+      ...seed.max !== void 0 ? { maximum: seed.max } : {}
+    };
+  }
+  const modes = supportedModes(caps);
+  if (modes.length > 1) {
+    properties.mode = { type: "string", enum: modes, default: "generate", description: "Generate, edit a source, or inpaint with a mask." };
+  }
+  const roles = supportedReferenceRoles(caps);
+  if (caps.inpainting && !roles.includes("mask")) roles.push("mask");
+  if (roles.length > 0) {
+    const limits = roles.map((role) => {
+      const cap = caps.references?.roles[role] ?? { max: 1 };
+      const min = cap.min ? `${cap.min}\u2013` : "up to ";
+      return `${role} (${cap.label ?? REFERENCE_ROLE_LABELS[role]}): ${min}${cap.max}`;
+    });
+    const perRoleTotal = roles.reduce((sum, role) => sum + (caps.references?.roles[role]?.max ?? 1), 0);
+    const maxItems = Math.min(caps.references?.maxTotal ?? Infinity, perRoleTotal);
+    properties.references = {
+      type: "array",
+      description: `Reference inputs by role. Limits: ${limits.join("; ")}${caps.references?.maxTotal !== void 0 ? `; at most ${caps.references.maxTotal} in total` : ""}.`,
+      maxItems,
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string", minLength: 1, description: "Asset id." },
+          role: { type: "string", enum: roles },
+          url: { type: "string" }
+        },
+        required: ["id", "role"],
+        additionalProperties: false
+      }
+    };
+    if (roles.some((role) => (caps.references?.roles[role]?.min ?? 0) > 0)) required.push("references");
+  }
+  const params = Object.entries(caps.params ?? {});
+  if (params.length > 0) {
+    properties.params = {
+      type: "object",
+      description: "Model-specific parameters.",
+      properties: Object.fromEntries(params.map(([name, spec]) => [name, paramSchema(name, spec)])),
+      additionalProperties: false
+    };
+  }
+  return {
+    type: "object",
+    title: caps.name ?? caps.id,
+    description: `${caps.description ? `${caps.description} ` : ""}(${caps.media} model "${caps.id}")`,
+    properties,
+    ...required.length ? { required } : {},
+    additionalProperties: false
+  };
+}
+
+// src/generation/tools.ts
+var STRATEGIES = ["nearest", "upgrade", "downgrade", "error"];
+var requestSchema = {
+  type: "object",
+  description: "Generation request. Call list_models for the fields each model supports; unsupported values are adjusted per `strategy`.",
+  properties: {
+    prompt: { type: "string" },
+    negativePrompt: { type: "string" },
+    systemPrompt: { type: "string" },
+    aspectRatio: { type: "string", description: 'E.g. "16:9".' },
+    resolution: { type: "string" },
+    quality: { type: "string" },
+    count: { type: "integer", minimum: 1 },
+    duration: { type: "number", minimum: 0, description: "Seconds." },
+    seed: { type: "integer" },
+    mode: { type: "string", enum: ["generate", "edit", "inpaint"] },
+    references: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string", minLength: 1 },
+          role: { type: "string", enum: [...REFERENCE_ROLES] },
+          url: { type: "string" }
+        },
+        required: ["id", "role"],
+        additionalProperties: false
+      }
+    },
+    params: { type: "object", additionalProperties: { type: ["string", "number", "boolean"] } }
+  },
+  additionalProperties: false
+};
+var strategySchema = {
+  type: "string",
+  enum: STRATEGIES,
+  description: "How to handle unsupported values: nearest (snap/clamp, ties up), downgrade (ties down), upgrade (ties up, never drops references), error (change nothing)."
+};
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).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";
+}
+function planFailure(plan) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: `The request cannot be sent to "${plan.model}":
+${plan.errors.map((e) => `- ${e.field}: ${e.message}`).join("\n")}`
+      }
+    ],
+    structuredContent: { error: { code: "plan_failed", message: "Request planning failed." }, plan }
+  };
+}
+function createGenerationToolProvider(options) {
+  const readModels = () => typeof options.models === "function" ? options.models() : options.models;
+  const defaultStrategy = options.defaultStrategy ?? "nearest";
+  const maxKeys = Math.max(1, options.maxIdempotencyKeys ?? 500);
+  const calls = /* @__PURE__ */ new Map();
+  const findModel = (id) => {
+    const model = readModels().find((m) => m.id === id);
+    if (!model) throw new Error(`Unknown model "${String(id)}". Call list_models for the available ids.`);
+    return model;
+  };
+  const plan = (args) => {
+    const model = findModel(args.model);
+    const request = { ...args.request ?? {}, model: model.id };
+    return {
+      model,
+      plan: planGenerationRequest(request, model, {
+        strategy: args.strategy ?? defaultStrategy,
+        resolvedPrompt: args.resolvedPrompt
+      })
+    };
+  };
+  const planInput = () => {
+    const ids = readModels().map((m) => m.id);
+    return {
+      type: "object",
+      properties: {
+        model: { type: "string", ...ids.length ? { enum: ids } : {}, description: "Model id from list_models." },
+        request: requestSchema,
+        strategy: strategySchema,
+        resolvedPrompt: {
+          type: "string",
+          description: "The prompt with templates and variables resolved, when `request.prompt` is a template."
+        }
+      },
+      required: ["model", "request"],
+      additionalProperties: false
+    };
+  };
+  const tools = () => {
+    const list2 = [
+      {
+        name: "list_models",
+        title: "List generation models",
+        description: "Lists the available generation models with their media kind, description and the JSON Schema of the request each accepts.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            media: { type: "string", enum: ["image", "video", "audio", "text"], description: "Only models of this kind." }
+          },
+          additionalProperties: false
+        },
+        annotations: {
+          title: "List generation models",
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        },
+        handler: (args) => ({
+          models: readModels().filter((m) => !args.media || m.media === args.media).map((m) => ({
+            id: m.id,
+            media: m.media,
+            ...m.name ? { name: m.name } : {},
+            ...m.description ? { description: m.description } : {},
+            ...m.badges?.length ? { badges: [...m.badges] } : {},
+            requestSchema: capabilitiesToJsonSchema(m)
+          }))
+        })
+      },
+      {
+        name: "plan_generation",
+        title: "Plan a generation request",
+        description: "Checks a request against a model without generating: returns the adjusted request, every adjustment (field, from, to, reason) and errors.",
+        inputSchema: planInput(),
+        annotations: {
+          title: "Plan a generation request",
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        },
+        handler: (args) => ({ plan: plan(args).plan })
+      }
+    ];
+    if (options.estimate) {
+      const estimate = options.estimate;
+      list2.push({
+        name: "estimate_generation",
+        title: "Estimate a generation",
+        description: "Estimates cost and/or time of a request after planning it. Does not generate anything.",
+        inputSchema: planInput(),
+        annotations: {
+          title: "Estimate a generation",
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: true
+        },
+        handler: async (args, context) => {
+          const planned = plan(args);
+          if (!planned.plan.ok) return planFailure(planned.plan);
+          const value = await estimate(planned.plan.request, { ...planned, signal: context.signal });
+          return { plan: planned.plan, estimate: value };
+        }
+      });
+    }
+    const generateInput = planInput();
+    list2.push({
+      name: "generate",
+      title: "Generate media",
+      description: "Plans the request and starts a generation. Pass a fresh `idempotencyKey` per intended generation and reuse it when retrying, so a retry never generates twice.",
+      inputSchema: {
+        ...generateInput,
+        properties: {
+          ...generateInput.properties,
+          idempotencyKey: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200,
+            description: "Unique per intended generation; reuse it to retry safely."
+          }
+        },
+        required: ["model", "request", "idempotencyKey"]
+      },
+      annotations: {
+        title: "Generate media",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      handler: async (args, context) => {
+        const key = String(args.idempotencyKey);
+        const { idempotencyKey: _key, ...rest } = args;
+        const signature = stableStringify(rest);
+        const existing = calls.get(key);
+        if (existing) {
+          if (existing.signature !== signature) {
+            throw new Error(
+              `Idempotency key "${key}" was already used with different arguments. Use a new key for a new generation.`
+            );
+          }
+          return { ...await existing.result, deduplicated: true };
+        }
+        const planned = plan(args);
+        if (!planned.plan.ok) return planFailure(planned.plan);
+        const result = Promise.resolve().then(
+          () => options.generate(planned.plan.request, {
+            ...planned,
+            idempotencyKey: key,
+            signal: context.signal
+          })
+        ).then((value) => ({
+          result: value,
+          plan: planned.plan,
+          idempotencyKey: key
+        }));
+        calls.set(key, { signature, result });
+        while (calls.size > maxKeys) calls.delete(calls.keys().next().value);
+        try {
+          return await result;
+        } catch (error) {
+          if (calls.get(key)?.result === result) calls.delete(key);
+          throw error;
+        }
+      }
+    });
+    return list2;
+  };
+  return {
+    id: options.id ?? "generation",
+    ...options.namespace ? { namespace: options.namespace } : {},
+    tools,
+    ...options.subscribe ? { subscribe: options.subscribe } : {},
+    clearIdempotencyKeys(key) {
+      if (key === void 0) calls.clear();
+      else calls.delete(key);
+    }
+  };
+}
+
+// src/generation/provenance.ts
+var PROVENANCE_FORMAT = "pixerate.generation-provenance";
+var PROVENANCE_VERSION = 1;
+var ProvenanceParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProvenanceParseError";
+  }
+};
+var toIso = (value) => new Date(value).toISOString();
+var clone = (value) => value === void 0 ? value : JSON.parse(JSON.stringify(value));
+function pinTemplates(rawPrompt, templates, bindings, maxDepth) {
+  const byName = new Map(templates.map((t) => [t.name, t]));
+  const pinned = /* @__PURE__ */ new Map();
+  const visit = (text, depth) => {
+    if (depth > maxDepth) return;
+    for (const token of tokenizePrompt(text)) {
+      if (token.type !== "template" || pinned.has(token.value)) continue;
+      const template = byName.get(token.value);
+      if (!template) continue;
+      const body = getTemplateBody(template, bindings);
+      if (body === void 0) continue;
+      const bound = bindings[template.name];
+      const version = bound && template.versions ? template.versions.find((v) => v.id === bound || v.version === bound) : getLatestVersion(template);
+      const isVersioned = !!template.versions?.length && !!version;
+      pinned.set(template.name, {
+        name: template.name,
+        ...template.id !== void 0 ? { templateId: template.id } : {},
+        ...isVersioned ? { versionId: version.id, version: version.version } : {},
+        body
+      });
+      visit(body, depth + 1);
+    }
+  };
+  visit(rawPrompt, 0);
+  return [...pinned.values()];
+}
+function pinnedTemplatesToTemplates(pinned) {
+  return pinned.map(
+    (p) => p.versionId !== void 0 ? {
+      ...p.templateId !== void 0 ? { id: p.templateId } : {},
+      name: p.name,
+      latestVersion: p.version,
+      versions: [{ id: p.versionId, version: p.version ?? p.versionId, body: p.body }]
+    } : { ...p.templateId !== void 0 ? { id: p.templateId } : {}, name: p.name, body: p.body }
+  );
+}
+function createProvenance(options) {
+  const templates = options.templates ?? [];
+  const maxDepth = options.maxDepth ?? 10;
+  const resolved = resolvePrompt(options.rawPrompt, templates, {
+    bindings: options.bindings,
+    values: options.values,
+    maxDepth
+  });
+  const pinned = pinTemplates(options.rawPrompt, templates, options.bindings ?? {}, maxDepth);
+  const bindings = {};
+  for (const p of pinned) if (p.versionId !== void 0) bindings[p.name] = p.versionId;
+  const modelId = typeof options.model === "string" ? options.model : options.model.id;
+  const request = clone(options.plan?.request ?? options.request ?? {});
+  request.model = modelId;
+  if (request.prompt === void 0) request.prompt = resolved.text;
+  const adjustments = clone(options.adjustments ?? options.plan?.adjustments ?? []);
+  return {
+    format: PROVENANCE_FORMAT,
+    version: PROVENANCE_VERSION,
+    rawPrompt: options.rawPrompt,
+    templates: pinned,
+    bindings,
+    values: options.values ? clone(options.values) : null,
+    resolvedPrompt: resolved.text,
+    sourceMap: resolved.map.map((segment) => {
+      const { locked: _locked, ...rest } = segment;
+      return rest;
+    }),
+    modelId,
+    request,
+    adjustments,
+    references: (request.references ?? []).map(({ id, role }) => ({ id, role })),
+    createdAt: toIso(options.createdAt ?? Date.now()),
+    ...options.startedAt !== void 0 ? { startedAt: toIso(options.startedAt) } : {},
+    ...options.completedAt !== void 0 ? { completedAt: toIso(options.completedAt) } : {},
+    ...options.outputIds ? { outputIds: [...options.outputIds] } : {},
+    ...options.meta ? { meta: clone(options.meta) } : {}
+  };
+}
+function serializeProvenance(provenance) {
+  return JSON.stringify(provenance);
+}
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function parseProvenance(input) {
+  let data = input;
+  if (typeof input === "string") {
+    try {
+      data = JSON.parse(input);
+    } catch {
+      throw new ProvenanceParseError("Provenance is not valid JSON.");
+    }
+  }
+  if (!isRecord(data) || data.format !== PROVENANCE_FORMAT) {
+    throw new ProvenanceParseError("Not a generation provenance record.");
+  }
+  if (typeof data.version !== "number" || data.version > PROVENANCE_VERSION) {
+    throw new ProvenanceParseError(`Unsupported provenance version ${JSON.stringify(data.version)}.`);
+  }
+  const checks = [
+    ["rawPrompt", typeof data.rawPrompt === "string"],
+    ["resolvedPrompt", typeof data.resolvedPrompt === "string"],
+    ["modelId", typeof data.modelId === "string"],
+    ["createdAt", typeof data.createdAt === "string"],
+    ["request", isRecord(data.request)],
+    ["templates", Array.isArray(data.templates) && data.templates.every((t) => isRecord(t) && typeof t.name === "string" && typeof t.body === "string")],
+    ["sourceMap", Array.isArray(data.sourceMap)],
+    ["adjustments", Array.isArray(data.adjustments)],
+    ["references", Array.isArray(data.references)]
+  ];
+  const bad = checks.find(([, ok]) => !ok);
+  if (bad) throw new ProvenanceParseError(`Invalid provenance field "${bad[0]}".`);
+  return {
+    ...data,
+    bindings: isRecord(data.bindings) ? data.bindings : {},
+    values: isRecord(data.values) ? data.values : null
+  };
+}
+function recreateRequest(provenance) {
+  const request = clone(provenance.request);
+  request.model = provenance.modelId;
+  if (request.prompt === void 0) request.prompt = provenance.resolvedPrompt;
+  return request;
+}
+function replayProvenancePrompt(provenance) {
+  const result = resolvePrompt(provenance.rawPrompt, pinnedTemplatesToTemplates(provenance.templates), {
+    bindings: provenance.bindings,
+    ...provenance.values ? { values: provenance.values } : {}
+  });
+  return { text: result.text, map: result.map, matches: result.text === provenance.resolvedPrompt };
+}
+
+// src/generation/batch.ts
+function createBatchResolver(options) {
+  const maxBatch = Math.max(1, Math.floor(options.maxBatch ?? 50));
+  const delayMs = Math.max(0, options.delayMs ?? 0);
+  const settled = /* @__PURE__ */ new Map();
+  const failures = /* @__PURE__ */ new Set();
+  const inFlight = /* @__PURE__ */ new Map();
+  let queue = [];
+  let timer = null;
+  const run = (keys) => {
+    const pendings = keys.map((key) => inFlight.get(key));
+    const finish = (values, error) => {
+      if (values === null) options.onError?.(error, keys);
+      keys.forEach((key, index) => {
+        const pending = pendings[index];
+        const value = values?.get(key);
+        if (pending && inFlight.get(key) === pending) {
+          inFlight.delete(key);
+          settled.set(key, value);
+          if (values === null) failures.add(key);
+        }
+        pending?.resolve(value);
+      });
+    };
+    let promise;
+    try {
+      promise = Promise.resolve(options.fetch(keys));
+    } catch (error) {
+      promise = Promise.reject(error);
+    }
+    promise.then(
+      (values) => finish(values instanceof Map ? values : /* @__PURE__ */ new Map()),
+      (error) => finish(null, error ?? new Error("Batch fetch failed."))
+    );
+  };
+  const flush = () => {
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+    const keys = queue;
+    queue = [];
+    for (let i = 0; i < keys.length; i += maxBatch) run(keys.slice(i, i + maxBatch));
+  };
+  const load = (key) => {
+    if (settled.has(key)) return Promise.resolve(settled.get(key));
+    const existing = inFlight.get(key);
+    if (existing) return existing.promise;
+    let resolve;
+    const promise = new Promise((r) => resolve = r);
+    inFlight.set(key, { promise, resolve });
+    queue.push(key);
+    if (queue.length >= maxBatch) flush();
+    else if (timer === null) timer = setTimeout(flush, delayMs);
+    return promise;
+  };
+  return {
+    load,
+    loadMany: (keys) => Promise.all(keys.map(load)),
+    peek: (key) => settled.get(key),
+    has: (key) => settled.has(key),
+    failed: (key) => failures.has(key),
+    prime(key, value) {
+      settled.set(key, value);
+      failures.delete(key);
+    },
+    clear(key) {
+      if (key === void 0) {
+        settled.clear();
+        failures.clear();
+        for (const k of [...inFlight.keys()]) if (!queue.includes(k)) inFlight.delete(k);
+        return;
+      }
+      settled.delete(key);
+      failures.delete(key);
+      if (!queue.includes(key)) inFlight.delete(key);
+    },
+    flush
+  };
+}
+
+// src/generation/progress.ts
+var MAX_PENDING_PERCENT = 95;
+var ALMOST_DONE_MS = 5e3;
+var UNKNOWN_DURATION_TAU_MS = 3e4;
+var toMs = (value) => typeof value === "number" ? value : new Date(value).getTime();
+function formatRemaining(ms) {
+  const seconds = Math.ceil(ms / 1e3);
+  if (seconds < 60) return `~${Math.max(1, seconds)}s left`;
+  const minutes = Math.ceil(ms / 6e4);
+  if (minutes < 60) return `~${minutes}m left`;
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return rest ? `~${hours}h ${rest}m left` : `~${hours}h left`;
+}
+function estimateJobProgress(input) {
+  const started = toMs(input.startedAt);
+  const now = toMs(input.now ?? Date.now());
+  const elapsedMs = Math.max(0, now - started);
+  if (input.done) return { percent: 100, label: "Done", elapsedMs, remainingMs: 0, overdue: false };
+  if (!Number.isFinite(started) || now <= started) {
+    return { percent: 0, label: "Starting\u2026", elapsedMs: 0, ...input.expectedMs ? { remainingMs: input.expectedMs } : {}, overdue: false };
+  }
+  const expected = input.expectedMs;
+  if (!expected || !(expected > 0)) {
+    const percent2 = MAX_PENDING_PERCENT * (1 - Math.exp(-elapsedMs / UNKNOWN_DURATION_TAU_MS));
+    return { percent: Math.floor(percent2), label: "Working\u2026", elapsedMs, overdue: false };
+  }
+  const remainingMs = Math.max(0, expected - elapsedMs);
+  const percent = Math.min(MAX_PENDING_PERCENT, Math.floor(elapsedMs / expected * 100));
+  return {
+    percent,
+    label: remainingMs <= ALMOST_DONE_MS ? "Almost done\u2026" : formatRemaining(remainingMs),
+    elapsedMs,
+    remainingMs,
+    overdue: elapsedMs > expected
+  };
+}
+function expectedDurationFor(caps, request = {}) {
+  const timing = caps.timing;
+  if (!timing) return void 0;
+  const count = request.count ?? caps.count?.default ?? 1;
+  const duration = request.duration ?? caps.duration?.default ?? 0;
+  const resolution = request.resolution ?? caps.resolutions?.default;
+  const megapixels = resolution ? resolutionMegapixels(resolution) ?? 0 : 0;
+  return Math.round(
+    timing.baseMs + (timing.perItemMs ?? 0) * Math.max(0, count - 1) + (timing.perSecondMs ?? 0) * duration + (timing.perMegapixelMs ?? 0) * megapixels
+  );
+}
+
+// src/generation/controls.ts
+function enumControl(key, label, cap) {
+  if (!cap?.options.length) return null;
+  return {
+    key,
+    label,
+    kind: "select",
+    valueType: "string",
+    options: cap.options.map((value) => ({ value, label: cap.labels?.[value] ?? value })),
+    ...cap.default !== void 0 ? { defaultValue: cap.default } : {}
+  };
+}
+function getGenerationControls(caps) {
+  const controls = [];
+  const modes = supportedModes(caps);
+  if (modes.length > 1) {
+    controls.push({
+      key: "mode",
+      label: "Mode",
+      kind: "select",
+      valueType: "string",
+      options: modes.map((m) => ({ value: m, label: m[0].toUpperCase() + m.slice(1) })),
+      defaultValue: "generate"
+    });
+  }
+  const negative = textFieldCapability(caps.negativePrompt);
+  if (negative) controls.push({ key: "negativePrompt", label: "Negative prompt", kind: "textarea", valueType: "string", maxLength: negative.maxLength });
+  const system = textFieldCapability(caps.systemPrompt);
+  if (system) controls.push({ key: "systemPrompt", label: "System prompt", kind: "textarea", valueType: "string", maxLength: system.maxLength });
+  controls.push(enumControl("aspectRatio", "Aspect ratio", caps.aspectRatios));
+  controls.push(enumControl("resolution", "Resolution", caps.resolutions));
+  controls.push(enumControl("quality", "Quality", caps.quality));
+  if (caps.count) {
+    const options = caps.count.options?.filter((o) => o >= 1 && o <= caps.count.max);
+    controls.push(
+      options?.length ? { key: "count", label: "Outputs", kind: "select", valueType: "number", options: options.map((o) => ({ value: o, label: String(o) })), defaultValue: caps.count.default } : { key: "count", label: "Outputs", kind: "range", valueType: "number", min: 1, max: caps.count.max, step: 1, defaultValue: caps.count.default ?? 1 }
+    );
+  }
+  if (caps.duration) {
+    const d = caps.duration;
+    const options = d.options?.filter((o) => (d.min === void 0 || o >= d.min) && (d.max === void 0 || o <= d.max));
+    controls.push(
+      options?.length ? { key: "duration", label: "Duration (s)", kind: "select", valueType: "number", options: options.map((o) => ({ value: o, label: `${o}s` })), defaultValue: d.default } : {
+        key: "duration",
+        label: "Duration (s)",
+        kind: d.min !== void 0 && d.max !== void 0 ? "range" : "number",
+        valueType: "number",
+        min: d.min,
+        max: d.max,
+        step: d.step,
+        defaultValue: d.default
+      }
+    );
+  }
+  const seed = seedCapability(caps.seed);
+  if (seed) controls.push({ key: "seed", label: "Seed", kind: "number", valueType: "number", min: seed.min, max: seed.max, step: 1 });
+  for (const [name, spec] of Object.entries(caps.params ?? {})) {
+    const base = { key: `params.${name}`, label: spec.label ?? name, ...spec.description ? { description: spec.description } : {} };
+    if (spec.type === "boolean") {
+      controls.push({ ...base, kind: "checkbox", valueType: "boolean", defaultValue: spec.default });
+    } else if (spec.type === "enum") {
+      const numeric = spec.options.every((o) => typeof o === "number");
+      controls.push({
+        ...base,
+        kind: "select",
+        valueType: numeric ? "number" : "string",
+        options: spec.options.map((value) => ({ value, label: String(value) })),
+        defaultValue: spec.default
+      });
+    } else {
+      controls.push({
+        ...base,
+        kind: spec.min !== void 0 && spec.max !== void 0 ? "range" : "number",
+        valueType: "number",
+        min: spec.min,
+        max: spec.max,
+        step: spec.step ?? (spec.type === "integer" ? 1 : void 0),
+        defaultValue: spec.default
+      });
+    }
+  }
+  return controls.filter((c) => c !== null);
+}
+function getRequestValue(request, key) {
+  if (key.startsWith("params.")) return request.params?.[key.slice(7)];
+  return request[key];
+}
+function setRequestValue(request, key, value) {
+  const remove = value === void 0 || value === "" || typeof value === "number" && Number.isNaN(value);
+  if (key.startsWith("params.")) {
+    const name = key.slice(7);
+    const params = { ...request.params ?? {} };
+    if (remove) delete params[name];
+    else params[name] = value;
+    const next2 = { ...request, params };
+    if (Object.keys(params).length === 0) delete next2.params;
+    return next2;
+  }
+  const next = { ...request };
+  if (remove) delete next[key];
+  else next[key] = value;
+  return next;
+}
+function parseControlValue(control, raw) {
+  if (control.valueType === "boolean") return Boolean(raw);
+  if (raw === "" || raw === void 0) return void 0;
+  if (control.valueType === "number") {
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return String(raw);
+}
+function getReferenceSlots(caps, request = {}) {
+  const roles = supportedReferenceRoles(caps);
+  if (caps.inpainting && !roles.includes("mask")) roles.push("mask");
+  const refs = request.references ?? [];
+  const total = refs.length;
+  const maxTotal = caps.references?.maxTotal ?? Infinity;
+  return roles.map((role) => {
+    const cap = caps.references?.roles[role] ?? { max: 1 };
+    const references = refs.filter((ref) => ref.role === role);
+    return {
+      role,
+      label: cap.label ?? REFERENCE_ROLE_LABELS[role],
+      ...cap.description ? { description: cap.description } : {},
+      min: cap.min ?? 0,
+      max: cap.max,
+      references,
+      canAdd: references.length < cap.max && total < maxTotal
+    };
+  });
+}
+function addReference(request, reference) {
+  return { ...request, references: [...request.references ?? [], { ...reference }] };
+}
+function removeReference(request, role, id) {
+  const references = (request.references ?? []).filter((ref) => !(ref.role === role && ref.id === id));
+  const next = { ...request, references };
+  if (references.length === 0) delete next.references;
+  return next;
+}
+export {
+  GENERATION_REQUEST_FIELDS,
+  MAX_PENDING_PERCENT,
+  PROVENANCE_FORMAT,
+  PROVENANCE_VERSION,
+  ProvenanceParseError,
+  QUALITY_LADDER,
+  REFERENCE_ROLES,
+  REFERENCE_ROLE_LABELS,
+  addReference,
+  aspectRatioRank,
+  capabilitiesToJsonSchema,
+  createBatchResolver,
+  createGenerationToolProvider,
+  createProvenance,
+  estimateJobProgress,
+  expectedDurationFor,
+  formatRemaining,
+  getGenerationControls,
+  getReferenceSlots,
+  getRequestValue,
+  mergeCapabilities,
+  parseControlValue,
+  parseProvenance,
+  pinnedTemplatesToTemplates,
+  planGenerationRequest,
+  qualityRank,
+  recreateRequest,
+  removeReference,
+  replayProvenancePrompt,
+  resolutionMegapixels,
+  resolutionRank,
+  seedCapability,
+  serializeProvenance,
+  setRequestValue,
+  snapToOption,
+  supportedModes,
+  supportedReferenceRoles,
+  textFieldCapability,
+  validateJsonSchema
+};
+//# sourceMappingURL=index.js.map