@pixerate/editor 0.23.0 → 0.25.0

package/dist/generation/index.cjs

@@ -0,0 +1,2317 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+
+var _chunkFD4LPFAEcjs = require('../chunk-FD4LPFAE.cjs');
+require('../chunk-MKA3AHLV.cjs');
+
+
+var _chunkCPOKFNBGcjs = require('../chunk-CPOKFNBG.cjs');
+
+
+
+
+var _chunkBVP3TSLHcjs = require('../chunk-BVP3TSLH.cjs');
+
+// 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 = _optionalChain([caps, 'optionalAccess', _ => _.references, 'optionalAccess', _2 => _2.roles, 'access', _3 => _3[role], 'optionalAccess', _4 => _4.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 ? !!_optionalChain([caps, 'access', _5 => _5.references, 'optionalAccess', _6 => _6.roles, 'access', _7 => _7[name]]) : isBuiltinRole(name)) return name;
+  const lower = name.toLowerCase();
+  if (_optionalChain([caps, 'optionalAccess', _8 => _8.references, 'optionalAccess', _9 => _9.roles, 'access', _10 => _10[lower]])) return lower;
+  if (!caps && isBuiltinRole(lower)) return lower;
+  return _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([caps, 'access', _11 => _11.references, 'optionalAccess', _12 => _12.roles]), () => ( {}));
+  const builtin = REFERENCE_ROLES.filter((role) => (_nullishCoalesce(_optionalChain([roles, 'access', _13 => _13[role], 'optionalAccess', _14 => _14.max]), () => ( 0))) > 0);
+  const custom = Object.keys(roles).filter(
+    (role) => !isBuiltinRole(role) && isReferenceRoleName(role) && (_nullishCoalesce(_optionalChain([roles, 'access', _15 => _15[role], 'optionalAccess', _16 => _16.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 _optionalChain([best, 'optionalAccess', _17 => _17.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 = class {
+  constructor(caps, request, options, strategy) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.caps = caps;
+    this.request = request;
+    this.options = options;
+    this.strategy = strategy;
+    this.tie = strategy === "downgrade" ? "lower" : "higher";
+    this.strict = strategy === "error";
+  }
+  
+  
+  
+  
+  __init() {this.adjustments = []}
+  __init2() {this.errors = []}
+  
+  
+  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 = _nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(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 = _optionalChain([spec, 'access', _18 => _18.options, 'optionalAccess', _19 => _19.filter, 'call', _20 => _20(
+      (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 = _nullishCoalesce(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 = `${_nullishCoalesce(spec.min, () => ( "-\u221E"))}\u2013${_nullishCoalesce(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 = _optionalChain([this, 'access', _21 => _21.caps, 'access', _22 => _22.references, 'optionalAccess', _23 => _23.roles, 'access', _24 => _24[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 (!_optionalChain([mentions, 'optionalAccess', _25 => _25.length])) return;
+    const refs = [..._nullishCoalesce(this.request.references, () => ( []))];
+    for (const mention of mentions) {
+      if (!mention || typeof mention.id !== "string" || mention.id === "") continue;
+      let role = _nullishCoalesce(mention.role, () => ( void 0));
+      if (!role) {
+        role = _nullishCoalesce(this.options.defaultMentionRole, () => ( this.inferRole(mention.mediaType)));
+        this.adjust(
+          `references.${role}`,
+          void 0,
+          role,
+          "defaulted",
+          `@${_nullishCoalesce(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 && (_nullishCoalesce(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 (_nullishCoalesce(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, (_nullishCoalesce(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(_nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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 = _optionalChain([this, 'access', _26 => _26.caps, 'access', _27 => _27.references, 'optionalAccess', _28 => _28.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 = _nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(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 = _nullishCoalesce(this.caps.params, () => ( {}));
+    const next = {};
+    for (const [name, value] of Object.entries(_nullishCoalesce(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 = _nullishCoalesce(caps.prompt, () => ( {}));
+    if (promptCap.required && !(_nullishCoalesce(request.prompt, () => ( ""))).trim()) {
+      this.error("prompt", request.prompt, "A prompt is required.");
+    }
+    const countResolved = _nullishCoalesce(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();
+  }
+}, _class);
+function planGenerationRequest(request, caps, options = {}) {
+  const strategy = _nullishCoalesce(options.strategy, () => ( "nearest"));
+  const planner = new Planner(caps, cloneRequest(_nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(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 = _nullishCoalesce(caps.prompt, () => ( {}));
+  const countResolved = _nullishCoalesce(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 (_optionalChain([caps, 'access', _29 => _29.aspectRatios, 'optionalAccess', _30 => _30.options, 'access', _31 => _31.length])) properties.aspectRatio = enumSchema(caps.aspectRatios, "Aspect ratio (width:height).");
+  if (_optionalChain([caps, 'access', _32 => _32.resolutions, 'optionalAccess', _33 => _33.options, 'access', _34 => _34.length])) properties.resolution = enumSchema(caps.resolutions, "Output resolution, low to high.");
+  if (_optionalChain([caps, 'access', _35 => _35.quality, 'optionalAccess', _36 => _36.options, 'access', _37 => _37.length])) properties.quality = enumSchema(caps.quality, "Quality level, low to high.");
+  if (caps.count) {
+    const options = _optionalChain([caps, 'access', _38 => _38.count, 'access', _39 => _39.options, 'optionalAccess', _40 => _40.filter, 'call', _41 => _41((o) => o >= 1 && o <= caps.count.max)]);
+    properties.count = _optionalChain([options, 'optionalAccess', _42 => _42.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 = _optionalChain([d, 'access', _43 => _43.options, 'optionalAccess', _44 => _44.filter, 'call', _45 => _45((o) => (d.min === void 0 || o >= d.min) && (d.max === void 0 || o <= d.max))]);
+    properties.duration = _optionalChain([options, 'optionalAccess', _46 => _46.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 = _nullishCoalesce(_optionalChain([caps, 'access', _47 => _47.references, 'optionalAccess', _48 => _48.roles, 'access', _49 => _49[role]]), () => ( { max: 1 }));
+      const min = cap.min ? `${cap.min}\u2013` : "up to ";
+      const accepts = "accepts" in cap && _optionalChain([cap, 'access', _50 => _50.accepts, 'optionalAccess', _51 => _51.length]) ? `, ${cap.accepts.join("/")} only` : "";
+      return `${role} (${referenceRoleLabel(role, caps)}): ${min}${cap.max}${accepts}`;
+    });
+    const perRoleTotal = roles.reduce((sum, role) => sum + (_nullishCoalesce(_optionalChain([caps, 'access', _52 => _52.references, 'optionalAccess', _53 => _53.roles, 'access', _54 => _54[role], 'optionalAccess', _55 => _55.max]), () => ( 1))), 0);
+    const maxItems = Math.min(_nullishCoalesce(_optionalChain([caps, 'access', _56 => _56.references, 'optionalAccess', _57 => _57.maxTotal]), () => ( Infinity)), perRoleTotal);
+    properties.references = {
+      type: "array",
+      description: `Reference inputs by role. Limits: ${limits.join("; ")}${_optionalChain([caps, 'access', _58 => _58.references, 'optionalAccess', _59 => _59.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" },
+          mediaType: { type: "string", description: 'MIME type or media kind of the asset, e.g. "image/png".' },
+          contentHash: { type: "string" }
+        },
+        required: ["id", "role"],
+        additionalProperties: false
+      }
+    };
+    if (roles.some((role) => (_nullishCoalesce(_optionalChain([caps, 'access', _60 => _60.references, 'optionalAccess', _61 => _61.roles, 'access', _62 => _62[role], 'optionalAccess', _63 => _63.min]), () => ( 0))) > 0)) required.push("references");
+  }
+  const params = Object.entries(_nullishCoalesce(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: _nullishCoalesce(caps.name, () => ( caps.id)),
+    description: `${caps.description ? `${caps.description} ` : ""}(${caps.media} model "${caps.id}")`,
+    properties,
+    ...required.length ? { required } : {},
+    additionalProperties: false
+  };
+}
+
+// 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 _nullishCoalesce(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);
+}
+
+// src/generation/tools.ts
+var STRATEGIES = ["nearest", "upgrade", "downgrade", "error"];
+function knownRoles(models) {
+  const roles = [...REFERENCE_ROLES];
+  for (const model of models) {
+    for (const role of supportedReferenceRoles(model)) if (!roles.includes(role)) roles.push(role);
+  }
+  return roles;
+}
+var requestSchemaFor = (roles) => ({
+  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: [...roles],
+            description: "What the asset is used for. Each model lists the roles it accepts (list_models)."
+          },
+          url: { type: "string" },
+          mediaType: { type: "string", description: 'MIME type or media kind, e.g. "image/png".' },
+          contentHash: { 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 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 = _nullishCoalesce(options.defaultStrategy, () => ( "nearest"));
+  const maxKeys = Math.max(1, _nullishCoalesce(options.maxIdempotencyKeys, () => ( 500)));
+  const calls = /* @__PURE__ */ new Map();
+  const findModel2 = (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 = findModel2(args.model);
+    const request = { ..._nullishCoalesce(args.request, () => ( {})), model: model.id };
+    return {
+      model,
+      plan: planGenerationRequest(request, model, {
+        strategy: _nullishCoalesce(args.strategy, () => ( defaultStrategy)),
+        resolvedPrompt: args.resolvedPrompt
+      })
+    };
+  };
+  const planInput = () => {
+    const models = readModels();
+    const ids = models.map((m) => m.id);
+    return {
+      type: "object",
+      properties: {
+        model: { type: "string", ...ids.length ? { enum: ids } : {}, description: "Model id from list_models." },
+        request: requestSchemaFor(knownRoles(models)),
+        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 } : {},
+            ..._optionalChain([m, 'access', _64 => _64.badges, 'optionalAccess', _65 => _65.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 (_optionalChain([calls, 'access', _66 => _66.get, 'call', _67 => _67(key), 'optionalAccess', _68 => _68.result]) === result) calls.delete(key);
+          throw error;
+        }
+      }
+    });
+    return list2;
+  };
+  return {
+    id: _nullishCoalesce(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 _chunkFD4LPFAEcjs.tokenizePrompt.call(void 0, text)) {
+      if (token.type !== "template" || pinned.has(token.value)) continue;
+      const template = byName.get(token.value);
+      if (!template) continue;
+      const body = _chunkFD4LPFAEcjs.getTemplateBody.call(void 0, 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) : _chunkFD4LPFAEcjs.getLatestVersion.call(void 0, template);
+      const isVersioned = !!_optionalChain([template, 'access', _69 => _69.versions, 'optionalAccess', _70 => _70.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: _nullishCoalesce(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 = _nullishCoalesce(options.templates, () => ( []));
+  const maxDepth = _nullishCoalesce(options.maxDepth, () => ( 10));
+  const resolved = _chunkFD4LPFAEcjs.resolvePrompt.call(void 0, options.rawPrompt, templates, {
+    bindings: options.bindings,
+    values: options.values,
+    maxDepth
+  });
+  const pinned = pinTemplates(options.rawPrompt, templates, _nullishCoalesce(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(_nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'access', _71 => _71.plan, 'optionalAccess', _72 => _72.request]), () => ( options.request)), () => ( {})));
+  request.model = modelId;
+  if (request.prompt === void 0) request.prompt = resolved.text;
+  const adjustments = clone(_nullishCoalesce(_nullishCoalesce(options.adjustments, () => ( _optionalChain([options, 'access', _73 => _73.plan, 'optionalAccess', _74 => _74.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: (_nullishCoalesce(request.references, () => ( []))).map(({ id, role }) => ({ id, role })),
+    createdAt: toIso(_nullishCoalesce(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 (e2) {
+      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 replayProvenancePrompt(provenance) {
+  const result = _chunkFD4LPFAEcjs.resolvePrompt.call(void 0, 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(_nullishCoalesce(options.maxBatch, () => ( 50))));
+  const delayMs = Math.max(0, _nullishCoalesce(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) _optionalChain([options, 'access', _75 => _75.onError, 'optionalCall', _76 => _76(error, keys)]);
+      keys.forEach((key, index) => {
+        const pending = pendings[index];
+        const value = _optionalChain([values, 'optionalAccess', _77 => _77.get, 'call', _78 => _78(key)]);
+        if (pending && inFlight.get(key) === pending) {
+          inFlight.delete(key);
+          settled.set(key, value);
+          if (values === null) failures.add(key);
+        }
+        _optionalChain([pending, 'optionalAccess', _79 => _79.resolve, 'call', _80 => _80(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, _nullishCoalesce(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(_nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(request.count, () => ( _optionalChain([caps, 'access', _81 => _81.count, 'optionalAccess', _82 => _82.default]))), () => ( 1));
+  const duration = _nullishCoalesce(_nullishCoalesce(request.duration, () => ( _optionalChain([caps, 'access', _83 => _83.duration, 'optionalAccess', _84 => _84.default]))), () => ( 0));
+  const resolution = _nullishCoalesce(request.resolution, () => ( _optionalChain([caps, 'access', _85 => _85.resolutions, 'optionalAccess', _86 => _86.default])));
+  const megapixels = resolution ? _nullishCoalesce(resolutionMegapixels(resolution), () => ( 0)) : 0;
+  return Math.round(
+    timing.baseMs + (_nullishCoalesce(timing.perItemMs, () => ( 0))) * Math.max(0, count - 1) + (_nullishCoalesce(timing.perSecondMs, () => ( 0))) * duration + (_nullishCoalesce(timing.perMegapixelMs, () => ( 0))) * megapixels
+  );
+}
+
+// src/generation/controls.ts
+function enumControl(key, label, cap) {
+  if (!_optionalChain([cap, 'optionalAccess', _87 => _87.options, 'access', _88 => _88.length])) return null;
+  return {
+    key,
+    label,
+    kind: "select",
+    valueType: "string",
+    options: cap.options.map((value) => ({ value, label: _nullishCoalesce(_optionalChain([cap, 'access', _89 => _89.labels, 'optionalAccess', _90 => _90[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 = _optionalChain([caps, 'access', _91 => _91.count, 'access', _92 => _92.options, 'optionalAccess', _93 => _93.filter, 'call', _94 => _94((o) => o >= 1 && o <= caps.count.max)]);
+    controls.push(
+      _optionalChain([options, 'optionalAccess', _95 => _95.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: _nullishCoalesce(caps.count.default, () => ( 1)) }
+    );
+  }
+  if (caps.duration) {
+    const d = caps.duration;
+    const options = _optionalChain([d, 'access', _96 => _96.options, 'optionalAccess', _97 => _97.filter, 'call', _98 => _98((o) => (d.min === void 0 || o >= d.min) && (d.max === void 0 || o <= d.max))]);
+    controls.push(
+      _optionalChain([options, 'optionalAccess', _99 => _99.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(_nullishCoalesce(caps.params, () => ( {})))) {
+    const base = { key: `params.${name}`, label: _nullishCoalesce(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: _nullishCoalesce(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 _optionalChain([request, 'access', _100 => _100.params, 'optionalAccess', _101 => _101[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 = { ..._nullishCoalesce(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 = _nullishCoalesce(request.references, () => ( []));
+  const total = refs.length;
+  const maxTotal = _nullishCoalesce(_optionalChain([caps, 'access', _102 => _102.references, 'optionalAccess', _103 => _103.maxTotal]), () => ( Infinity));
+  return roles.map((role) => {
+    const cap = _nullishCoalesce(_optionalChain([caps, 'access', _104 => _104.references, 'optionalAccess', _105 => _105.roles, 'access', _106 => _106[role]]), () => ( { max: 1 }));
+    const references = refs.filter((ref) => ref.role === role);
+    return {
+      role,
+      label: referenceRoleLabel(role, caps),
+      ...cap.description ? { description: cap.description } : {},
+      ..."accepts" in cap && _optionalChain([cap, 'access', _107 => _107.accepts, 'optionalAccess', _108 => _108.length]) ? { accepts: [...cap.accepts] } : {},
+      min: _nullishCoalesce(cap.min, () => ( 0)),
+      max: cap.max,
+      references,
+      canAdd: references.length < cap.max && total < maxTotal
+    };
+  });
+}
+function addReference(request, reference) {
+  return { ...request, references: [..._nullishCoalesce(request.references, () => ( [])), { ...reference }] };
+}
+function removeReference(request, role, id) {
+  const references = (_nullishCoalesce(request.references, () => ( []))).filter((ref) => !(ref.role === role && ref.id === id));
+  const next = { ...request, references };
+  if (references.length === 0) delete next.references;
+  return next;
+}
+
+// src/generation/assets.ts
+function toAssetResolver(lookup) {
+  if (!lookup) return void 0;
+  if (typeof lookup === "function") return (id) => _nullishCoalesce(lookup(id), () => ( void 0));
+  if (lookup instanceof Map) return (id) => lookup.get(id);
+  const byId = new Map(lookup.map((asset) => [asset.id, asset]));
+  return (id) => byId.get(id);
+}
+function roleCap(caps, role) {
+  const cap = _optionalChain([caps, 'access', _109 => _109.references, 'optionalAccess', _110 => _110.roles, 'access', _111 => _111[role]]);
+  if (cap && cap.max > 0) return cap;
+  if (role === "mask" && caps.inpainting) return { max: 1 };
+  return void 0;
+}
+function getAssetRoleOptions(caps) {
+  const roles = supportedReferenceRoles(caps);
+  if (caps.inpainting && !roles.includes("mask")) roles.push("mask");
+  return roles.map((role) => {
+    const cap = _nullishCoalesce(roleCap(caps, role), () => ( { max: 1 }));
+    return {
+      role,
+      label: referenceRoleLabel(role, caps),
+      ...cap.description ? { description: cap.description } : {},
+      min: _nullishCoalesce(cap.min, () => ( 0)),
+      max: cap.max,
+      ..._optionalChain([cap, 'access', _112 => _112.accepts, 'optionalAccess', _113 => _113.length]) ? { accepts: [...cap.accepts] } : {}
+    };
+  });
+}
+function validateAssetMentions(mentions, caps, options = {}) {
+  const resolve = toAssetResolver(options.assets);
+  const issues = [];
+  const counts = {};
+  mentions.forEach((mention, index) => {
+    const id = mention.id;
+    const label = `@${_nullishCoalesce(mention.label, () => ( id))}`;
+    if (!mention.role) {
+      issues.push({ index, id, code: "missing-role", severity: "warning", message: `${label} has no role.` });
+      return;
+    }
+    let role = mention.role;
+    if (!roleCap(caps, role)) {
+      const alias = normalizeReferenceRole(role, caps);
+      if (alias !== role && roleCap(caps, alias)) {
+        issues.push({
+          index,
+          id,
+          role,
+          code: "renamed-role",
+          severity: "warning",
+          suggestion: alias,
+          message: `${label}: this model calls "${role}" ${referenceRoleLabel(alias, caps)} (${alias}).`
+        });
+        role = alias;
+      } else {
+        issues.push({
+          index,
+          id,
+          role,
+          code: "unsupported-role",
+          severity: "error",
+          message: `${label}: ${_nullishCoalesce(caps.name, () => ( caps.id))} does not accept ${referenceRoleLabel(role, caps).toLowerCase()} assets.`
+        });
+        return;
+      }
+    }
+    const cap = roleCap(caps, role);
+    const mediaType = _nullishCoalesce(mention.mediaType, () => ( _optionalChain([resolve, 'optionalCall', _114 => _114(id), 'optionalAccess', _115 => _115.mediaType])));
+    if (mediaType !== void 0 && !mediaTypeMatches(mediaType, cap.accepts)) {
+      issues.push({
+        index,
+        id,
+        role,
+        code: "media-mismatch",
+        severity: "error",
+        message: `${label} is ${mediaType}; ${referenceRoleLabel(role, caps)} accepts ${(_nullishCoalesce(cap.accepts, () => ( []))).join(", ")}.`
+      });
+      return;
+    }
+    counts[role] = (_nullishCoalesce(counts[role], () => ( 0))) + 1;
+    if (counts[role] > cap.max) {
+      issues.push({
+        index,
+        id,
+        role,
+        code: "too-many",
+        severity: "warning",
+        message: `${label}: at most ${cap.max} ${referenceRoleLabel(role, caps).toLowerCase()} asset(s); extra ones are left out.`
+      });
+    }
+  });
+  const missing = getAssetRoleOptions(caps).filter((option) => (_nullishCoalesce(counts[option.role], () => ( 0))) < option.min).map((option) => ({ role: option.role, min: option.min, count: _nullishCoalesce(counts[option.role], () => ( 0)) }));
+  return { ok: !issues.some((issue) => issue.severity === "error") && missing.length === 0, issues, counts, missing };
+}
+function resolveAssetMentions(mentions, assets) {
+  const byId = new Map(assets.map((asset) => [asset.id, asset]));
+  const byLabel = new Map(assets.filter((a) => a.label).map((asset) => [asset.label.toLowerCase(), asset]));
+  const result = [];
+  for (const mention of mentions) {
+    const asset = _nullishCoalesce(byId.get(mention.handle), () => ( byLabel.get(mention.handle.toLowerCase())));
+    if (!asset) continue;
+    result.push({
+      id: asset.id,
+      label: mention.handle,
+      ...mention.role ? { role: mention.role } : {},
+      ...asset.mediaType !== void 0 ? { mediaType: asset.mediaType } : {},
+      ...asset.contentHash !== void 0 ? { contentHash: asset.contentHash } : {},
+      ...asset.url !== void 0 ? { url: asset.url } : {}
+    });
+  }
+  return result;
+}
+function defaultAssetRoleOptions() {
+  return REFERENCE_ROLES.map((role) => ({ role, label: referenceRoleLabel(role), min: 0, max: 1 }));
+}
+function describeAssetMentions(mentions, assets, caps) {
+  const byId = new Map(assets.map((asset) => [asset.id, asset]));
+  const byLabel = new Map(assets.filter((a) => a.label).map((asset) => [asset.label.toLowerCase(), asset]));
+  const chips = [];
+  for (const mention of mentions) {
+    const asset = _nullishCoalesce(byId.get(mention.handle), () => ( byLabel.get(mention.handle.toLowerCase())));
+    if (!asset) continue;
+    const role = mention.role || void 0;
+    chips.push({
+      index: chips.length,
+      ...mention.start !== void 0 ? { start: mention.start } : {},
+      handle: mention.handle,
+      asset,
+      ...role ? { role, roleLabel: referenceRoleLabel(caps ? normalizeReferenceRole(role, caps) : role, caps) } : {},
+      issues: []
+    });
+  }
+  if (caps) {
+    const validation = validateAssetMentions(
+      chips.map((chip) => ({
+        id: chip.asset.id,
+        label: chip.handle,
+        ...chip.role ? { role: chip.role } : {},
+        ...chip.asset.mediaType ? { mediaType: chip.asset.mediaType } : {}
+      })),
+      caps
+    );
+    for (const issue of validation.issues) chips[issue.index].issues.push(issue);
+  }
+  return chips;
+}
+
+// src/generation/record.ts
+var GENERATION_RECORD_FORMAT = "pixerate.generation-record";
+var GENERATION_RECORD_VERSION = 1;
+var idCounter = 0;
+function createGenerationRecordId() {
+  const uuid = _optionalChain([globalThis, 'access', _116 => _116.crypto, 'optionalAccess', _117 => _117.randomUUID, 'optionalCall', _118 => _118()]);
+  if (typeof uuid === "string") return `gen_${uuid}`;
+  idCounter = (idCounter + 1) % 1679616;
+  const random = Math.floor(Math.random() * 2 ** 48).toString(36).padStart(10, "0");
+  return `gen_${Date.now().toString(36)}${idCounter.toString(36).padStart(4, "0")}${random}`;
+}
+var clone2 = (value) => value === void 0 ? value : JSON.parse(JSON.stringify(value));
+function recordTemplates(pinned) {
+  return pinned.map((p) => ({
+    name: p.name,
+    ...p.templateId !== void 0 ? { templateId: p.templateId } : {},
+    ...p.versionId !== void 0 ? { versionId: p.versionId, version: p.version } : {},
+    hash: hashText(p.body)
+  }));
+}
+function recordAssets(references, lookup) {
+  const resolve = toAssetResolver(lookup);
+  return (_nullishCoalesce(references, () => ( []))).map((ref) => {
+    const info = _optionalChain([resolve, 'optionalCall', _119 => _119(ref.id)]);
+    const contentHash = _nullishCoalesce(ref.contentHash, () => ( _optionalChain([info, 'optionalAccess', _120 => _120.contentHash])));
+    const mediaType = _nullishCoalesce(ref.mediaType, () => ( _optionalChain([info, 'optionalAccess', _121 => _121.mediaType])));
+    const url = _nullishCoalesce(ref.url, () => ( _optionalChain([info, 'optionalAccess', _122 => _122.url])));
+    return {
+      id: ref.id,
+      role: ref.role,
+      ...contentHash !== void 0 ? { contentHash } : {},
+      ...mediaType !== void 0 ? { mediaType } : {},
+      ...url !== void 0 ? { url } : {}
+    };
+  });
+}
+function createGenerationRecord(options) {
+  const {
+    model,
+    request: settingsInput,
+    plan: planInput,
+    strategy: strategyInput,
+    mentions,
+    assets,
+    seed: seedInput,
+    id,
+    parentId,
+    kind,
+    ...provenanceOptions
+  } = options;
+  const caps = typeof model === "string" ? void 0 : model;
+  const settings = clone2(_nullishCoalesce(_nullishCoalesce(settingsInput, () => ( _optionalChain([planInput, 'optionalAccess', _123 => _123.request]))), () => ( {})));
+  let plan = planInput;
+  if (!plan && caps) {
+    const resolved = _chunkFD4LPFAEcjs.resolvePrompt.call(void 0, options.rawPrompt, _nullishCoalesce(options.templates, () => ( [])), {
+      bindings: options.bindings,
+      values: options.values,
+      maxDepth: options.maxDepth
+    });
+    plan = planGenerationRequest(settings, caps, {
+      strategy: _nullishCoalesce(strategyInput, () => ( "nearest")),
+      resolvedPrompt: resolved.text,
+      ...mentions ? { mentions } : {}
+    });
+  }
+  const provenance = createProvenance({
+    ...provenanceOptions,
+    model,
+    ...plan ? { plan } : { request: settings }
+  });
+  const seed = _nullishCoalesce(seedInput, () => ( provenance.request.seed));
+  return {
+    format: GENERATION_RECORD_FORMAT,
+    version: GENERATION_RECORD_VERSION,
+    id: _nullishCoalesce(id, () => ( createGenerationRecordId())),
+    ...parentId !== void 0 ? { parentId } : {},
+    kind: _nullishCoalesce(kind, () => ( (parentId !== void 0 ? "recreate" : "generate"))),
+    provenance,
+    templates: recordTemplates(provenance.templates),
+    promptHash: hashText(provenance.resolvedPrompt),
+    ...caps ? { capabilityHash: hashCapabilities(caps) } : {},
+    settings,
+    strategy: _nullishCoalesce(_nullishCoalesce(strategyInput, () => ( _optionalChain([plan, 'optionalAccess', _124 => _124.strategy]))), () => ( "nearest")),
+    ...seed !== void 0 ? { seed } : {},
+    assets: recordAssets(provenance.request.references, assets),
+    ..._optionalChain([mentions, 'optionalAccess', _125 => _125.length]) ? { mentions: clone2([...mentions]) } : {},
+    createdAt: provenance.createdAt
+  };
+}
+function completeGenerationRecord(record, update) {
+  const next = clone2(record);
+  const now = new Date(_nullishCoalesce(update.completedAt, () => ( Date.now()))).toISOString();
+  if (update.outputIds) next.provenance.outputIds = [...update.outputIds];
+  next.provenance.completedAt = now;
+  if (update.meta) next.provenance.meta = { ..._nullishCoalesce(next.provenance.meta, () => ( {})), ...clone2(update.meta) };
+  if (update.seed !== void 0) next.seed = update.seed;
+  next.updatedAt = now;
+  return next;
+}
+function serializeGenerationRecord(record) {
+  return JSON.stringify(record);
+}
+var isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function parseGenerationRecord(input) {
+  let data = input;
+  if (typeof input === "string") {
+    try {
+      data = JSON.parse(input);
+    } catch (e3) {
+      throw new ProvenanceParseError("Generation record is not valid JSON.");
+    }
+  }
+  if (!isObject(data) || data.format !== GENERATION_RECORD_FORMAT) {
+    throw new ProvenanceParseError("Not a generation record.");
+  }
+  if (typeof data.version !== "number" || data.version > GENERATION_RECORD_VERSION) {
+    throw new ProvenanceParseError(`Unsupported generation record version ${JSON.stringify(data.version)}.`);
+  }
+  const checks = [
+    ["id", typeof data.id === "string" && data.id !== ""],
+    ["templates", Array.isArray(data.templates) && data.templates.every((t) => isObject(t) && typeof t.name === "string" && typeof t.hash === "string")],
+    ["assets", Array.isArray(data.assets) && data.assets.every((a) => isObject(a) && typeof a.id === "string" && typeof a.role === "string")],
+    ["settings", isObject(data.settings)],
+    ["promptHash", typeof data.promptHash === "string"],
+    ["createdAt", typeof data.createdAt === "string"]
+  ];
+  const bad = checks.find(([, ok]) => !ok);
+  if (bad) throw new ProvenanceParseError(`Invalid generation record field "${bad[0]}".`);
+  const provenance = parseProvenance(data.provenance);
+  return {
+    ...data,
+    kind: data.kind === "recreate" || data.kind === "variation" ? data.kind : "generate",
+    strategy: ["nearest", "upgrade", "downgrade", "error"].includes(data.strategy) ? data.strategy : "nearest",
+    provenance
+  };
+}
+function isGenerationRecord(value) {
+  return isObject(value) && value.format === GENERATION_RECORD_FORMAT;
+}
+var SKIPPED_SETTING_FIELDS = /* @__PURE__ */ new Set(["model", "prompt", "references", "params", "seed"]);
+function findModel(capabilities, modelId) {
+  if (!capabilities) return { given: false };
+  const list2 = Array.isArray(capabilities) ? capabilities : [capabilities];
+  return { given: true, caps: list2.find((m) => m.id === modelId) };
+}
+var sameValue = (a, b) => stableStringify(a) === stableStringify(b);
+var show = (value) => value === void 0 ? "unset" : typeof value === "string" ? `"${value}"` : JSON.stringify(value);
+var refKey = (ref) => `${ref.role}:${ref.id}`;
+function templateDrift(record, current, mode) {
+  if (!current) return [];
+  const byName = new Map(current.map((t) => [t.name, t]));
+  const drift = [];
+  for (const recorded of record.templates) {
+    const template = byName.get(recorded.name);
+    const fromVersion = _nullishCoalesce(recorded.version, () => ( recorded.versionId));
+    if (!template) {
+      drift.push({
+        type: "template-missing",
+        severity: "warning",
+        template: recorded.name,
+        from: fromVersion,
+        applied: false,
+        message: `Template "${recorded.name}" no longer exists; the recorded body is used.`
+      });
+      continue;
+    }
+    const body = _chunkFD4LPFAEcjs.getTemplateBody.call(void 0, template, {});
+    const hash = body === void 0 ? void 0 : hashText(body);
+    if (hash === recorded.hash) continue;
+    const latest = _chunkFD4LPFAEcjs.getLatestVersion.call(void 0, template);
+    const toVersion = _optionalChain([template, 'access', _126 => _126.versions, 'optionalAccess', _127 => _127.length]) ? _nullishCoalesce(_optionalChain([latest, 'optionalAccess', _128 => _128.version]), () => ( _optionalChain([latest, 'optionalAccess', _129 => _129.id]))) : void 0;
+    const versions = fromVersion !== void 0 || toVersion !== void 0 ? ` (${_nullishCoalesce(fromVersion, () => ( "unversioned"))} \u2192 ${_nullishCoalesce(toVersion, () => ( "unversioned"))})` : "";
+    drift.push({
+      type: "template-changed",
+      severity: mode === "latest" ? "info" : "warning",
+      template: recorded.name,
+      from: { version: fromVersion, hash: recorded.hash },
+      to: { version: toVersion, hash },
+      applied: mode === "latest",
+      message: mode === "latest" ? `Template "${recorded.name}" changed since this generation${versions}; using the current version.` : `Template "${recorded.name}" changed since this generation${versions}; recreating with the recorded version.`
+    });
+  }
+  return drift;
+}
+function randomSeed(caps, previous, random) {
+  const cap = caps ? seedCapability(caps.seed) : {};
+  if (!cap) return void 0;
+  const min = Math.ceil(_nullishCoalesce(cap.min, () => ( 0)));
+  const max = Math.floor(_nullishCoalesce(cap.max, () => ( 2 ** 31 - 1)));
+  if (max < min) return min;
+  let seed = previous;
+  for (let attempt = 0; attempt < 8 && (seed === void 0 || seed === previous); attempt++) {
+    seed = min + Math.floor(random() * (max - min + 1));
+  }
+  if (seed === previous && max > min) seed = previous === max ? min : previous + 1;
+  return seed;
+}
+function rebuild(record, options, kind, overrides) {
+  const mode = _nullishCoalesce(options.mode, () => ( "exact"));
+  const provenance = record.provenance;
+  const drift = templateDrift(record, options.templates, mode);
+  const rawPrompt = _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _130 => _130.rawPrompt]), () => ( provenance.rawPrompt));
+  const values = _optionalChain([overrides, 'optionalAccess', _131 => _131.values]) !== void 0 ? { ..._nullishCoalesce(provenance.values, () => ( {})), ...overrides.values } : provenance.values ? clone2(provenance.values) : null;
+  const pinned = pinnedTemplatesToTemplates(provenance.templates);
+  let templates;
+  let bindings;
+  if (mode === "latest" && options.templates) {
+    const currentNames = new Set(options.templates.map((t) => t.name));
+    const fallback = pinned.filter((t) => !currentNames.has(t.name));
+    templates = [...options.templates.map((t) => ({ ...t })), ...fallback];
+    bindings = {};
+    for (const t of fallback) {
+      if (provenance.bindings[t.name] !== void 0) bindings[t.name] = provenance.bindings[t.name];
+    }
+  } else {
+    templates = pinned;
+    bindings = { ...provenance.bindings };
+  }
+  const resolved = _chunkFD4LPFAEcjs.resolvePrompt.call(void 0, rawPrompt, templates, { bindings, ...values ? { values } : {} });
+  const sourceMap = resolved.map.map((segment) => {
+    const { locked: _locked, ...rest } = segment;
+    return rest;
+  });
+  if (resolved.text !== provenance.resolvedPrompt && !overrides) {
+    drift.push({
+      type: "prompt-changed",
+      severity: "info",
+      from: provenance.resolvedPrompt,
+      to: resolved.text,
+      applied: true,
+      message: "The resolved prompt differs from the recorded one."
+    });
+  }
+  const base = clone2(mode === "exact" ? provenance.request : record.settings);
+  const recordedPlanned = provenance.request;
+  if (base.prompt === void 0 || base.prompt === provenance.resolvedPrompt) base.prompt = resolved.text;
+  else if (base.prompt === provenance.rawPrompt) base.prompt = rawPrompt;
+  if (mode === "latest" && _optionalChain([record, 'access', _132 => _132.mentions, 'optionalAccess', _133 => _133.length])) {
+    const plannedRole = new Map((_nullishCoalesce(recordedPlanned.references, () => ( []))).map((ref) => [ref.id, ref.role]));
+    base.references = [
+      ..._nullishCoalesce(base.references, () => ( [])),
+      ...record.mentions.map((m) => ({
+        id: m.id,
+        role: m.role || plannedRole.get(m.id) || "image_ref",
+        ...m.url !== void 0 ? { url: m.url } : {},
+        ...m.mediaType !== void 0 ? { mediaType: m.mediaType } : {},
+        ...m.contentHash !== void 0 ? { contentHash: m.contentHash } : {}
+      }))
+    ];
+  } else if (mode === "latest" && base.references === void 0 && recordedPlanned.references) {
+    base.references = clone2(recordedPlanned.references);
+  }
+  if (record.seed !== void 0) base.seed = record.seed;
+  base.model = provenance.modelId;
+  const { given, caps } = findModel(options.capabilities, provenance.modelId);
+  if (overrides) {
+    if (overrides.settings) {
+      const { params, ...rest } = overrides.settings;
+      Object.assign(base, clone2(rest));
+      if (params) base.params = { ..._nullishCoalesce(base.params, () => ( {})), ...clone2(params) };
+    }
+    if (overrides.seed === null) delete base.seed;
+    else base.seed = _nullishCoalesce(overrides.seed, () => ( randomSeed(caps, record.seed, _nullishCoalesce(overrides.random, () => ( Math.random)))));
+    if (base.seed === void 0) delete base.seed;
+  }
+  const resolveAsset = toAssetResolver(options.assets);
+  if (resolveAsset && base.references) {
+    const recordedById = new Map(record.assets.map((a) => [refKey(a), a]));
+    const kept = [];
+    for (const ref of base.references) {
+      const info = resolveAsset(ref.id);
+      if (!info) {
+        drift.push({
+          type: "asset-missing",
+          severity: "error",
+          assetId: ref.id,
+          role: ref.role,
+          message: `Asset "${ref.id}" (${ref.role}) is no longer available.`
+        });
+        continue;
+      }
+      const recordedHash = _nullishCoalesce(_optionalChain([recordedById, 'access', _134 => _134.get, 'call', _135 => _135(refKey(ref)), 'optionalAccess', _136 => _136.contentHash]), () => ( ref.contentHash));
+      if (recordedHash !== void 0 && info.contentHash !== void 0 && recordedHash !== info.contentHash) {
+        drift.push({
+          type: "asset-changed",
+          severity: "warning",
+          assetId: ref.id,
+          role: ref.role,
+          from: recordedHash,
+          to: info.contentHash,
+          applied: true,
+          message: `Asset "${ref.id}" (${ref.role}) has changed since this generation.`
+        });
+      }
+      const next = { ...ref };
+      if (info.contentHash !== void 0) next.contentHash = info.contentHash;
+      if (next.mediaType === void 0 && info.mediaType !== void 0) next.mediaType = info.mediaType;
+      kept.push(next);
+    }
+    if (kept.length) base.references = kept;
+    else delete base.references;
+  }
+  let plan;
+  let request = base;
+  if (given && !caps) {
+    drift.push({
+      type: "model-missing",
+      severity: "error",
+      modelId: provenance.modelId,
+      message: `Model "${provenance.modelId}" is no longer available.`
+    });
+  } else if (caps) {
+    const capabilityHash = hashCapabilities(caps);
+    if (record.capabilityHash !== void 0 && record.capabilityHash !== capabilityHash) {
+      drift.push({
+        type: "model-changed",
+        severity: "warning",
+        modelId: caps.id,
+        from: record.capabilityHash,
+        to: capabilityHash,
+        message: `The capabilities of "${_nullishCoalesce(caps.name, () => ( caps.id))}" changed since this generation.`
+      });
+    }
+    plan = planGenerationRequest(base, caps, {
+      strategy: _nullishCoalesce(options.strategy, () => ( record.strategy)),
+      resolvedPrompt: resolved.text
+    });
+    request = plan.request;
+    const severity = mode === "exact" && !overrides ? "warning" : "info";
+    const type = mode === "exact" && !overrides ? "setting-unsupported" : "setting-changed";
+    const describeChange = (field, from, to) => {
+      const adjustment = plan.adjustments.find((a) => a.field === field || a.field.startsWith(`${field}.`));
+      drift.push({
+        type,
+        severity,
+        field,
+        from,
+        to,
+        applied: true,
+        message: type === "setting-unsupported" ? `${field} ${show(from)} is no longer supported; using ${show(to)}.${adjustment ? ` ${adjustment.reason}` : ""}` : `${field} was ${show(from)}, now ${show(to)}.${adjustment ? ` ${adjustment.reason}` : ""}`
+      });
+    };
+    if (!overrides) {
+      for (const field of GENERATION_REQUEST_FIELDS) {
+        if (SKIPPED_SETTING_FIELDS.has(field)) continue;
+        const from = recordedPlanned[field];
+        const to = request[field];
+        if (!sameValue(from, to)) describeChange(field, from, to);
+      }
+      const paramNames = /* @__PURE__ */ new Set([...Object.keys(_nullishCoalesce(recordedPlanned.params, () => ( {}))), ...Object.keys(_nullishCoalesce(request.params, () => ( {})))]);
+      for (const name of [...paramNames].sort()) {
+        const from = _optionalChain([recordedPlanned, 'access', _137 => _137.params, 'optionalAccess', _138 => _138[name]]);
+        const to = _optionalChain([request, 'access', _139 => _139.params, 'optionalAccess', _140 => _140[name]]);
+        if (!sameValue(from, to)) describeChange(`params.${name}`, from, to);
+      }
+      if (!sameValue(_nullishCoalesce(record.seed, () => ( recordedPlanned.seed)), request.seed)) describeChange("seed", _nullishCoalesce(record.seed, () => ( recordedPlanned.seed)), request.seed);
+      const missing = new Set(drift.filter((d) => d.type === "asset-missing").map((d) => `${d.role}:${d.assetId}`));
+      const fromRefs = (_nullishCoalesce(recordedPlanned.references, () => ( []))).map(refKey).filter((key) => !missing.has(key));
+      const toRefs = (_nullishCoalesce(request.references, () => ( []))).map(refKey);
+      if (!sameValue(fromRefs, toRefs)) describeChange("references", fromRefs, toRefs);
+    }
+    for (const error of plan.errors) {
+      drift.push({
+        type: "setting-unsupported",
+        severity: "error",
+        field: error.field,
+        from: error.value,
+        message: error.message
+      });
+    }
+  }
+  const ok = !drift.some((d) => d.severity === "error") && (plan ? plan.ok : true);
+  const recordOptions = {
+    rawPrompt,
+    templates,
+    bindings,
+    ...values ? { values } : {},
+    model: _nullishCoalesce(caps, () => ( provenance.modelId)),
+    request,
+    ...plan ? { plan } : {},
+    strategy: _nullishCoalesce(options.strategy, () => ( record.strategy)),
+    parentId: record.id,
+    kind
+  };
+  return {
+    mode,
+    ok,
+    request,
+    ...plan ? { plan } : {},
+    rawPrompt,
+    resolvedPrompt: resolved.text,
+    sourceMap,
+    values,
+    templates,
+    bindings,
+    drift,
+    parentId: record.id,
+    kind,
+    recordOptions
+  };
+}
+function recreateRequest(input, options) {
+  if (isGenerationRecord(input)) return rebuild(input, _nullishCoalesce(options, () => ( {})), "recreate");
+  const provenance = input;
+  const request = clone2(provenance.request);
+  request.model = provenance.modelId;
+  if (request.prompt === void 0) request.prompt = provenance.resolvedPrompt;
+  return request;
+}
+function variationRequest(record, overrides = {}, options = {}) {
+  return rebuild(record, options, "variation", overrides);
+}
+var DRIFT_TYPE_LABELS = {
+  "template-changed": "Template changed",
+  "template-missing": "Template deleted",
+  "prompt-changed": "Prompt changed",
+  "model-missing": "Model unavailable",
+  "model-changed": "Model changed",
+  "setting-unsupported": "Setting unsupported",
+  "setting-changed": "Setting changed",
+  "asset-missing": "Asset missing",
+  "asset-changed": "Asset changed"
+};
+function blockingDrift(drift) {
+  return drift.filter((d) => d.severity === "error");
+}
+
+// src/generation/store.ts
+var INDEX_VERSION = 1;
+var time = (value) => new Date(value).getTime();
+function summarizeGenerationRecord(record) {
+  const unique = (values) => [...new Set(values)];
+  return {
+    id: record.id,
+    modelId: record.provenance.modelId,
+    kind: record.kind,
+    ...record.parentId !== void 0 ? { parentId: record.parentId } : {},
+    createdAt: record.createdAt,
+    templates: unique(record.templates.map((t) => t.name)),
+    templateIds: unique(record.templates.flatMap((t) => t.templateId !== void 0 ? [t.templateId] : [])),
+    assets: unique(record.assets.map((a) => a.id)),
+    roles: unique(record.assets.map((a) => a.role)),
+    preview: record.provenance.resolvedPrompt.slice(0, 160)
+  };
+}
+function matchesRecordFilter(summary, filter = {}) {
+  if (filter.model !== void 0) {
+    const models = typeof filter.model === "string" ? [filter.model] : filter.model;
+    if (!models.includes(summary.modelId)) return false;
+  }
+  if (filter.template !== void 0 && !summary.templates.includes(filter.template) && !summary.templateIds.includes(filter.template)) {
+    return false;
+  }
+  if (filter.asset !== void 0 && !summary.assets.includes(filter.asset)) return false;
+  if (filter.role !== void 0 && !summary.roles.includes(filter.role)) return false;
+  if (filter.kind !== void 0 && summary.kind !== filter.kind) return false;
+  if (filter.parentId !== void 0 && summary.parentId !== filter.parentId) return false;
+  const created = time(summary.createdAt);
+  if (filter.since !== void 0 && created < time(filter.since)) return false;
+  if (filter.until !== void 0 && created >= time(filter.until)) return false;
+  if (filter.text !== void 0 && !summary.preview.toLowerCase().includes(filter.text.toLowerCase())) return false;
+  return true;
+}
+var newestFirst = (a, b) => time(b.createdAt) - time(a.createdAt) || (a.id < b.id ? 1 : a.id > b.id ? -1 : 0);
+function createGenerationRecordStore(options) {
+  const storage = options.storage;
+  const ns = _nullishCoalesce(options.namespace, () => ( "pixerate.generation-records"));
+  const indexKey = `${ns}:index`;
+  const recordKey = (id) => `${ns}:record:${id}`;
+  const listeners = /* @__PURE__ */ new Set();
+  let index = null;
+  let queue = Promise.resolve();
+  const run = (task) => {
+    const result = queue.then(task, task);
+    queue = result.catch(() => void 0);
+    return result;
+  };
+  const notify = () => listeners.forEach((listener) => listener());
+  const loadIndex = async () => {
+    if (index) return index;
+    const raw = await storage.get(indexKey);
+    let items = [];
+    if (raw) {
+      try {
+        const data = JSON.parse(raw);
+        if (data && Array.isArray(data.items)) {
+          items = data.items.filter((item) => item && typeof item.id === "string" && typeof item.createdAt === "string");
+        }
+      } catch (e4) {
+        items = [];
+      }
+    }
+    index = items;
+    return index;
+  };
+  const saveIndex = async (items) => {
+    await storage.set(indexKey, JSON.stringify({ version: INDEX_VERSION, items }));
+    index = items;
+  };
+  const select = (items, filter = {}) => {
+    const matched = items.filter((s) => matchesRecordFilter(s, filter)).sort(newestFirst);
+    const offset = Math.max(0, _nullishCoalesce(filter.offset, () => ( 0)));
+    return matched.slice(offset, filter.limit !== void 0 ? offset + Math.max(0, filter.limit) : void 0);
+  };
+  const pruneLocked = async (prune) => {
+    const items = [...await loadIndex()].sort(newestFirst);
+    const removed = [];
+    const kept = [];
+    let candidates = 0;
+    const cutoff = prune.olderThan !== void 0 ? time(prune.olderThan) : void 0;
+    for (const item of items) {
+      if (_optionalChain([prune, 'access', _141 => _141.keep, 'optionalCall', _142 => _142(item)])) {
+        kept.push(item);
+        candidates++;
+        continue;
+      }
+      const tooOld = cutoff !== void 0 && time(item.createdAt) < cutoff;
+      const overLimit = prune.maxRecords !== void 0 && candidates >= Math.max(0, prune.maxRecords);
+      if (tooOld || overLimit) removed.push(item);
+      else {
+        kept.push(item);
+        candidates++;
+      }
+    }
+    if (removed.length === 0) return [];
+    await saveIndex(kept);
+    for (const item of removed) await storage.remove(recordKey(item.id));
+    return removed.map((item) => item.id);
+  };
+  return {
+    put: (record) => run(async () => {
+      const serialized = serializeGenerationRecord(record);
+      await storage.set(recordKey(record.id), serialized);
+      const items = (await loadIndex()).filter((item) => item.id !== record.id);
+      items.push(summarizeGenerationRecord(record));
+      await saveIndex(items);
+      if (options.maxRecords !== void 0) await pruneLocked({ maxRecords: options.maxRecords });
+      notify();
+    }),
+    get: (id) => run(async () => {
+      const raw = await storage.get(recordKey(id));
+      if (!raw) return null;
+      try {
+        return parseGenerationRecord(raw);
+      } catch (e5) {
+        return null;
+      }
+    }),
+    summaries: (filter) => run(async () => select(await loadIndex(), filter)),
+    list: (filter) => run(async () => {
+      const records = [];
+      for (const summary of select(await loadIndex(), filter)) {
+        const raw = await storage.get(recordKey(summary.id));
+        if (!raw) continue;
+        try {
+          records.push(parseGenerationRecord(raw));
+        } catch (e6) {
+        }
+      }
+      return records;
+    }),
+    remove: (id) => run(async () => {
+      const items = await loadIndex();
+      const next = items.filter((item) => item.id !== id);
+      if (next.length === items.length) return false;
+      await saveIndex(next);
+      await storage.remove(recordKey(id));
+      notify();
+      return true;
+    }),
+    prune: (prune) => run(async () => {
+      const removed = await pruneLocked(prune);
+      if (removed.length) notify();
+      return removed;
+    }),
+    clear: () => run(async () => {
+      const items = await loadIndex();
+      await saveIndex([]);
+      for (const item of items) await storage.remove(recordKey(item.id));
+      notify();
+    }),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DRIFT_TYPE_LABELS = DRIFT_TYPE_LABELS; exports.GENERATION_RECORD_FORMAT = GENERATION_RECORD_FORMAT; exports.GENERATION_RECORD_VERSION = GENERATION_RECORD_VERSION; exports.GENERATION_REQUEST_FIELDS = GENERATION_REQUEST_FIELDS; exports.MAX_PENDING_PERCENT = MAX_PENDING_PERCENT; exports.PROVENANCE_FORMAT = PROVENANCE_FORMAT; exports.PROVENANCE_VERSION = PROVENANCE_VERSION; exports.ProvenanceParseError = ProvenanceParseError; exports.QUALITY_LADDER = QUALITY_LADDER; exports.REFERENCE_ROLES = REFERENCE_ROLES; exports.REFERENCE_ROLE_ALIASES = REFERENCE_ROLE_ALIASES; exports.REFERENCE_ROLE_LABELS = REFERENCE_ROLE_LABELS; exports.REFERENCE_ROLE_NAME_REGEX = REFERENCE_ROLE_NAME_REGEX; exports.addReference = addReference; exports.aspectRatioRank = aspectRatioRank; exports.blockingDrift = blockingDrift; exports.capabilitiesToJsonSchema = capabilitiesToJsonSchema; exports.completeGenerationRecord = completeGenerationRecord; exports.createBatchResolver = createBatchResolver; exports.createGenerationRecord = createGenerationRecord; exports.createGenerationRecordId = createGenerationRecordId; exports.createGenerationRecordStore = createGenerationRecordStore; exports.createGenerationToolProvider = createGenerationToolProvider; exports.createProvenance = createProvenance; exports.defaultAssetRoleOptions = defaultAssetRoleOptions; exports.describeAssetMentions = describeAssetMentions; exports.estimateJobProgress = estimateJobProgress; exports.expectedDurationFor = expectedDurationFor; exports.findTextMentions = _chunkBVP3TSLHcjs.findTextMentions; exports.formatMentionText = _chunkBVP3TSLHcjs.formatMentionText; exports.formatRemaining = formatRemaining; exports.getAssetRoleOptions = getAssetRoleOptions; exports.getGenerationControls = getGenerationControls; exports.getReferenceSlots = getReferenceSlots; exports.getRequestValue = getRequestValue; exports.hashCapabilities = hashCapabilities; exports.hashText = hashText; exports.hashValue = hashValue; exports.isGenerationRecord = isGenerationRecord; exports.isReferenceRoleName = isReferenceRoleName; exports.matchesRecordFilter = matchesRecordFilter; exports.mediaTypeMatches = mediaTypeMatches; exports.mergeCapabilities = mergeCapabilities; exports.normalizeReferenceRole = normalizeReferenceRole; exports.parseControlValue = parseControlValue; exports.parseGenerationRecord = parseGenerationRecord; exports.parseProvenance = parseProvenance; exports.pinnedTemplatesToTemplates = pinnedTemplatesToTemplates; exports.planGenerationRequest = planGenerationRequest; exports.qualityRank = qualityRank; exports.recreateRequest = recreateRequest; exports.referenceRoleLabel = referenceRoleLabel; exports.removeReference = removeReference; exports.replayProvenancePrompt = replayProvenancePrompt; exports.resolutionMegapixels = resolutionMegapixels; exports.resolutionRank = resolutionRank; exports.resolveAssetMentions = resolveAssetMentions; exports.seedCapability = seedCapability; exports.serializeGenerationRecord = serializeGenerationRecord; exports.serializeProvenance = serializeProvenance; exports.setMentionRoleInText = _chunkBVP3TSLHcjs.setMentionRoleInText; exports.setRequestValue = setRequestValue; exports.snapToOption = snapToOption; exports.stableStringify = stableStringify; exports.summarizeGenerationRecord = summarizeGenerationRecord; exports.supportedModes = supportedModes; exports.supportedReferenceRoles = supportedReferenceRoles; exports.textFieldCapability = textFieldCapability; exports.toAssetResolver = toAssetResolver; exports.validateAssetMentions = validateAssetMentions; exports.validateJsonSchema = _chunkCPOKFNBGcjs.validateJsonSchema; exports.variationRequest = variationRequest;
+//# sourceMappingURL=index.cjs.map