scenri 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [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,
@@ -6141,8 +6141,9 @@ 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.
@@ -6173,6 +6174,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 +6410,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 +6441,14 @@ 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 seamScore(image, plan, source) {
   const { data, info } = await sharp7(image).removeAlpha().greyscale().raw().toBuffer({ resolveWithObject: true });
   const W = info.width;
@@ -6318,6 +6479,89 @@ 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))) };
+}
+
+// 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 +7674,16 @@ function registerImageRoutes(app, deps) {
 
 // src/release/notes.data.ts
 var RELEASES = [
+  {
+    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 +8874,8 @@ function buildServer(opts) {
     let work;
     let expectShape;
     let editedFrom = null;
+    let runEngine = engine;
+    let expandMethod = null;
     if (compiled2) {
       finalPrompt = compiled2.prompt;
       referenceImages = compiled2.referenceImages;
@@ -8666,9 +8922,18 @@ 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) {
+        const route = await resolveOutpaintRoute(engines.all(), engine);
+        runEngine = route.engine;
+        expandMethod = route.method;
+      }
+      const canOutpaint2 = expandMethod === "outpaint";
       if (expandPlan) {
-        if (!canOutpaint) {
+        if (!canOutpaint2) {
           const canvas = await expandCanvas(srcBuf, expandPlan);
           expandSourceHash = core.images.save(canvas);
         }
@@ -8685,7 +8950,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 +8965,59 @@ 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) => {
+      work = plan2 && !canOutpaint2 ? async (signal) => {
         const draws = await Promise.all([
-          engine.edit(editReq, signal),
-          engine.edit(editReq, signal).catch(() => null)
+          runEngine.edit(editReq, signal),
+          runEngine.edit(editReq, signal).catch(() => null)
         ]);
         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 [score, residual] = await Promise.all([
+              seamScore(image, plan2, srcSize),
+              seamResidual(image, plan2, srcSize)
+            ]);
+            return { got, penalty: seamPenalty(score, residual) };
           })
         );
-        const best = scored.filter((x) => x !== null).sort((a, b) => a.score - b.score)[0];
+        const best = scored.filter((x) => x !== null).sort((a, b) => a.penalty - b.penalty)[0];
         return best?.got ?? draws[0];
-      } : (signal) => engine.edit(editReq, signal);
+      } : (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 } : {}
@@ -8765,7 +9049,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 +9310,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: sharp18 } = await import('sharp');
+    await sharp18({ 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.5.1",
   "author": "Tony Gorb <hello@scenri.co>",
   "license": "AGPL-3.0-only",
   "type": "module",