scenri 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.6.0](https://github.com/tonygorb/Scenri/compare/v0.5.1...v0.6.0) (2026-08-26)
+
+
+### Features
+
+* an extend keeps the exact picture unless the join would show ([af6d8ba](https://github.com/tonygorb/Scenri/commit/af6d8baecbe6b524e7333ad0b63663f73c213642))
+* an extend keeps the exact picture unless the join would show ([bb48b52](https://github.com/tonygorb/Scenri/commit/bb48b52c77dcc1fc62f0ffc35cd26a81934f9423))
+* composite both draws and keep the better join ([8bbada7](https://github.com/tonygorb/Scenri/commit/8bbada70cf84268c347166bdeb768767b99386df))
+
+
+### Bug Fixes
+
+* codex reads at most five images, and the sixth was the shot itself ([91fe75e](https://github.com/tonygorb/Scenri/commit/91fe75e017c25313f64b79fb4d4b32cfc628838a))
+* codex reads at most five images, and the sixth was the shot itself ([3e3c430](https://github.com/tonygorb/Scenri/commit/3e3c4307df355cf7091a905b5416f5eabbb88504))
+
+## [0.5.1](https://github.com/tonygorb/Scenri/compare/v0.5.0...v0.5.1) (2026-08-26)
+
+
+### Bug Fixes
+
+* a grown frame keeps its subject's place and solves its own seam ([9d2108b](https://github.com/tonygorb/Scenri/commit/9d2108b2e5af29e1a6efdd531b82b647ec1c58ad))
+* a grown frame keeps its subject's place and solves its own seam ([d45bf73](https://github.com/tonygorb/Scenri/commit/d45bf73d4760573af863b2f4533983382b16795c))
+
 ## [0.5.0](https://github.com/tonygorb/Scenri/compare/v0.4.7...v0.5.0) (2026-08-25)
 
 

package/dist/serve.js

@@ -1238,9 +1238,9 @@ function libraryMethods(db) {
           local: String(i.sourceUrl).startsWith("local:")
         });
         const seen = /* @__PURE__ */ new Set();
-        const usable = images.filter((i) => i.assetRef && !seen.has(i.assetRef) && seen.add(i.assetRef));
-        const shots = usable.filter((i) => !i.excluded).map(shot);
-        const hiddenShots = usable.filter((i) => i.excluded).map(shot);
+        const usable2 = images.filter((i) => i.assetRef && !seen.has(i.assetRef) && seen.add(i.assetRef));
+        const shots = usable2.filter((i) => !i.excluded).map(shot);
+        const hiddenShots = usable2.filter((i) => i.excluded).map(shot);
         return {
           id: `cat-${p.id}`,
           name: p.title,
@@ -2485,14 +2485,27 @@ function createCodexEngine(opts) {
         // OSS-local only: the user's own session, on the user's own machine
         supportsEdit: true,
         supportsMask: false,
-        // The underlying `codex` binary's --image flag is genuinely variadic
-        // ("-i, --image <FILE>...", re-confirmed via `codex exec --help`), so
-        // this number is a product decision, not a binary constraint. It is
-        // sized to hold a full identity payload without eviction:
-        // PRODUCT_REF_MAX (3 angles) + CHARACTER_REF_MAX (2 views) + one
-        // style reference = 6. Below this, compileBrief's role-priority clamp
-        // starts dropping real identity information.
-        maxReferenceImages: 6
+        /*
+         * Five, and it is a hard constraint of the image tool, not a product
+         * choice.
+         *
+         * The `codex` binary's --image flag really is variadic, which is why
+         * this used to be 6 — one style reference on top of PRODUCT_REF_MAX (3)
+         * plus CHARACTER_REF_MAX (2). But the flag only puts pictures into the
+         * conversation; the thing that consumes them is codex's built-in
+         * image_gen tool, and that caps at five either way it is called:
+         * `referenced_image_paths` longer than five is a hard tool error, and
+         * `num_last_images_to_include` is validated to 1..=5
+         * (codex-rs/ext/image-generation/src/tool.rs, MAX_EDIT_IMAGES = 5).
+         *
+         * Six was therefore not a generous budget, it was an eviction. On the
+         * context route `recent_images` walks the history BACKWARDS and keeps
+         * the last five, so the sixth image to be dropped is the FIRST one
+         * attached — and on an edit the first one attached is `input.png`, the
+         * shot being edited. A refine carrying a full identity payload was
+         * silently editing nothing at all.
+         */
+        maxReferenceImages: 5
       };
     },
     isAvailable() {
@@ -6141,13 +6154,52 @@ function planExpand(source, targetRatio) {
 function expandInstruction(plan, direction) {
   const where = plan.axis === "width" ? "left and right" : "top and bottom";
   const nearEdge = plan.axis === "height" ? "\nDepth: the bottom edge of the frame is the part of the surface nearest the camera; the top edge is the furthest away." : "";
-  const own = direction.trim() ? `
-Also: ${direction.trim()}` : "";
+  const extra = direction.trim().replace(/^[.\s]+/, "");
+  const own = extra ? `
+Also: ${extra}` : "";
   return `Fill only the soft blurred margin at the ${where} of this frame so the photograph continues into it.
 Continue: the same surface, the same light direction, the same colour temperature and the same depth of field that are already in the picture.` + nearEdge + `
 Constraints: change only the blurred margin; keep the sharp photograph unchanged in position, scale and content.
 Avoid: new objects, products, people, text or watermarks.` + own;
 }
+var NAMED_RATIOS = [
+  ["1:1", 1],
+  ["4:5", 4 / 5],
+  ["5:4", 5 / 4],
+  ["2:3", 2 / 3],
+  ["3:2", 3 / 2],
+  ["3:4", 3 / 4],
+  ["4:3", 4 / 3],
+  ["9:16", 9 / 16],
+  ["16:9", 16 / 9],
+  ["2:1", 2],
+  ["1:2", 0.5]
+];
+function ratioLabel(width, height) {
+  const ratio = width / height;
+  for (const [label, value] of NAMED_RATIOS) {
+    if (Math.abs(ratio - value) / value < 0.02) return label;
+  }
+  const gcd = (a, b) => b ? gcd(b, a % b) : a;
+  const d = gcd(width, height) || 1;
+  return `${Math.round(width / d)}:${Math.round(height / d)}`;
+}
+function reframeInstruction(plan, source, direction) {
+  const wider = plan.axis === "width";
+  const where = wider ? "to the left and to the right" : "above and below";
+  const shape = ratioLabel(plan.width, plan.height);
+  const share = wider ? source.width / plan.width : source.height / plan.height;
+  const middle = `${Math.round(share * 100)}%`;
+  const span = wider ? "width" : "height";
+  const nearEdge = wider ? "" : "\nDepth: the bottom edge of the frame is the part of the surface nearest the camera; the top edge is the furthest away.";
+  const extra = direction.trim().replace(/^[.\s]+/, "");
+  const own = extra ? `
+Also: ${extra}` : "";
+  return `Redraw this photograph as one ${shape} frame, ${wider ? "wider" : "taller"} than it is now, revealing more of the same scene ${where}.
+Frame: the photograph you were given is the middle ${middle} of the new frame's ${span}; everything outside that is scene that was just beyond the original edges.
+Keep: every object in the same place at the same size, the same camera position and height, the same light direction and colour temperature, the same depth of field, the same colours, and the same clothing.` + nearEdge + `
+Avoid: new objects, products, people, text or watermarks; do not recompose, recentre, crop or resize anything already visible.` + own;
+}
 
 // src/cropRules.ts
 function planCrop(source, targetRatio) {
@@ -6173,6 +6225,148 @@ async function attentionCropOrigin(srcBuf, source, plan) {
     return { left: plan.left, top: plan.top };
   }
 }
+
+// src/outpaint/membrane.ts
+var SOLVE_MAX_EDGE = 192;
+var SOLVE_MIN_EDGE = 8;
+var SWEEPS_PER_EDGE = 2;
+var MIN_SWEEPS = 40;
+var POLISH_SWEEPS = 32;
+var POLISH_MAX_CELLS = 4e6;
+function solveMembrane(req) {
+  const { width, height, axis, seamAt } = req;
+  const along = axis === "width" ? height : width;
+  const depth = axis === "width" ? width : height;
+  const out = new Float32Array(width * height * 3);
+  if (width < 1 || height < 1 || along < 1 || depth < 1) return out;
+  if (depth === 1) {
+    for (let a = 0; a < along; a++) {
+      const off = marginOffset(0, a, width, axis, seamAt, depth) * 3;
+      for (let c = 0; c < 3; c++) out[off + c] = req.seam[a * 3 + c];
+    }
+    return out;
+  }
+  const coarse = cascade(req.seam, along, depth);
+  if (depth * along <= POLISH_MAX_CELLS) {
+    const full = { along, depth, data: new Float32Array(along * depth * 3) };
+    prolong(coarse, full);
+    relax(full, req.seam, POLISH_SWEEPS);
+    for (let d = 0; d < depth; d++) {
+      for (let a = 0; a < along; a++) {
+        const off = marginOffset(d, a, width, axis, seamAt, depth) * 3;
+        const src = (d * along + a) * 3;
+        out[off] = full.data[src];
+        out[off + 1] = full.data[src + 1];
+        out[off + 2] = full.data[src + 2];
+      }
+    }
+    return out;
+  }
+  for (let d = 0; d < depth; d++) {
+    for (let a = 0; a < along; a++) {
+      const off = marginOffset(d, a, width, axis, seamAt, depth) * 3;
+      sampleGrid(coarse, d, a, depth, along, out, off);
+    }
+  }
+  return out;
+}
+function marginOffset(d, a, width, axis, seamAt, depth) {
+  if (axis === "width") {
+    const x = seamAt === "far" ? depth - 1 - d : d;
+    return a * width + x;
+  }
+  const y = seamAt === "far" ? depth - 1 - d : d;
+  return y * width + a;
+}
+function cascade(seam, along, depth) {
+  const scale = Math.max(1, Math.ceil(Math.max(along, depth) / SOLVE_MAX_EDGE));
+  const targetAlong = Math.max(2, Math.round(along / scale));
+  const targetDepth = Math.max(2, Math.round(depth / scale));
+  const edges = [];
+  for (let e = SOLVE_MIN_EDGE; e < Math.max(targetAlong, targetDepth); e *= 2) edges.push(e);
+  edges.push(Math.max(targetAlong, targetDepth));
+  let grid = null;
+  for (const edge of edges) {
+    const ratio = edge / Math.max(targetAlong, targetDepth);
+    const la = Math.max(2, Math.round(targetAlong * ratio));
+    const ld = Math.max(2, Math.round(targetDepth * ratio));
+    const next = { along: la, depth: ld, data: new Float32Array(la * ld * 3) };
+    if (grid) prolong(grid, next);
+    relax(next, resampleSeam(seam, along, la));
+    grid = next;
+  }
+  return grid;
+}
+function resampleSeam(seam, along, to) {
+  const out = new Float32Array(to * 3);
+  for (let i = 0; i < to; i++) {
+    const src = to === 1 ? 0 : i * (along - 1) / (to - 1);
+    const lo = Math.floor(src);
+    const hi = Math.min(along - 1, lo + 1);
+    const t = src - lo;
+    for (let c = 0; c < 3; c++) out[i * 3 + c] = seam[lo * 3 + c] * (1 - t) + seam[hi * 3 + c] * t;
+  }
+  return out;
+}
+function prolong(from, to) {
+  for (let d = 0; d < to.depth; d++) {
+    const sd = to.depth === 1 ? 0 : d * (from.depth - 1) / (to.depth - 1);
+    for (let a = 0; a < to.along; a++) {
+      const sa = to.along === 1 ? 0 : a * (from.along - 1) / (to.along - 1);
+      sampleGrid(from, sd, sa, from.depth, from.along, to.data, (d * to.along + a) * 3);
+    }
+  }
+}
+function sampleGrid(grid, d, a, fromDepth, fromAlong, into, off) {
+  const sd = fromDepth === grid.depth ? d : grid.depth === 1 ? 0 : d * (grid.depth - 1) / (fromDepth - 1);
+  const sa = fromAlong === grid.along ? a : grid.along === 1 ? 0 : a * (grid.along - 1) / (fromAlong - 1);
+  const d0 = Math.floor(sd);
+  const a0 = Math.floor(sa);
+  const d1 = Math.min(grid.depth - 1, d0 + 1);
+  const a1 = Math.min(grid.along - 1, a0 + 1);
+  const td = sd - d0;
+  const ta = sa - a0;
+  const i00 = (d0 * grid.along + a0) * 3;
+  const i01 = (d0 * grid.along + a1) * 3;
+  const i10 = (d1 * grid.along + a0) * 3;
+  const i11 = (d1 * grid.along + a1) * 3;
+  for (let c = 0; c < 3; c++) {
+    const top = grid.data[i00 + c] * (1 - ta) + grid.data[i01 + c] * ta;
+    const bot = grid.data[i10 + c] * (1 - ta) + grid.data[i11 + c] * ta;
+    into[off + c] = top * (1 - td) + bot * td;
+  }
+}
+function relax(grid, seam, fixedSweeps) {
+  const { depth, along, data } = grid;
+  for (let a = 0; a < along; a++) {
+    const off = a * 3;
+    for (let c = 0; c < 3; c++) data[off + c] = seam[off + c];
+  }
+  if (depth < 2) return;
+  const n = Math.max(depth, along);
+  const omega = Math.min(1.99, 2 / (1 + Math.sin(Math.PI / Math.max(2, n))));
+  const sweeps = fixedSweeps ?? Math.max(MIN_SWEEPS, SWEEPS_PER_EDGE * n);
+  for (let sweep = 0; sweep < sweeps; sweep++) {
+    for (let parity = 0; parity < 2; parity++) {
+      for (let d = 1; d < depth; d++) {
+        const row = d * along;
+        const rowUp = (d - 1) * along;
+        const rowDn = (d < depth - 1 ? d + 1 : d - 1) * along;
+        for (let a = (d + parity) % 2; a < along; a += 2) {
+          const iL = row + (a > 0 ? a - 1 : Math.min(1, along - 1));
+          const iR = row + (a < along - 1 ? a + 1 : Math.max(0, along - 2));
+          const i = row + a;
+          for (let c = 0; c < 3; c++) {
+            const avg = (data[(rowUp + a) * 3 + c] + data[(rowDn + a) * 3 + c] + data[iL * 3 + c] + data[iR * 3 + c]) * 0.25;
+            data[i * 3 + c] += omega * (avg - data[i * 3 + c]);
+          }
+        }
+      }
+    }
+  }
+}
+
+// src/expand.ts
 async function expandCanvas(source, plan) {
   const bed = await sharp7(source).resize(plan.width, plan.height, { fit: "cover", position: "centre" }).blur(Math.max(8, Math.round(Math.max(plan.width, plan.height) / 40))).toBuffer();
   return sharp7(bed).composite([{ input: source, left: plan.left, top: plan.top }]).png().toBuffer();
@@ -6267,17 +6461,27 @@ async function reconcile(surround, source, side, axis) {
       smooth[i * 3 + c] = sum / n;
     }
   }
-  const depth = axis === "width" ? W : H;
+  const half = Math.max(1, Math.floor(along / 2));
+  const centreLo = (half - 1) / 2;
+  const centreHi = half + (along - half - 1) / 2;
+  const span = Math.max(1, centreHi - centreLo);
+  const base = [0, 0, 0];
+  const slope = [0, 0, 0];
+  for (let c = 0; c < 3; c++) {
+    const lo = medianOf(smooth, c, 0, half);
+    const hi = medianOf(smooth, c, half, along);
+    slope[c] = (hi - lo) / span;
+    base[c] = lo - slope[c] * centreLo;
+    for (let i = 0; i < along; i++) smooth[i * 3 + c] -= base[c] + slope[c] * i;
+  }
+  const field = solveMembrane({ width: W, height: H, axis, seamAt: side.seamAt, seam: smooth });
   const corrected = Buffer.from(marginRaw);
   for (let y = 0; y < H; y++) {
     for (let x = 0; x < W; x++) {
-      const d = axis === "width" ? side.seamAt === "far" ? W - 1 - x : x : side.seamAt === "far" ? H - 1 - y : y;
-      const fall = 1 - d / Math.max(1, depth - 1);
-      if (fall <= 0) continue;
       const i = axis === "width" ? y : x;
       const off = (y * W + x) * 3;
       for (let c = 0; c < 3; c++) {
-        const v = corrected[off + c] + smooth[i * 3 + c] * fall;
+        const v = corrected[off + c] + base[c] + slope[c] * i + field[off + c];
         corrected[off + c] = v < 0 ? 0 : v > 255 ? 255 : Math.round(v);
       }
     }
@@ -6288,6 +6492,24 @@ async function reconcile(surround, source, side, axis) {
 async function expandCanvasBedOnly(source, plan) {
   return sharp7(source).resize(plan.width, plan.height, { fit: "cover", position: "centre" }).blur(Math.max(8, Math.round(Math.max(plan.width, plan.height) / 40))).toBuffer();
 }
+function medianOf(rgb, channel, from, to) {
+  const n = to - from;
+  if (n < 1) return 0;
+  const values = new Float64Array(n);
+  for (let i = 0; i < n; i++) values[i] = rgb[(from + i) * 3 + channel];
+  values.sort();
+  return n % 2 ? values[(n - 1) / 2] : (values[n / 2 - 1] + values[n / 2]) / 2;
+}
+async function reframeExpand(engineImage, plan) {
+  const meta = await sharp7(engineImage).metadata();
+  if (!(meta.width && meta.height)) return null;
+  const want = plan.width / plan.height;
+  const got = meta.width / meta.height;
+  if (got >= 1 !== want >= 1) return null;
+  if (meta.width === plan.width && meta.height === plan.height) return engineImage;
+  const straight = Math.abs(got - want) / want <= 0.02;
+  return sharp7(engineImage).resize(plan.width, plan.height, { fit: straight ? "fill" : "cover", position: "centre" }).png().toBuffer();
+}
 async function seamScore(image, plan, source) {
   const { data, info } = await sharp7(image).removeAlpha().greyscale().raw().toBuffer({ resolveWithObject: true });
   const W = info.width;
@@ -6318,6 +6540,177 @@ async function seamScore(image, plan, source) {
   const second = first + (horizontal ? source.width : source.height);
   return Math.max(at(first), at(second));
 }
+var SEAM_VISIBLE = 2.2;
+var OFFSET = 4;
+var RESIDUAL_VISIBLE = 15;
+async function seamResidual(image, plan, source) {
+  const { data, info } = await sharp7(image).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const W = info.width;
+  const H = info.height;
+  const ch = info.channels;
+  const horizontal = plan.axis === "width";
+  const between = (a, b) => {
+    const limit = horizontal ? W : H;
+    if (a < 0 || b < 0 || a >= limit || b >= limit) return null;
+    const run2 = horizontal ? H : W;
+    let sum = 0;
+    for (let i = 0; i < run2; i++) {
+      const ia = (horizontal ? i * W + a : a * W + i) * ch;
+      const ib = (horizontal ? i * W + b : b * W + i) * ch;
+      sum += Math.abs(data[ia] - data[ib]) + Math.abs(data[ia + 1] - data[ib + 1]) + Math.abs(data[ia + 2] - data[ib + 2]);
+    }
+    return sum / (run2 * 3);
+  };
+  const near = horizontal ? plan.left : plan.top;
+  const far = near + (horizontal ? source.width : source.height);
+  const both = [
+    // The margin before the picture starts, against the picture just inside it.
+    between(near - OFFSET, near + OFFSET - 1),
+    // The picture just before it ends, against the margin just after.
+    between(far - OFFSET, far + OFFSET - 1)
+  ].filter((v) => v !== null);
+  return both.length ? Math.max(...both) : 0;
+}
+function seamPenalty(score, residual) {
+  return Math.max(score / SEAM_VISIBLE, residual / RESIDUAL_VISIBLE);
+}
+var MIN_SHARE = 0.2;
+var MAX_SHARE = 0.8;
+async function subjectFraction(src, source, axis) {
+  try {
+    const window = axis === "width" ? { width: Math.max(8, Math.round(source.width * 0.5)), height: source.height } : { width: source.width, height: Math.max(8, Math.round(source.height * 0.5)) };
+    const { info } = await sharp7(src).resize(window.width, window.height, { fit: "cover", position: "attention" }).toBuffer({ resolveWithObject: true });
+    const offset = axis === "width" ? Math.abs(typeof info.cropOffsetLeft === "number" ? info.cropOffsetLeft : 0) : Math.abs(typeof info.cropOffsetTop === "number" ? info.cropOffsetTop : 0);
+    const span = axis === "width" ? source.width : source.height;
+    const extent = axis === "width" ? window.width : window.height;
+    const centre = (offset + extent / 2) / span;
+    return Math.min(1, Math.max(0, (centre + 0.5) / 2));
+  } catch {
+    return 0.5;
+  }
+}
+function placeExpand(plan, source, fraction) {
+  const share = Math.min(MAX_SHARE, Math.max(MIN_SHARE, fraction));
+  if (plan.axis === "width") {
+    const room2 = plan.width - source.width;
+    if (room2 <= 0) return plan;
+    return { ...plan, left: Math.min(room2, Math.max(0, Math.round(room2 * share))) };
+  }
+  const room = plan.height - source.height;
+  if (room <= 0) return plan;
+  return { ...plan, top: Math.min(room, Math.max(0, Math.round(room * share))) };
+}
+var NEUTRAL = { r: 128, g: 128, b: 128 };
+async function conditioningCanvas(source, plan, fill = "edge") {
+  const meta = await sharp7(source).metadata();
+  const sw = meta.width ?? 0;
+  const sh = meta.height ?? 0;
+  if (!(sw > 0 && sh > 0)) throw new Error("conditioningCanvas: source has no dimensions");
+  const layers = [];
+  if (fill === "edge") layers.push(...await edgeMargins(source, plan, { width: sw, height: sh }));
+  layers.push({ input: source, left: plan.left, top: plan.top });
+  const canvas = sharp7({
+    create: {
+      width: plan.width,
+      height: plan.height,
+      channels: 4,
+      background: fill === "transparent" ? { ...NEUTRAL, alpha: 0 } : { ...NEUTRAL, alpha: 1 }
+    }
+  }).composite(layers);
+  return (fill === "transparent" ? canvas : canvas.removeAlpha()).png().toBuffer();
+}
+async function edgeMargins(source, plan, size) {
+  const out = [];
+  const strip = async (extract, width, height) => sharp7(source).extract(extract).resize(width, height, { fit: "fill" }).png().toBuffer();
+  if (plan.axis === "width") {
+    const before = plan.left;
+    const after = plan.width - plan.left - size.width;
+    if (before > 0)
+      out.push({
+        input: await strip({ left: 0, top: 0, width: 1, height: size.height }, before, size.height),
+        left: 0,
+        top: plan.top
+      });
+    if (after > 0)
+      out.push({
+        input: await strip({ left: size.width - 1, top: 0, width: 1, height: size.height }, after, size.height),
+        left: plan.left + size.width,
+        top: plan.top
+      });
+    return out;
+  }
+  const above = plan.top;
+  const below = plan.height - plan.top - size.height;
+  if (above > 0)
+    out.push({
+      input: await strip({ left: 0, top: 0, width: size.width, height: 1 }, size.width, above),
+      left: plan.left,
+      top: 0
+    });
+  if (below > 0)
+    out.push({
+      input: await strip({ left: 0, top: size.height - 1, width: size.width, height: 1 }, size.width, below),
+      left: plan.left,
+      top: plan.top + size.height
+    });
+  return out;
+}
+
+// src/outpaint/choose.ts
+function chooseExpand(candidates) {
+  const { preserved, reframed } = candidates;
+  const best = preserved.reduce(
+    (winner, c) => winner === null || c.seam < winner.seam ? c : winner,
+    null
+  );
+  if (!best && !reframed) return null;
+  if (!best && reframed) {
+    return { choice: "reframed", image: reframed.image, reason: "only-candidate", seam: null };
+  }
+  const won = best;
+  if (!reframed) {
+    return {
+      choice: "preserved",
+      image: won.image,
+      reason: "only-candidate",
+      seam: won.seam,
+      from: won.from
+    };
+  }
+  if (won.seam < SEAM_VISIBLE) {
+    return {
+      choice: "preserved",
+      image: won.image,
+      reason: "join-invisible",
+      seam: won.seam,
+      from: won.from
+    };
+  }
+  return { choice: "reframed", image: reframed.image, reason: "join-visible", seam: won.seam };
+}
+
+// src/outpaint/route.ts
+var canOutpaint = (e) => {
+  const caps = e.capabilities();
+  return caps.supportsOutpaint === true;
+};
+var usable = async (e) => {
+  try {
+    return (await e.isAvailable()).ok;
+  } catch {
+    return false;
+  }
+};
+async function resolveOutpaintRoute(all, shot) {
+  if (canOutpaint(shot)) return { engine: shot, method: "outpaint", crossed: false };
+  const shotId = shot.capabilities().id;
+  for (const candidate of all) {
+    const caps = candidate.capabilities();
+    if (caps.id === shotId || caps.placeholder || !canOutpaint(candidate)) continue;
+    if (await usable(candidate)) return { engine: candidate, method: "outpaint", crossed: true };
+  }
+  return { engine: shot, method: "reframe", crossed: false };
+}
 async function driftDiff(a, b) {
   const metaA = await sharp7(a).metadata();
   const metaB = await sharp7(b).metadata();
@@ -7430,6 +7823,30 @@ function registerImageRoutes(app, deps) {
 
 // src/release/notes.data.ts
 var RELEASES = [
+  {
+    version: "0.6.0",
+    date: "2026-08-26",
+    sections: [
+      {
+        heading: "Shots",
+        body: "Changing a shot to a wider or taller shape now keeps the original photograph wherever that can be done without a visible join, and rebuilds the frame as one coherent picture where it cannot. Scenri draws the new frame two ways, looks at both joins, and keeps the one you cannot find."
+      },
+      {
+        heading: "Fixes",
+        body: "A refinement carrying a full set of product and presenter references now reaches the engine with the shot itself attached. Codex reads five pictures at most, and a sixth was quietly displacing the frame being refined."
+      }
+    ]
+  },
+  {
+    version: "0.5.1",
+    date: "2026-08-26",
+    sections: [
+      {
+        heading: "Shots",
+        body: "An extended shot keeps its subject where it was composed, so a product standing near one edge stays near that edge in the wider frame rather than drifting to the middle. The new margin now meets the picture across the whole join instead of only at the seam, so a difference in tone or light no longer survives out at the frame edge. Where a connected engine can paint a margin directly, an extension is handed to it."
+      }
+    ]
+  },
   {
     version: "0.5.0",
     date: "2026-08-26",
@@ -8620,6 +9037,9 @@ function buildServer(opts) {
     let work;
     let expectShape;
     let editedFrom = null;
+    let runEngine = engine;
+    let expandMethod = null;
+    let expandDecision = null;
     if (compiled2) {
       finalPrompt = compiled2.prompt;
       referenceImages = compiled2.referenceImages;
@@ -8666,11 +9086,21 @@ function buildServer(opts) {
       }
       if (reshape === "extend" && !expandPlan)
         return reply.status(400).send({ error: "the picture is already this shape" });
-      const canOutpaint = expandPlan ? engine.capabilities().supportsOutpaint === true : false;
+      if (expandPlan && srcMeta.width && srcMeta.height) {
+        const size = { width: srcMeta.width, height: srcMeta.height };
+        expandPlan = placeExpand(expandPlan, size, await subjectFraction(srcBuf, size, expandPlan.axis));
+      }
       if (expandPlan) {
-        if (!canOutpaint) {
-          const canvas = await expandCanvas(srcBuf, expandPlan);
-          expandSourceHash = core.images.save(canvas);
+        const route = await resolveOutpaintRoute(engines.all(), engine);
+        runEngine = route.engine;
+        expandMethod = route.method;
+      }
+      const canOutpaint2 = expandMethod === "outpaint";
+      let reframeSourceHash;
+      if (expandPlan) {
+        if (!canOutpaint2) {
+          expandSourceHash = core.images.save(await expandCanvas(srcBuf, expandPlan));
+          reframeSourceHash = core.images.save(await conditioningCanvas(srcBuf, expandPlan, "edge"));
         }
         expectShape = { width: expandPlan.width, height: expandPlan.height };
       }
@@ -8685,7 +9115,7 @@ function buildServer(opts) {
         ...expandPlan ? { width: expandPlan.width, height: expandPlan.height } : {},
         // Only an engine that can genuinely paint a margin is told where the
         // picture sits; the rest would ignore it anyway.
-        ...expandPlan && canOutpaint ? {
+        ...expandPlan && canOutpaint2 ? {
           expand: {
             left: expandPlan.left,
             top: expandPlan.top,
@@ -8700,40 +9130,82 @@ function buildServer(opts) {
           seed: seedFor(String(editedFrom ?? srcHash), expandPlan.width, expandPlan.height)
         } : {}
       };
-      estimate = await engine.costEstimate(editReq);
+      estimate = await runEngine.costEstimate(editReq);
       const plan2 = expandPlan;
       const srcSize = { width: srcMeta.width ?? 0, height: srcMeta.height ?? 0 };
       const original2 = srcBuf;
-      work = plan2 && !canOutpaint ? async (signal) => {
-        const draws = await Promise.all([
-          engine.edit(editReq, signal),
-          engine.edit(editReq, signal).catch(() => null)
+      const reframeReq = plan2 && !canOutpaint2 && reframeSourceHash ? {
+        ...editReq,
+        instruction: reframeInstruction(plan2, srcSize, finalPrompt),
+        sourceImage: core.images.pathFor(reframeSourceHash)
+      } : null;
+      work = plan2 && !canOutpaint2 && reframeReq ? async (signal) => {
+        const [bedDraw, paddedDraw] = await Promise.allSettled([
+          runEngine.edit(editReq, signal),
+          runEngine.edit(reframeReq, signal)
         ]);
-        const scored = await Promise.all(
-          draws.map(async (got) => {
-            const first = got?.images[0];
-            if (!got || !first) return null;
-            const { image } = await compositeExpand(core.images.read(first), original2, plan2);
-            return { got, score: await seamScore(image, plan2, srcSize) };
-          })
-        );
-        const best = scored.filter((x) => x !== null).sort((a, b) => a.score - b.score)[0];
-        return best?.got ?? draws[0];
-      } : (signal) => engine.edit(editReq, signal);
+        const bed = bedDraw.status === "fulfilled" ? bedDraw.value : null;
+        const padded = paddedDraw.status === "fulfilled" ? paddedDraw.value : null;
+        if (!bed && !padded) {
+          throw bedDraw.status === "rejected" ? bedDraw.reason : paddedDraw.reason;
+        }
+        const preserved = [];
+        for (const [from, draw2] of [
+          ["bed", bed],
+          ["padded", padded]
+        ]) {
+          const hash = draw2?.images[0];
+          if (!hash) continue;
+          const { image } = await compositeExpand(core.images.read(hash), original2, plan2);
+          const [score, residual] = await Promise.all([
+            seamScore(image, plan2, srcSize),
+            seamResidual(image, plan2, srcSize)
+          ]);
+          preserved.push({ image, seam: seamPenalty(score, residual), from });
+        }
+        let reframed = null;
+        const paddedImage = padded?.images[0];
+        if (paddedImage) {
+          const frame = await reframeExpand(core.images.read(paddedImage), plan2);
+          if (frame) reframed = { image: frame };
+        }
+        const decision = chooseExpand({ preserved, reframed });
+        if (!decision) return bed ?? padded;
+        expandDecision = decision;
+        return {
+          images: [core.images.save(decision.image)],
+          costUsd: (bed?.costUsd ?? 0) + (padded?.costUsd ?? 0)
+        };
+      } : (signal) => runEngine.edit(editReq, signal);
     }
-    core.ledger.assertUnderCap(engine.capabilities().id, estimate + (reserved.get(engine.capabilities().id) ?? 0));
+    const billedId = runEngine.capabilities().id;
+    core.ledger.assertUnderCap(billedId, estimate + (reserved.get(billedId) ?? 0));
     const node = core.store.addNode({
       projectId: project.id,
       parentId: resolvedParentId,
       kind,
       prompt: finalPrompt,
-      engineId: String(engineId)
+      engineId: billedId
     });
     if (brief)
       core.store.setBrief(node.id, {
         ...brief,
         ...editedFrom ? { sourceImage: editedFrom } : {},
         ...kind === "edit" && reshape ? { reshape } : {},
+        // How the margin was actually made, and by whom. An extend may be
+        // handed to a different engine than the shot used, and a record that
+        // does not say so cannot be read back later.
+        ...expandMethod && expandPlan ? {
+          expand: {
+            method: expandMethod,
+            engineId: billedId,
+            // Where the protected picture sits in the frame it grew into.
+            // Placement is no longer always centred, so a reader that
+            // assumes it is would be looking in the wrong place.
+            left: expandPlan.left,
+            top: expandPlan.top
+          }
+        } : {},
         // What the refinement carried, recorded apart from what it asked for:
         // the detail view shows both, and remix reads tokens alone.
         ...kind === "edit" && inheritedTokens.length ? { inherited: inheritedTokens } : {}
@@ -8741,7 +9213,7 @@ function buildServer(opts) {
     const plan = expandPlan;
     const original = editedFrom ? core.images.read(editedFrom) : null;
     const localScope = kind === "edit" && !plan && editScope === "local" && original;
-    const post = plan ? async (images) => {
+    const post = plan ? expandMethod === "outpaint" ? async (images) => {
       const out = [];
       for (const h of images) {
         const answer = core.images.read(h);
@@ -8756,6 +9228,19 @@ function buildServer(opts) {
         out.push(core.images.save(image));
       }
       return out;
+    } : async (images) => {
+      if (expandDecision)
+        app.log.info(
+          {
+            nodeId: node.id,
+            choice: expandDecision.choice,
+            reason: expandDecision.reason,
+            seam: expandDecision.seam,
+            from: expandDecision.from
+          },
+          "expand: chose which frame to keep"
+        );
+      return images;
     } : localScope ? async (images) => {
       const out = [];
       for (const h of images) {
@@ -8765,7 +9250,7 @@ function buildServer(opts) {
       }
       return out;
     } : void 0;
-    void runNode(node.id, engine, estimate, work, expectShape, post).catch(
+    void runNode(node.id, runEngine, estimate, work, expectShape, post).catch(
       (err) => app.log.error({ err }, "node run failed")
     );
     const allWarnings = [...compiled2?.warnings ?? [], ...extraWarnings];
@@ -9026,8 +9511,8 @@ async function verify() {
     const db = new Database2(":memory:");
     db.pragma("user_version");
     db.close();
-    const { default: sharp16 } = await import('sharp');
-    await sharp16({ create: { width: 1, height: 1, channels: 3, background: "#000" } }).png().toBuffer();
+    const { default: sharp19 } = await import('sharp');
+    await sharp19({ create: { width: 1, height: 1, channels: 3, background: "#000" } }).png().toBuffer();
     console.log(JSON.stringify({ ok: true, version: readMeta().version }));
   } catch (err) {
     console.log(JSON.stringify({ ok: false, error: String(err?.message ?? err) }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scenri",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "author": "Tony Gorb <hello@scenri.co>",
   "license": "AGPL-3.0-only",
   "type": "module",