@koda-sl/baker-cli 0.393.0-dev.799d3f88c → 0.395.0-dev.f8ecbaa42

package/dist/{chunk-JLKUHDBB.js → chunk-Q3LMLQAI.js}

@@ -1459,7 +1459,9 @@ var MODEL_REGISTRY = {
     // Vision judgement — the selection contract (numbered images, JSON
     // response) is baked into the backend prompt; `prompt` carries only the
     // selection criteria. `count` has an engine-side default of 1, so it is
-    // not registry-required.
+    // not registry-required. `keep_reserved_areas` is read by the Runtime, which
+    // drops a candidate that filled the copy's areas before the judge, and is
+    // never sent on to the backend.
     "~google/gemini-flash-latest": {
       label: "Google Gemini Flash (latest, Vision)",
       inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES }],
@@ -1468,7 +1470,8 @@ var MODEL_REGISTRY = {
         prompt: { kind: "string" },
         count: { kind: "number", min: 1 },
         temperature: { kind: "number", min: 0, max: 2 },
-        max_tokens: { kind: "number", min: 1 }
+        max_tokens: { kind: "number", min: 1 },
+        keep_reserved_areas: { kind: "boolean" }
       }
     },
     "~google/gemini-pro-latest": {
@@ -1479,7 +1482,8 @@ var MODEL_REGISTRY = {
         prompt: { kind: "string" },
         count: { kind: "number", min: 1 },
         temperature: { kind: "number", min: 0, max: 2 },
-        max_tokens: { kind: "number", min: 1 }
+        max_tokens: { kind: "number", min: 1 },
+        keep_reserved_areas: { kind: "boolean" }
       }
     }
   },
@@ -2345,8 +2349,8 @@ function promptMaxLength(kind, model) {
   return schema?.kind === "string" ? schema.maxLength : void 0;
 }
 function inputSlot(kind, model, inputKind) {
-  const spec = MODEL_REGISTRY[kind]?.[model];
-  return spec?.optional_inputs?.find((input) => input.kind === inputKind) ?? spec?.inputs.find((input) => input.kind === inputKind);
+  const spec2 = MODEL_REGISTRY[kind]?.[model];
+  return spec2?.optional_inputs?.find((input) => input.kind === inputKind) ?? spec2?.inputs.find((input) => input.kind === inputKind);
 }
 function maxInputSlot(kind, model, inputKind) {
   return inputSlot(kind, model, inputKind)?.max;
@@ -2415,9 +2419,9 @@ function nearestSupportedImageSize(kind, model, target) {
 function isManagedNodeKind(nodeType) {
   return Object.keys(MODEL_REGISTRY).includes(nodeType);
 }
-function checkRequiredParams(spec, params, model) {
+function checkRequiredParams(spec2, params, model) {
   const errors = [];
-  for (const req of spec.required) {
+  for (const req of spec2.required) {
     if (params[req] === void 0 || params[req] === null) {
       errors.push({
         code: "missing_required_param",
@@ -2428,12 +2432,12 @@ function checkRequiredParams(spec, params, model) {
   }
   return errors;
 }
-function checkParamValues(spec, params, model) {
+function checkParamValues(spec2, params, model) {
   const errors = [];
   for (const [key, value] of Object.entries(params)) {
     if (key === "model") continue;
     if (value === void 0) continue;
-    const schema = spec.params[key];
+    const schema = spec2.params[key];
     if (!schema) {
       errors.push({
         code: "unknown_param",
@@ -2448,14 +2452,14 @@ function checkParamValues(spec, params, model) {
   return errors;
 }
 function validateModelParams(nodeType, model, params) {
-  const spec = MODEL_REGISTRY[nodeType][model];
-  if (!spec) {
+  const spec2 = MODEL_REGISTRY[nodeType][model];
+  if (!spec2) {
     return {
       ok: false,
       errors: [{ code: "unknown_model", message: `unknown model "${model}" for node "${nodeType}"` }]
     };
   }
-  const errors = [...checkRequiredParams(spec, params, model), ...checkParamValues(spec, params, model)];
+  const errors = [...checkRequiredParams(spec2, params, model), ...checkParamValues(spec2, params, model)];
   if (errors.length > 0) return { ok: false, errors };
   if (nodeType === "video_generate") {
     const tooHeavy = clipTooHeavyToIngest(
@@ -2467,8 +2471,8 @@ function validateModelParams(nodeType, model, params) {
   return { ok: true };
 }
 function validateModelInputs(nodeType, model, providedKinds) {
-  const spec = MODEL_REGISTRY[nodeType][model];
-  if (!spec) {
+  const spec2 = MODEL_REGISTRY[nodeType][model];
+  if (!spec2) {
     return {
       ok: false,
       errors: [{ code: "unknown_model", message: `unknown model "${model}" for node "${nodeType}"` }]
@@ -2476,7 +2480,7 @@ function validateModelInputs(nodeType, model, providedKinds) {
   }
   const have = new Set(providedKinds);
   const errors = [];
-  for (const inputSpec of spec.inputs) {
+  for (const inputSpec of spec2.inputs) {
     if (!have.has(inputSpec.kind)) {
       errors.push({
         code: "missing_input",
@@ -3686,9 +3690,9 @@ function parseSpineInputLens(args) {
 }
 
 // src/engine/engine/define.ts
-function resolveOutputKinds(spec, params) {
-  if (!spec) return {};
-  return typeof spec === "function" ? spec(params) : spec;
+function resolveOutputKinds(spec2, params) {
+  if (!spec2) return {};
+  return typeof spec2 === "function" ? spec2(params) : spec2;
 }
 function defineNode(def) {
   return def;
@@ -3766,9 +3770,9 @@ function cappedParamsOf(n) {
   if (!isManagedNodeKind(n.type)) return [];
   const model = n.params?.model;
   if (typeof model !== "string") return [];
-  const spec = MODEL_REGISTRY[n.type][model];
-  if (!spec) return [];
-  return Object.entries(spec.params).flatMap(
+  const spec2 = MODEL_REGISTRY[n.type][model];
+  if (!spec2) return [];
+  return Object.entries(spec2.params).flatMap(
     ([key, schema]) => schema.kind === "string" && schema.maxLength !== void 0 ? [{ key, max: schema.maxLength, model }] : []
   );
 }
@@ -4711,8 +4715,8 @@ function checkReferenceCompleteness(ctx, meta) {
   }
 }
 function videoModelMaxDuration(model) {
-  const spec = MODEL_REGISTRY.video_generate[model];
-  const durations = spec?.params?.duration?.enum;
+  const spec2 = MODEL_REGISTRY.video_generate[model];
+  const durations = spec2?.params?.duration?.enum;
   if (!durations) return void 0;
   const nums = durations.filter((d) => typeof d === "number");
   return nums.length > 0 ? Math.max(...nums) : void 0;
@@ -5361,6 +5365,7 @@ var Engine = class {
       }
     }
     const t0 = Date.now();
+    let charged;
     const ctx = {
       canvasRunId: runId,
       nodeId: node.id,
@@ -5370,13 +5375,16 @@ var Engine = class {
       client: this.client,
       assets: this.assets,
       log: this.log,
-      signal: opts.signal
+      signal: opts.signal,
+      reportCharge: (credits2) => {
+        charged = (charged ?? 0) + credits2;
+      }
     };
     const preparedForExec = needsLocalMaterialization(def) ? { ...prepared, resolvedInputs: await this.materializeLocalInputs(prepared.resolvedInputs) } : prepared;
     const { parsedInputs, parsedParams } = parseNodeArgs(def, preparedForExec, node.id, node.type);
     const result = await invokeExecute(def, parsedInputs, parsedParams, ctx, node.id, node.type);
     const elapsed = Date.now() - t0;
-    const credits = def.cost ? def.cost({ params: parsedParams }).credits : 0;
+    const credits = charged ?? estimatedNodeCredits(def, parsedParams);
     const outputsObj = result;
     outputs[node.id] = outputsObj;
     if (this.persistAssets) {
@@ -5514,6 +5522,9 @@ async function invokeExecute(def, parsedInputs, parsedParams, ctx, nodeId, nodeT
     throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e });
   }
 }
+function estimatedNodeCredits(def, params) {
+  return def.cost ? def.cost({ params }).credits : 0;
+}
 function needsLocalMaterialization(def) {
   return def.location === "local" && !def.passthroughRefs;
 }
@@ -6366,17 +6377,17 @@ var FontRef = BaseAssetRef.extend({
 var AssetRef = z4.discriminatedUnion("kind", [ImageRef, VideoRef, AudioRef, JsonRef, TextRef, FontRef]);
 
 // src/engine/nodes/remote/delegate.ts
-function delegated(spec) {
+function delegated(spec2) {
   return {
-    ...spec,
+    ...spec2,
     location: "remote",
     execute: async ({ inputs, params, ctx }) => {
       return await callBackendExec({
-        nodeType: spec.id,
-        nodeVersion: spec.version,
+        nodeType: spec2.id,
+        nodeVersion: spec2.version,
         params,
         inputs,
-        outputKinds: resolveOutputKinds(spec.outputKinds, params),
+        outputKinds: resolveOutputKinds(spec2.outputKinds, params),
         ctx
       });
     }
@@ -6398,6 +6409,9 @@ async function callBackendExec(args) {
       },
       args.ctx.signal
     );
+    if (typeof res.credits_charged === "number" && Number.isFinite(res.credits_charged)) {
+      args.ctx.reportCharge?.(res.credits_charged);
+    }
     return await ingestOutputs(res.outputs, args.ctx, args.outputKinds);
   } catch (e) {
     throw mapClientError(args.ctx, e);
@@ -6749,22 +6763,22 @@ function inferMimeFromPath(absPath, sniffBytes) {
   return "application/octet-stream";
 }
 async function rasterizeSvgToPng(bytes) {
-  const { default: sharp } = await import("sharp");
-  const base = await sharp(bytes).metadata();
+  const { default: sharp2 } = await import("sharp");
+  const base = await sharp2(bytes).metadata();
   const longest = Math.max(base.width ?? 0, base.height ?? 0);
   let density = SVG_BASE_DENSITY;
   if (longest > 0) {
     const scaled = Math.round(SVG_BASE_DENSITY * SVG_TARGET_LONGEST_PX / longest);
     density = Math.min(SVG_MAX_DENSITY, Math.max(SVG_BASE_DENSITY, scaled));
   }
-  return await sharp(bytes, { density }).png({ force: true, palette: false }).toBuffer();
+  return await sharp2(bytes, { density }).png({ force: true, palette: false }).toBuffer();
 }
 var MODEL_SAFE_IMAGE_MIMES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
 var MAX_MODEL_REFERENCE_BYTES = 30 * 1024 * 1024;
 async function fitWithinReferenceLimit(bytes, mime, maxBytes) {
   if (bytes.byteLength <= maxBytes) return { bytes, mime };
-  const { default: sharp } = await import("sharp");
-  const read = () => sharp(bytes, { animated: true });
+  const { default: sharp2 } = await import("sharp");
+  const read = () => sharp2(bytes, { animated: true });
   const meta = await read().metadata();
   const animated = (meta.pages ?? 1) > 1;
   const keepAlpha = meta.hasAlpha === true;
@@ -6802,11 +6816,11 @@ async function toModelSafeImage(bytes, opts) {
   if (sniffSvg(bytes)) {
     return await fit(await rasterizeSvgToPng(bytes), "image/png", "svg");
   }
-  const { default: sharp } = await import("sharp");
+  const { default: sharp2 } = await import("sharp");
   let png;
   let format;
   try {
-    const img = sharp(bytes);
+    const img = sharp2(bytes);
     format = (await img.metadata()).format ?? "unknown";
     png = await img.png({ force: true }).toBuffer();
   } catch (e) {
@@ -7167,10 +7181,10 @@ function planSingleInputSlot(tmpDir, slot, ref, lookup, stagedInputs) {
 }
 function planOutputs(tmpDir, outputs, lookup) {
   const outputPaths = [];
-  for (const [name, spec] of Object.entries(outputs)) {
-    const ext = spec.ext.startsWith(".") ? spec.ext : `.${spec.ext}`;
+  for (const [name, spec2] of Object.entries(outputs)) {
+    const ext = spec2.ext.startsWith(".") ? spec2.ext : `.${spec2.ext}`;
     const absPath = path8.join(tmpDir, `out_${name}${ext}`);
-    outputPaths.push({ name, absPath, spec });
+    outputPaths.push({ name, absPath, spec: spec2 });
     lookup.set(`out.${name}`, absPath);
   }
   return outputPaths;
@@ -7278,7 +7292,7 @@ async function runCli(opts) {
 ${tailLines(stderr, 40)}`);
     }
     const result = {};
-    for (const { name, absPath, spec } of outputPaths) {
+    for (const { name, absPath, spec: spec2 } of outputPaths) {
       const s = await stat3(absPath).catch(() => null);
       if (!s?.isFile() || s.size === 0) {
         throw new Error(`cli-runner: declared output "${name}" missing or empty at ${absPath}`);
@@ -7286,8 +7300,8 @@ ${tailLines(stderr, 40)}`);
       const bytes = await readFile6(absPath);
       const ref = await ctx.assets.ingestBytes({
         bytes: Buffer.from(bytes),
-        kind: spec.kind,
-        mime: mimeForExt(spec.ext)
+        kind: spec2.kind,
+        mime: mimeForExt(spec2.ext)
       });
       result[name] = ref;
     }
@@ -7875,47 +7889,47 @@ async function loadCompositionMeta(compositionDir) {
 }
 function buildParamsSchema(meta) {
   const shape = {};
-  for (const [name, spec] of Object.entries(meta.params)) {
-    shape[name] = buildParamFieldSchema(name, spec);
+  for (const [name, spec2] of Object.entries(meta.params)) {
+    shape[name] = buildParamFieldSchema(name, spec2);
   }
   return z10.object(shape).strict();
 }
-function buildParamFieldSchema(name, spec) {
-  switch (spec.kind) {
+function buildParamFieldSchema(name, spec2) {
+  switch (spec2.kind) {
     case "string": {
-      const s = spec.enum && spec.enum.length > 0 ? z10.enum(spec.enum) : z10.string();
-      return finalize(s, spec.default, spec.required);
+      const s = spec2.enum && spec2.enum.length > 0 ? z10.enum(spec2.enum) : z10.string();
+      return finalize(s, spec2.default, spec2.required);
     }
     case "integer": {
       let s = z10.number().int();
-      if (spec.min !== void 0) s = s.min(spec.min);
-      if (spec.max !== void 0) s = s.max(spec.max);
-      return finalize(s, spec.default, spec.required);
+      if (spec2.min !== void 0) s = s.min(spec2.min);
+      if (spec2.max !== void 0) s = s.max(spec2.max);
+      return finalize(s, spec2.default, spec2.required);
     }
     case "number": {
       let s = z10.number();
-      if (spec.min !== void 0) s = s.min(spec.min);
-      if (spec.max !== void 0) s = s.max(spec.max);
-      return finalize(s, spec.default, spec.required);
+      if (spec2.min !== void 0) s = s.min(spec2.min);
+      if (spec2.max !== void 0) s = s.max(spec2.max);
+      return finalize(s, spec2.default, spec2.required);
     }
     case "boolean":
-      return finalize(z10.boolean(), spec.default, spec.required);
+      return finalize(z10.boolean(), spec2.default, spec2.required);
     case "color": {
       const s = z10.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
         message: `param "${name}": must be a 3/6/8-digit hex color (e.g. "#ff0066")`
       });
-      return finalize(s, spec.default, spec.required);
+      return finalize(s, spec2.default, spec2.required);
     }
     case "image":
-      return finalize(z10.union([z10.string().min(1), z10.record(z10.string(), z10.unknown())]), spec.default, spec.required);
+      return finalize(z10.union([z10.string().min(1), z10.record(z10.string(), z10.unknown())]), spec2.default, spec2.required);
     case "json":
       return finalize(
         z10.unknown().refine((v) => v !== void 0, { message: `param "${name}" is required` }),
-        spec.default,
-        spec.required
+        spec2.default,
+        spec2.required
       );
     default: {
-      const _exhaustive = spec;
+      const _exhaustive = spec2;
       throw new Error(`buildParamFieldSchema: unknown kind ${_exhaustive.kind}`);
     }
   }
@@ -8505,12 +8519,12 @@ async function stageInputs2(tmp, inputs, meta, ctx) {
   assertInputsMatchMeta(inputs, meta, "hyperframe_render");
   let primaryDuration = null;
   for (const [key, ref] of Object.entries(inputs ?? {})) {
-    const spec = meta.inputs[key];
-    if (!spec) continue;
-    const filename = spec.staged_as ?? defaultFilenameForInput(key, spec.kind);
+    const spec2 = meta.inputs[key];
+    if (!spec2) continue;
+    const filename = spec2.staged_as ?? defaultFilenameForInput(key, spec2.kind);
     await stageAsset(ref, tmp, filename);
-    ctx.log(`staged ${spec.kind} \u2192 ${filename}`);
-    if (spec.kind === "video" && primaryDuration === null) {
+    ctx.log(`staged ${spec2.kind} \u2192 ${filename}`);
+    if (spec2.kind === "video" && primaryDuration === null) {
       primaryDuration = await probeDurationSeconds(path15.join(tmp, filename));
     }
   }
@@ -8525,24 +8539,24 @@ function assertInputsMatchMeta(inputs, meta, nodeId) {
       throw new Error(`${nodeId}: inputs.${key} is not declared in composition meta.json (declares: ${declared})`);
     }
   }
-  for (const [key, spec] of Object.entries(meta.inputs)) {
-    if (spec.required && !providedKeys.has(key)) {
-      throw new Error(`${nodeId}: inputs.${key} is required (kind=${spec.kind})`);
+  for (const [key, spec2] of Object.entries(meta.inputs)) {
+    if (spec2.required && !providedKeys.has(key)) {
+      throw new Error(`${nodeId}: inputs.${key} is required (kind=${spec2.kind})`);
     }
   }
   for (const [key, ref] of Object.entries(inputs ?? {})) {
-    const spec = meta.inputs[key];
-    if (!spec) continue;
-    if (ref.kind !== spec.kind) {
-      throw new Error(`${nodeId}: inputs.${key} expected kind "${spec.kind}", got "${ref.kind}"`);
+    const spec2 = meta.inputs[key];
+    if (!spec2) continue;
+    if (ref.kind !== spec2.kind) {
+      throw new Error(`${nodeId}: inputs.${key} expected kind "${spec2.kind}", got "${ref.kind}"`);
     }
   }
 }
 async function buildSubstitutionValues(compositionParams, meta, duration) {
   const out = {};
   for (const [name, value] of Object.entries(compositionParams)) {
-    const spec = meta.params[name];
-    if (spec?.kind === "image") {
+    const spec2 = meta.params[name];
+    if (spec2?.kind === "image") {
       out[name] = await coerceImageParam(value);
       continue;
     }
@@ -8763,18 +8777,18 @@ async function vendorGsap2(tmp, ctx) {
 async function stageInputs3(tmp, inputs, meta, ctx) {
   assertInputsMatchMeta(inputs, meta, "hyperframe_snapshot");
   for (const [key, ref] of Object.entries(inputs ?? {})) {
-    const spec = meta.inputs[key];
-    if (!spec) continue;
-    const filename = spec.staged_as ?? defaultFilenameForInput(key, spec.kind);
+    const spec2 = meta.inputs[key];
+    if (!spec2) continue;
+    const filename = spec2.staged_as ?? defaultFilenameForInput(key, spec2.kind);
     await stageAsset(ref, tmp, filename);
-    ctx.log(`staged ${spec.kind} \u2192 ${filename}`);
+    ctx.log(`staged ${spec2.kind} \u2192 ${filename}`);
   }
 }
 async function buildSubstitutionValues2(compositionParams, meta) {
   const out = {};
   for (const [name, value] of Object.entries(compositionParams)) {
-    const spec = meta.params[name];
-    if (spec?.kind === "image") {
+    const spec2 = meta.params[name];
+    if (spec2?.kind === "image") {
       out[name] = await coerceImageParam2(value);
       continue;
     }
@@ -9007,7 +9021,12 @@ var imageGenerateNode = delegated({
   params: ImageGenerateParams,
   outputs: z17.object({ images: z17.array(ImageRef).min(1) }).strict(),
   outputKinds: { images: "image" },
-  cost: () => ({ credits: 5, seconds_estimate: 10 })
+  // An estimate for the pre-flight cap only: the run reports what the backend billed. A
+  // top-quality render measured 8-12 credits on gpt-image-2.5 (2026-09), so it is priced 10.
+  cost: ({ params }) => ({
+    credits: params.quality === "xhigh" || params.quality === "max" ? 10 : 5,
+    seconds_estimate: 10
+  })
 });
 
 // src/engine/nodes/remote/imageAspectAdapt.ts
@@ -9191,24 +9210,103 @@ var imageSearchNode = delegated({
 });
 
 // src/engine/nodes/remote/imageSelect.ts
+import { readFile as readFile13 } from "fs/promises";
 import { z as z24 } from "zod";
+
+// src/engine/nodes/local/lib/plate-space.ts
+import sharp from "sharp";
+var CELL = 6;
+var SAMPLE_WIDTH = 384;
+var CELL_EDGE = 0.02;
+var BUSY_LIMIT = 0.08;
+function clampSpan([a, b]) {
+  const lo = Math.max(0, Math.min(100, Math.min(a, b)));
+  const hi = Math.max(0, Math.min(100, Math.max(a, b)));
+  return [lo, hi];
+}
+function cellGradient(pixels, width, height, cx, cy) {
+  let sum = 0;
+  let n = 0;
+  for (let y = cy; y < cy + CELL && y + 1 < height; y++) {
+    for (let x = cx; x < cx + CELL && x + 1 < width; x++) {
+      const at = pixels[y * width + x] ?? 0;
+      sum += Math.abs((pixels[y * width + x + 1] ?? at) - at) + Math.abs((pixels[(y + 1) * width + x] ?? at) - at);
+      n += 2;
+    }
+  }
+  return n === 0 ? 0 : sum / n / 255;
+}
+function areaBusy(pixels, width, height, area) {
+  const [x0, x1] = clampSpan(area.x_pct).map((p) => Math.round(p / 100 * width));
+  const [y0, y1] = clampSpan(area.y_pct).map((p) => Math.round(p / 100 * height));
+  let cells = 0;
+  let busy = 0;
+  for (let cy = y0; cy + CELL <= y1; cy += CELL) {
+    for (let cx = x0; cx + CELL <= x1; cx += CELL) {
+      cells++;
+      if (cellGradient(pixels, width, height, cx, cy) > CELL_EDGE) busy++;
+    }
+  }
+  return cells === 0 ? 0 : busy / cells;
+}
+async function readReservedAreas(image, areas) {
+  if (areas.length === 0) return [];
+  const { data, info } = await sharp(image).greyscale().resize({ width: SAMPLE_WIDTH }).raw().toBuffer({ resolveWithObject: true });
+  const pixels = new Uint8Array(data.buffer, data.byteOffset, info.width * info.height);
+  return areas.map((area) => ({
+    for: area.for ?? "copy",
+    busy: Math.round(areaBusy(pixels, info.width, info.height, area) * 1e3) / 1e3
+  }));
+}
+var spanOf = (v) => Array.isArray(v) && v.length === 2 && typeof v[0] === "number" && typeof v[1] === "number" ? [v[0], v[1]] : null;
+function reservedAreasOf(spec2) {
+  const raw = spec2?.reserved_for_overlay;
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap((entry) => {
+    const e = entry;
+    const x = spanOf(e.x_pct);
+    const y = spanOf(e.y_pct);
+    return x && y ? [{ for: typeof e.for === "string" ? e.for : "copy", x_pct: x, y_pct: y }] : [];
+  });
+}
+function spaceVerdict(readings, limit = BUSY_LIMIT) {
+  const worst = readings.map((areas) => Math.max(0, ...areas.map((a) => a.busy)));
+  const calm = worst.flatMap((w, i) => w <= limit ? [i] : []);
+  const calmest = worst.reduce((best, w, i) => w < (worst[best] ?? Number.POSITIVE_INFINITY) ? i : best, 0);
+  const crowded = readings.flatMap((areas, image) => {
+    const over = areas.filter((a) => a.busy > limit);
+    return over.length > 0 ? [{ image, areas: over }] : [];
+  });
+  return { calm, calmest, crowded };
+}
+
+// src/engine/nodes/remote/imageSelect.ts
 var IMAGE_SELECT_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
-var imageSelectNode = delegated({
+var ImageSelectParams = z24.object({
+  model: z24.enum(IMAGE_SELECT_MODELS),
+  prompt: z24.string().min(1),
+  count: z24.number().int().min(1).default(1),
+  temperature: z24.number().min(0).max(2).optional(),
+  max_tokens: z24.number().int().positive().optional(),
+  /**
+   * Drop, before the judge, every candidate that filled an area the plate spec
+   * (`inputs.plate_spec`, prompt.plate.json) reserves for the copy. Read off the pixels in
+   * the Runtime: no model call. Never sent to the backend.
+   */
+  keep_reserved_areas: z24.boolean().optional()
+}).strict();
+var ImageSelectInputs = z24.object({ images: z24.array(ImageRef).min(2) }).loose();
+var ImageSelectOutputs = z24.object({ images: z24.array(ImageRef).min(1), reasoning: TextRef, space: JsonRef.optional() }).strict();
+var spec = {
   id: "image_select",
   version: "1.0.0",
   category: "vision",
   summary: "Pick the best `count` images out of 2+ candidates with a vision LLM, judged against a prompt. Outputs a passthrough subset of the input refs (no new pixels) plus the model's comparative reasoning.",
-  when_to_use: "Use after fanning out several image_generate variants (or any pool of 2+ images) to keep only the strongest before expensive downstream steps \u2014 video generation, reference sheets, final delivery. `count` fixes the output size, so `images#0`\u2026`images#count-1` are always safe to wire. Pick `~google/gemini-flash-latest` for cheap/fast picks and `~google/gemini-pro-latest` for harder aesthetic judgement.",
-  inputs: z24.object({ images: z24.array(ImageRef).min(2) }).loose(),
-  params: z24.object({
-    model: z24.enum(IMAGE_SELECT_MODELS),
-    prompt: z24.string().min(1),
-    count: z24.number().int().min(1).default(1),
-    temperature: z24.number().min(0).max(2).optional(),
-    max_tokens: z24.number().int().positive().optional()
-  }).strict(),
-  outputs: z24.object({ images: z24.array(ImageRef).min(1), reasoning: TextRef }).strict(),
-  outputKinds: { images: "image", reasoning: "text" },
+  when_to_use: "Use after fanning out several image_generate variants (or any pool of 2+ images) to keep only the strongest before expensive downstream steps \u2014 video generation, reference sheets, final delivery. `count` fixes the output size, so `images#0`\u2026`images#count-1` are always safe to wire. Pick `~google/gemini-flash-latest` for cheap/fast picks and `~google/gemini-pro-latest` for harder aesthetic judgement. With `keep_reserved_areas` and a `plate_spec` input, a candidate that put its subject where the copy goes is dropped before the judge (deterministic, free).",
+  inputs: ImageSelectInputs,
+  params: ImageSelectParams,
+  outputs: ImageSelectOutputs,
+  outputKinds: { images: "image", reasoning: "text", space: "json" },
   cost: () => ({ credits: 1, seconds_estimate: 5 }),
   // Arity is only knowable at validate time when `images` is a literal array
   // of refs; a single `$ref:` string to an upstream array output is deferred
@@ -9229,7 +9327,76 @@ var imageSelectNode = delegated({
     }
     return issues;
   }
-});
+};
+async function refBytes(ref, ctx) {
+  if (ref.path) return readFile13(ref.path);
+  if (!ref.url) throw new Error("image_select: an input has neither a local path nor a url");
+  const local = await ctx.assets.ingestRemote({
+    kind: ref.kind,
+    url: ref.url,
+    sha256: ref.sha256,
+    mime: ref.mime
+  });
+  return readFile13(local.path ?? "");
+}
+async function localText(ctx, body) {
+  const ref = await ctx.assets.ingestBytes({ bytes: Buffer.from(body, "utf8"), kind: "text", mime: "text/plain" });
+  return TextRef.parse(ref);
+}
+async function localJson(ctx, value) {
+  const bytes = Buffer.from(JSON.stringify(value), "utf8");
+  return JsonRef.parse(await ctx.assets.ingestBytes({ bytes, kind: "json", mime: "application/json" }));
+}
+function judge(inputs, params, ctx) {
+  return callBackendExec({
+    nodeType: spec.id,
+    nodeVersion: spec.version,
+    params,
+    inputs,
+    outputKinds: { images: "image", reasoning: "text" },
+    ctx
+  });
+}
+async function selectKeepingSpace(inputs, params, ctx) {
+  const { keep_reserved_areas: _keep, ...backendParams } = params;
+  const specRef = inputs.plate_spec;
+  const parsedSpec = JsonRef.safeParse(specRef);
+  const areas = parsedSpec.success ? reservedAreasOf(JSON.parse((await refBytes(parsedSpec.data, ctx)).toString("utf8"))) : [];
+  if (areas.length === 0) return judge(inputs, backendParams, ctx);
+  const readings = await Promise.all(
+    inputs.images.map(async (image) => readReservedAreas(await refBytes(image, ctx), areas))
+  );
+  const verdict = spaceVerdict(readings);
+  const kept = verdict.calm.length > 0 ? verdict.calm : [verdict.calmest];
+  for (const { image, areas: over } of verdict.crowded) {
+    ctx.log(
+      `[space   ] ${ctx.nodeId}: picture ${image + 1} put its subject where the ${over.map((a) => a.for).join(", ")} goes${verdict.calm.length > 0 ? " \u2014 dropped before the judge" : ""}`
+    );
+  }
+  const report = {
+    none_calm: verdict.calm.length === 0,
+    kept: kept.map((i) => i + 1),
+    dropped: verdict.crowded.map((c) => c.image + 1).filter((n) => !kept.includes(n - 1)),
+    crowded: verdict.crowded.map((c) => ({ picture: c.image + 1, areas: c.areas }))
+  };
+  const space = await localJson(ctx, report);
+  if (kept.length < Math.max(2, params.count)) {
+    const chosen = kept.map((i) => inputs.images[i]).filter((i) => i !== void 0);
+    const why = verdict.calm.length === 0 ? `No picture kept the room the copy needs; picture ${(kept[0] ?? 0) + 1} crowds it least.` : `Only picture ${(kept[0] ?? 0) + 1} kept the room the copy needs; the others were dropped before judging.`;
+    return { images: chosen, reasoning: await localText(ctx, why), space };
+  }
+  const subset = { ...inputs, images: kept.map((i) => inputs.images[i]).filter((i) => i !== void 0) };
+  return { ...await judge(subset, backendParams, ctx), space };
+}
+var remote = delegated(spec);
+var imageSelectNode = {
+  ...remote,
+  execute: ({ inputs, params, ctx }) => {
+    if (params.keep_reserved_areas) return selectKeepingSpace(inputs, params, ctx);
+    const { keep_reserved_areas: _keep, ...backendParams } = params;
+    return judge(inputs, backendParams, ctx);
+  }
+};
 
 // src/engine/nodes/remote/music.ts
 import { z as z25 } from "zod";
@@ -9575,7 +9742,7 @@ var videoLipsyncNode = delegated({
 });
 
 // src/engine/nodes/remote/videoTranscribe.ts
-import { mkdtemp as mkdtemp6, readFile as readFile13, rm as rm6 } from "fs/promises";
+import { mkdtemp as mkdtemp6, readFile as readFile14, rm as rm6 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import path17 from "path";
 import { z as z33 } from "zod";
@@ -9722,7 +9889,7 @@ async function tryExtractAudio(inputs, ctx) {
       ["-i", video.path, "-vn", "-ac", "1", "-ar", "16000", "-b:a", "64k", "-f", "mp3", "-y", audioPath],
       { timeout_ms: AUDIO_EXTRACT_TIMEOUT_MS }
     );
-    const bytes = await readFile13(audioPath);
+    const bytes = await readFile14(audioPath);
     if (bytes.byteLength === 0) {
       ctx.log("video_transcribe: extracted audio is empty, sending full video");
       return null;
@@ -9917,7 +10084,7 @@ function safeCost(def) {
 
 // src/engine/storage/cache-store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir3, readFile as readFile14, rename as rename2, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile15, rename as rename2, writeFile as writeFile8 } from "fs/promises";
 import path18 from "path";
 var LocalCacheStore = class {
   rootDir;
@@ -9929,7 +10096,7 @@ var LocalCacheStore = class {
   }
   async get(cacheKey) {
     try {
-      const buf = await readFile14(this.filePath(cacheKey), "utf8");
+      const buf = await readFile15(this.filePath(cacheKey), "utf8");
       return JSON.parse(buf);
     } catch (e) {
       if (e.code === "ENOENT") return null;
@@ -10054,6 +10221,7 @@ export {
   bestSupportedQuality,
   nearestSupportedAspectRatio,
   nearestSupportedImageSize,
+  CREDITS_PER_USD,
   estimateVideoCredits,
   resolveConcurrency,
   ulid,
@@ -10084,6 +10252,9 @@ export {
   coercePathUrlToUrl,
   toModelSafeImage,
   loadCompositionMeta,
+  readReservedAreas,
+  reservedAreasOf,
+  spaceVerdict,
   catalogView,
   BackendClient2,
   Engine2 as Engine,
@@ -10095,4 +10266,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-JLKUHDBB.js.map
+//# sourceMappingURL=chunk-Q3LMLQAI.js.map