@poe-platform/safe-bash 0.1.844 → 0.1.845

package/dist/safe-bash/command-chunks/{chunk-3SWIXYXT.js → chunk-4KM2VJRB.js}

@@ -13,7 +13,7 @@ import {
   scanMp4Frames,
   scanMp4Packets,
   wavPacketFrames
-} from "./chunk-LORSYIAF.js";
+} from "./chunk-CMGVQM4Y.js";
 
 // packages/safe-bash-command-ffprobe/src/read-intervals.ts
 import { PagedStorage } from "@poe-platform/safe-fs/storage";

package/dist/safe-bash/command-chunks/{chunk-LORSYIAF.js → chunk-CMGVQM4Y.js}

@@ -399724,19 +399724,29 @@ function serializeWav(doc, options = {}) {
   } else {
     throw new Error("WAV encoding requires decoded PCM audio");
   }
+  const channelMask = audioTrack?.decodedAudio?.channelMask ?? (decodedAudio ? decodedAudio.channelMask : void 0) ?? [11, 263, 55, 63, 1807, 1599][channels - 3];
+  const extensible = channelMask !== void 0 || channels > 2;
+  const fmtSize = extensible ? 40 : 16;
   const padding = pcmBytes.byteLength % 2;
-  const writer = new BinaryWriter(44 + pcmBytes.byteLength + padding);
+  const writer = new BinaryWriter(28 + fmtSize + pcmBytes.byteLength + padding);
   writer.writeFourCC("RIFF");
-  writer.writeU32LE(36 + pcmBytes.byteLength + padding);
+  writer.writeU32LE(20 + fmtSize + pcmBytes.byteLength + padding);
   writer.writeFourCC("WAVE");
   writer.writeFourCC("fmt ");
-  writer.writeU32LE(16);
-  writer.writeU16LE(formatTag);
+  writer.writeU32LE(fmtSize);
+  writer.writeU16LE(extensible ? 65534 : formatTag);
   writer.writeU16LE(channels);
   writer.writeU32LE(sampleRate);
   writer.writeU32LE(sampleRate * channels * (bitsPerSample >>> 3));
   writer.writeU16LE(channels * (bitsPerSample >>> 3));
   writer.writeU16LE(bitsPerSample);
+  if (extensible) {
+    writer.writeU16LE(22);
+    writer.writeU16LE(bitsPerSample);
+    writer.writeU32LE(channelMask ?? 0);
+    writer.writeU32LE(formatTag);
+    writer.writeBytes(Uint8Array.of(0, 0, 16, 0, 128, 0, 0, 170, 0, 56, 155, 113));
+  }
   writer.writeFourCC("data");
   writer.writeU32LE(pcmBytes.byteLength);
   writer.writeBytes(pcmBytes);

package/dist/safe-bash-command-ffmpeg/index.js

@@ -23,7 +23,7 @@ import {
   sliceMp4,
   srtAst,
   webvttAst
-} from "../safe-bash/command-chunks/chunk-LORSYIAF.js";
+} from "../safe-bash/command-chunks/chunk-CMGVQM4Y.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-ffmpeg/src/index.ts
@@ -78,6 +78,73 @@ async function resampleAudio(channels, outputLength, rateRatio, budget, signal)
 
 // packages/safe-bash-command-ffmpeg/src/audio-tempo.ts
 import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
+async function filterUnityTempo(channels, sampleRate, pcm16, budget, signal) {
+  const length = channels[0]?.length ?? 0;
+  const window = 2 ** Math.ceil(Math.log2(Math.max(2, Math.floor(sampleRate / 24))));
+  const hop = window / 2;
+  if (length < hop) return channels.map(() => new Float32Array(0));
+  const hann = Float32Array.from({ length: window }, (_, i) => (1 - Math.cos(2 * Math.PI * i / (window - 1))) / 2);
+  const mono = new Float32Array(length);
+  for (let i = 0; i < length; i++) {
+    if (i % 16384 === 0) {
+      await yieldTurn2(signal);
+      signal?.throwIfAborted();
+      budget.checkCpu();
+    }
+    for (const channel of channels) {
+      if (Math.abs(channel[i]) > Math.abs(mono[i])) mono[i] = channel[i];
+    }
+  }
+  const output = channels.map(() => []);
+  let previous = -hop;
+  let position = -hop;
+  let work = 0;
+  while (true) {
+    let current = previous + hop;
+    position += hop;
+    const drift = position - hop - previous;
+    const start = Math.min(window, Math.max(0, -drift));
+    const end = Math.max(0, Math.min(window - drift, window - window / 16));
+    let correction = -drift;
+    let best = -Infinity;
+    for (let lag = start; lag < end; lag++) {
+      let correlation = 0;
+      for (let j = Math.max(0, -current); j < Math.min(window - lag, length - current, length - previous - lag); j++) {
+        correlation += (mono[previous + j + lag] ?? 0) * mono[current + j];
+        if (++work % 16384 === 0) {
+          await yieldTurn2(signal);
+          signal?.throwIfAborted();
+          budget.checkCpu();
+        }
+      }
+      const metric = correlation * (drift + lag) * (lag - start) * (end - lag);
+      if (metric > best) {
+        best = metric;
+        correction = lag - hop;
+      }
+    }
+    current -= correction;
+    const count = Math.max(0, Math.min(window, length - current));
+    const overlap = Math.min(hop, count, length - previous - hop);
+    for (let c = 0; c < channels.length; c++) {
+      const channel = channels[c];
+      const dst = output[c];
+      for (let i = 0; i < overlap; i++) {
+        const a = channel[previous + hop + i] ?? 0;
+        const b = channel[current + i] ?? 0;
+        const sample = current + i < 0 ? a : Math.fround(a * hann[hop + i] + Math.fround(b * hann[i]));
+        dst.push(pcm16 ? Math.trunc(sample * 32768) / 32768 : sample);
+      }
+      if (current + count >= length) {
+        for (let i = overlap; i < count; i++) dst.push(channel[current + i] ?? 0);
+      }
+    }
+    budget.checkDuration((output[0]?.length ?? 0) / sampleRate);
+    if (current + count >= length) break;
+    previous = current;
+  }
+  return output.map((channel) => Float32Array.from(channel));
+}
 async function stretchAudio(channels, sampleRate, tempo, budget, signal) {
   const length = channels[0]?.length ?? 0;
   if (tempo === 1 || length === 0) return channels;
@@ -1411,8 +1478,10 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
         if (!Number.isSafeInteger(val) || val < 0) return void 0;
         if (args.slice(i + 1).includes("-i")) pendingStartNumber = val;
         else outputStartNumber = val;
-      } else if (arg === "-ar") audioRate = parseInt(args[++i] ?? "0", 10) || void 0;
-      else if (arg === "-ac") audioChannels = parseInt(args[++i] ?? "0", 10) || void 0;
+      } else if (arg === "-ar") {
+        audioRate = parseInt(args[++i] ?? "0", 10) || void 0;
+        if (audioRate !== void 0 && audioRate < 0) return void 0;
+      } else if (arg === "-ac") audioChannels = parseInt(args[++i] ?? "0", 10) || void 0;
       else if (arg === "-hide_banner" || arg === "-nostdin" || arg === "-stats") continue;
       else if (arg === "-f") {
         const val = args[++i];
@@ -1483,7 +1552,7 @@ function evalSyncFfmpeg(inBytesOrArgs, maybeArgs, readFileSync, writeFileSync) {
       } else if (arg === "-vf" || arg === "-filter:v") {
         const f = args[++i];
         if (f) vfFilters.push(f);
-      } else if (arg === "-af" || arg === "-filter:a") {
+      } else if (arg === "-af" || arg === "-filter:a" || arg.startsWith("-af:") || arg.startsWith("-filter:a:")) {
         return void 0;
       } else if (arg === "-disposition" || arg.startsWith("-disposition:")) {
         streamDispositions.push([arg.slice("-disposition:".length), args[++i] ?? ""]);
@@ -1778,6 +1847,10 @@ function createFfmpegCommand(options = {}) {
             else outputStartNumber = val;
           } else if (arg === "-ar") {
             audioRate = parseInt(args[++i] ?? "0", 10) || void 0;
+            if (audioRate !== void 0 && audioRate < 0) {
+              await writeBytes(context.stderr, encodeUtf8("ffmpeg: sample rate must be nonnegative\n"), context.signal);
+              return { exitCode: 1 };
+            }
           } else if (arg === "-ac") {
             audioChannels = parseInt(args[++i] ?? "0", 10) || void 0;
           } else if (arg === "-hide_banner" || arg === "-nostdin" || arg === "-stats") {
@@ -1890,9 +1963,14 @@ function createFfmpegCommand(options = {}) {
           } else if (arg === "-vf" || arg === "-filter:v") {
             const f = args[++i];
             if (f) vfFilters.push(f);
-          } else if (arg === "-af" || arg === "-filter:a") {
+          } else if (arg === "-af" || arg === "-filter:a" || arg.startsWith("-af:") || arg.startsWith("-filter:a:")) {
             const f = args[++i];
-            if (f) afFilters.push(f);
+            const selector = arg.startsWith("-af:") ? arg.slice(4) : arg.startsWith("-filter:a:") ? arg.slice(10) : void 0;
+            const ordinal = selector === void 0 ? void 0 : Number(selector);
+            if (selector !== void 0 && (!selector || !Array.from(selector).every((char) => char >= "0" && char <= "9") || !Number.isSafeInteger(ordinal))) {
+              throw new Error(`Unsupported audio stream specifier: ${selector}`);
+            }
+            if (f) afFilters.push({ ordinal, expression: f });
           } else if (arg === "-filter_complex" || arg === "-lavfi") {
             filterComplex = args[++i];
           } else if (arg === "-disposition" || arg.startsWith("-disposition:")) {
@@ -2430,7 +2508,8 @@ To ignore this, add a trailing '?' to the map.
               }, context.signal);
             }
             validateAudioEncoder(audioCodec, workingDoc, astPlugins);
-            if (audioCodec === "copy" && afFilters.length > 0 && workingDoc.tracks.some((track) => track.type === "audio")) {
+            const audioTrackCount = workingDoc.tracks.filter((track) => track.type === "audio").length;
+            if (audioCodec === "copy" && audioTrackCount > 0 && afFilters.some((filter) => filter.ordinal === void 0 || filter.ordinal < audioTrackCount)) {
               await writeBytes(context.stderr, encodeUtf8("ffmpeg: Filtering and streamcopy cannot be used together for audio.\n"), context.signal);
               return { exitCode: 218 };
             }
@@ -2538,11 +2617,15 @@ To ignore this, add a trailing '?' to the map.
               workingDoc = limitAudioCopyPackets(workingDoc, maxAudioFrames);
             }
             if ((audioRate !== void 0 || audioChannels !== void 0 || afFilters.length > 0) && audioCodec !== "copy") {
+              let audioOrdinal = 0;
               workingDoc = {
                 ...workingDoc,
                 tracks: await mapWork(workingDoc.tracks, async (t) => {
                   let work = 0;
                   if (t.type !== "audio") return t;
+                  const ordinal = audioOrdinal++;
+                  const filter = afFilters.filter((filter2) => filter2.ordinal === void 0 || filter2.ordinal === ordinal).at(-1);
+                  if (audioRate === void 0 && audioChannels === void 0 && !filter) return t;
                   const audio = t.decodedAudio ?? (t.codecDescriptions[0]?.codecName === "aac" ? decodeAacTrack(workingDoc, t) : void 0);
                   if (!audio) throw new Error("Audio filtering requires decoded PCM audio");
                   const origRate = audio.sampleRate;
@@ -2552,19 +2635,15 @@ To ignore this, add a trailing '?' to the map.
                   const channelMask = audio.channelMask;
                   const surroundMono = origCh === 6 && targetCh === 1;
                   const monoStereo = origCh === 1 && (targetCh === 2 || targetCh === 3);
+                  const pcm16MonoStereo = monoStereo && !filter && targetRate === origRate && t.codecDescriptions[0]?.codecName === "pcm_s16le" && (audioCodec === "pcm_s16le" || audioCodec === void 0 && (outputFormat ?? outputTarget2.split(".").pop()?.toLowerCase()) === "wav");
+                  const monoSurround = origCh === 1 && targetCh >= 4 && targetCh <= 8;
                   if (targetCh !== origCh && origCh > 2 && (!surroundMono || channelMask && channelMask !== 63 && channelMask !== 1551)) {
                     throw new Error(`Unsupported audio channel layout conversion: ${origCh} channels (mask ${channelMask ?? 0}) to ${targetCh}`);
                   }
-                  const durSec = (audio.channelData[0]?.length ?? 0) / origRate;
-                  let volFactor = t.volume ?? 1;
-                  let tempoFactor = 1;
-                  let reverseAudio = false;
-                  for (const af of afFilters) {
-                    if (++work % 1024 === 0) {
-                      await yieldTurn5(context.signal);
-                      context.signal?.throwIfAborted();
-                    }
-                    for (const item of af.split(",")) {
+                  const volFactor = t.volume ?? 1;
+                  let stretched = audio.channelData;
+                  if (filter) {
+                    for (const item of filter.expression.split(",")) {
                       if (++work % 1024 === 0) {
                         await yieldTurn5(context.signal);
                         context.signal?.throwIfAborted();
@@ -2576,22 +2655,31 @@ To ignore this, add a trailing '?' to the map.
                         const gain = parseFilterExpression(decibels ? volSpec.slice(0, -2) : volSpec, "volume", {});
                         const factor = decibels ? Math.pow(10, gain / 20) : gain;
                         if (!Number.isFinite(factor)) throw new Error("volume: invalid gain");
-                        volFactor *= factor;
+                        stretched = await mapWork(stretched, async (channel) => {
+                          const output = new Float32Array(channel.length);
+                          for (let i2 = 0; i2 < channel.length; i2++) {
+                            if (++work % 1024 === 0) {
+                              await yieldTurn5(context.signal);
+                              context.signal?.throwIfAborted();
+                            }
+                            output[i2] = channel[i2] * factor;
+                          }
+                          return output;
+                        }, context.signal);
                       } else if (trimmed.startsWith("atempo=")) {
                         const tempo = Number(trimmed.slice(7));
                         if (!Number.isFinite(tempo) || tempo < 0.5 || tempo > 100) {
                           throw new Error("atempo must be in the range [0.5, 100]");
                         }
-                        tempoFactor *= tempo;
+                        stretched = tempo === 1 ? await filterUnityTempo(stretched, origRate, t.codecDescriptions[0]?.codecName === "pcm_s16le", budget, context.signal) : await stretchAudio(stretched, origRate, tempo, budget, context.signal);
                       } else if (trimmed === "areverse") {
-                        reverseAudio = !reverseAudio;
+                        stretched = await mapWork(stretched, async (channel) => channel.slice().reverse(), context.signal);
                       } else {
                         throw new Error(`Unsupported audio filter: ${trimmed}`);
                       }
                     }
                   }
-                  const targetSamples = Math.max(0, Math.round(durSec / tempoFactor * targetRate));
-                  let stretched = await stretchAudio(audio.channelData, origRate, tempoFactor, budget, context.signal);
+                  const targetSamples = Math.max(0, Math.round((stretched[0]?.length ?? 0) * targetRate / origRate));
                   if (targetRate !== origRate) stretched = await resampleAudio(stretched, targetSamples, origRate / targetRate, budget, context.signal);
                   const newChannelData = [];
                   for (let c = 0; c < targetCh; c++) {
@@ -2600,7 +2688,7 @@ To ignore this, add a trailing '?' to the map.
                       context.signal?.throwIfAborted();
                     }
                     const dst = new Float32Array(targetSamples);
-                    const srcCh = monoStereo && c >= 2 ? void 0 : stretched[origCh === 1 ? 0 : c];
+                    const srcCh = monoStereo && c >= 2 || monoSurround && c !== 2 ? void 0 : stretched[origCh === 1 ? 0 : c];
                     const rightCh = origCh === 2 && targetCh === 1 ? stretched[1] : void 0;
                     if (srcCh && srcCh.length > 0) {
                       for (let i2 = 0; i2 < targetSamples; i2++) {
@@ -2610,10 +2698,10 @@ To ignore this, add a trailing '?' to the map.
                         }
                         const srcIdx = Math.min(srcCh.length - 1, i2);
                         const sample = surroundMono ? ((stretched[0][srcIdx] + stretched[1][srcIdx]) * Math.SQRT1_2 + stretched[2][srcIdx] + (stretched[4][srcIdx] + stretched[5][srcIdx]) / 2) / (2 + Math.SQRT2) : rightCh ? (srcCh[srcIdx] + rightCh[srcIdx]) / 2 : srcCh[srcIdx];
-                        dst[i2] = Math.max(-1, Math.min(1, sample * volFactor * (monoStereo ? Math.SQRT1_2 : 1)));
+                        const mixed = pcm16MonoStereo ? Math.floor((sample * 32768 * 23170 + 16384) / 32768) / 32768 : sample * (monoStereo ? Math.SQRT1_2 : 1);
+                        dst[i2] = Math.max(-1, Math.min(1, mixed * volFactor));
                       }
                     }
-                    if (reverseAudio) dst.reverse();
                     newChannelData.push(dst);
                   }
                   const nextDescs = t.codecDescriptions.map((d) => ({

package/dist/safe-bash-command-ffprobe/index.js

@@ -1,8 +1,8 @@
 import {
   createFfprobeCommand
-} from "../safe-bash/command-chunks/chunk-3SWIXYXT.js";
+} from "../safe-bash/command-chunks/chunk-4KM2VJRB.js";
 import "../safe-bash/command-chunks/chunk-MGBHGZEX.js";
-import "../safe-bash/command-chunks/chunk-LORSYIAF.js";
+import "../safe-bash/command-chunks/chunk-CMGVQM4Y.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-ffprobe/src/index.ts

package/dist/safe-bash-command-ffprobe/media.js

@@ -11,9 +11,9 @@ import {
   loadManifestResources,
   resolvePath,
   rethrowRuntimeError
-} from "../safe-bash/command-chunks/chunk-3SWIXYXT.js";
+} from "../safe-bash/command-chunks/chunk-4KM2VJRB.js";
 import "../safe-bash/command-chunks/chunk-MGBHGZEX.js";
-import "../safe-bash/command-chunks/chunk-LORSYIAF.js";
+import "../safe-bash/command-chunks/chunk-CMGVQM4Y.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   createFfprobeCommand,

package/dist/safe-bash-command-imagemagick/index.d.ts

@@ -36,6 +36,7 @@ export interface MagickGeometry {
     readonly percentY?: number;
     readonly areaLimit?: number;
     readonly isSubdivide?: boolean;
+    readonly aspectRatio?: number;
 }
 export declare function parseMagickGeometry(raw: string): MagickGeometry;
 export declare function runIdentifyCli(argv: readonly string[], files: Map<string, Uint8Array> | IdentifyFileInput, stdinBytes?: Uint8Array, signal?: AbortSignal): Promise<ImageMagickCliResult>;

package/dist/safe-bash-command-imagemagick/index.js

@@ -3947,6 +3947,13 @@ function parseMagickGeometry(raw) {
       break;
     }
   }
+  if (s.includes(":")) {
+    const parts = s.split(":");
+    const ratio = Number(parts[0]) / Number(parts[1]);
+    if (parts.length === 2 && Number(parts[0]) > 0 && Number(parts[1]) > 0 && Number.isFinite(ratio)) {
+      return { aspectRatio: ratio, x, y, hasOffset, forceExact, shrinkOnly, enlargeOnly, fillArea, isPercent: false };
+    }
+  }
   if (isArea) {
     if (s.includes("x") || s.includes("X")) {
       const [wStr, hStr] = s.split(/[xX]/);
@@ -4803,14 +4810,16 @@ function* createCheckerboardImageSteps(width, height) {
 function* applyMagickSpliceSteps(img, geomStr, bg, gravity = "northwest", signal) {
   let cooperativeWork = 0;
   const g = parseMagickGeometry(geomStr);
-  const sw = Math.max(0, Math.round(g.width ?? 0));
-  const sh = Math.max(0, Math.round(g.height ?? 0));
+  const sw = Math.max(0, Math.round((g.width ?? 0) * (g.isPercent ? img.width / 100 : 1)));
+  const sh = Math.max(0, Math.round((g.height ?? 0) * (g.isPercent ? img.height / 100 : 1)));
   const box = gravityAdjustBox(img.width, img.height, sw, sh, g.x, g.y, gravity);
   const anchor = resolveGravityOffset(sw, sh, gravity);
-  const sx = Math.max(0, Math.min(img.width, box.x + anchor.left));
-  const sy = Math.max(0, Math.min(img.height, box.y + anchor.top));
   const outW = img.width + sw;
   const outH = img.height + sh;
+  const xOffset = box.x + anchor.left;
+  const sx = xOffset < 0 || xOffset > img.width ? outW : xOffset;
+  if (box.y + anchor.top > outH) throw new Error("pixels are not authentic");
+  const sy = Math.max(0, Math.min(img.height, box.y + anchor.top));
   const out = new Uint8Array(new ArrayBuffer(outW * outH * 4 + outH), 0, outW * outH * 4);
   for (let y = 0; y < outH; y++) {
     if (++cooperativeWork % 65536 === 0)
@@ -4825,7 +4834,7 @@ function* applyMagickSpliceSteps(img, geomStr, bg, gravity = "northwest", signal
         out[dstIdx + 2] = bg.b;
         out[dstIdx + 3] = bg.a;
       } else {
-        const origX = x < sx ? x : x - sw;
+        const origX = Math.min(img.width - 1, x < sx ? x : x - sw);
         const origY = y < sy ? y : y - sh;
         const srcIdx = (origY * img.width + origX) * 4;
         out[dstIdx] = img.data[srcIdx];
@@ -6898,13 +6907,12 @@ function magickCropArea(img, geomStr, gravity) {
 }
 function magickExtentLayout(img, geomStr, state) {
   const g = parseMagickGeometry(geomStr);
-  const targetW = Math.max(1, Math.round(g.width ?? img.width));
-  const targetH = Math.max(1, Math.round(g.height ?? img.height));
-  const offset = resolveGravityOffset(targetW - img.width, targetH - img.height, state.gravity);
-  const isEast = state.gravity === "east" || state.gravity === "northeast" || state.gravity === "southeast";
-  const isSouth = state.gravity === "south" || state.gravity === "southwest" || state.gravity === "southeast";
-  const left = Math.round(offset.left - (isEast ? -g.x : g.x));
-  const top = Math.round(offset.top - (isSouth ? -g.y : g.y));
+  const targetW = Math.max(1, Math.round(g.aspectRatio !== void 0 ? Math.min(img.width, img.height * g.aspectRatio) : g.isPercent ? img.width * (g.percentX ?? 100) / 100 : g.width ?? img.width));
+  const targetH = Math.max(1, Math.round(g.aspectRatio !== void 0 ? Math.min(img.height, img.width / g.aspectRatio) : g.isPercent ? img.height * (g.percentY ?? 100) / 100 : g.height ?? img.height));
+  if (g.enlargeOnly && img.width > targetW && img.height > targetH || g.shrinkOnly && img.width < targetW && img.height < targetH) return void 0;
+  const offset = gravityAdjustBox(img.width, img.height, targetW, targetH, g.x, g.y, state.gravity);
+  const left = -offset.x;
+  const top = -offset.y;
   const dstX0 = Math.max(0, left);
   const dstY0 = Math.max(0, top);
   const dstX1 = Math.min(targetW, left + img.width);
@@ -6914,6 +6922,7 @@ function magickExtentLayout(img, geomStr, state) {
 function* applyMagickExtentSteps(img, geomStr, state, signal) {
   yield;
   const layout = magickExtentLayout(img, geomStr, state);
+  if (!layout) return img;
   const virtualCanvas = magickResizeCanvas(img, layout.width, layout.height);
   const source = img[magickInput];
   const canvas = {
@@ -8950,18 +8959,22 @@ function* evaluatePipelineTokensSteps(tokens, files, state, parentStack, stdinBy
         return { ...canvas, virtualCanvas: magickBorderCanvas(im, bw, bh) };
       });
     } else if (t === "-shave") {
-      const g = parseMagickGeometry(tokens[++i] ?? "0x0");
+      const geometry = tokens[++i] ?? "0x0";
+      const g = parseMagickGeometry(geometry);
       const sw = Math.max(0, Math.round(g.width ?? 0));
       const sh = Math.max(0, Math.round(g.height ?? sw));
       stack = yield* mapSteps(stack, function* (im) {
-        const clampedSw = Math.min(Math.floor((im.width - 1) / 2), sw);
-        const clampedSh = Math.min(Math.floor((im.height - 1) / 2), sh);
+        if (sw * 2 >= im.width || sh * 2 >= im.height) {
+          analysis.warnings += `magick: geometry does not contain image '${geometry}'
+`;
+          return im;
+        }
         return { ...yield* extractImageSteps2(im, {
-          left: clampedSw,
-          top: clampedSh,
-          width: Math.max(1, im.width - clampedSw * 2),
-          height: Math.max(1, im.height - clampedSh * 2)
-        }), virtualCanvas: magickBorderCanvas(im, -clampedSw, -clampedSh) };
+          left: sw,
+          top: sh,
+          width: im.width - sw * 2,
+          height: im.height - sh * 2
+        }), virtualCanvas: magickBorderCanvas(im, -sw, -sh) };
       });
     } else if (t === "-trim") {
       stack = yield* mapSteps(stack, function* (im) {
@@ -9525,14 +9538,17 @@ async function transformStoredMagickCoordinates(image, backend, token, geometry,
     xs = [{ source: w - dx, target: 0, length: dx }, { source: 0, target: dx, length: w - dx }];
     ys = [{ source: h - dy, target: 0, length: dy }, { source: 0, target: dy, length: h - dy }];
   } else if (token === "-splice") {
-    const sw = Math.max(0, Math.round(g.width ?? 0)), sh = Math.max(0, Math.round(g.height ?? 0));
+    const sw = Math.max(0, Math.round((g.width ?? 0) * (g.isPercent ? w / 100 : 1)));
+    const sh = Math.max(0, Math.round((g.height ?? 0) * (g.isPercent ? h / 100 : 1)));
     const box = gravityAdjustBox(w, h, sw, sh, g.x, g.y, state.gravity);
     const anchor = resolveGravityOffset(sw, sh, state.gravity);
-    const x = Math.max(0, Math.min(w, box.x + anchor.left));
-    const y = Math.max(0, Math.min(h, box.y + anchor.top));
     width += sw;
     height += sh;
-    xs = [{ source: 0, target: 0, length: x }, { source: x, target: x + sw, length: w - x }];
+    const xOffset = box.x + anchor.left;
+    const x = xOffset < 0 || xOffset > w ? width : xOffset;
+    if (box.y + anchor.top > height) throw new Error("pixels are not authentic");
+    const y = Math.max(0, Math.min(h, box.y + anchor.top));
+    xs = [{ source: 0, target: 0, length: x }, { source: x, target: x + sw, length: Math.max(0, w - x) }];
     ys = [{ source: 0, target: 0, length: y }, { source: y, target: y + sh, length: h - y }];
   } else {
     const cw = Math.max(0, Math.round((g.width ?? 0) * (g.isPercent ? w / 100 : 1)));
@@ -9553,7 +9569,16 @@ async function transformStoredMagickCoordinates(image, backend, token, geometry,
     for (let offset = 0; offset < x.length; offset += 4096) {
       if (work++ % 64 === 0) await yieldTurn11(signal);
       const length = Math.min(4096, x.length - offset) * 4;
-      const bytes = await backend.storage.read(image.position + ((y.source + row) * w + x.source + offset) * 4, length);
+      const sourceX = Math.min(w - 1, x.source + offset);
+      const sourceLength = Math.min(length, (w - sourceX) * 4);
+      let bytes = await backend.storage.read(image.position + ((y.source + row) * w + sourceX) * 4, sourceLength);
+      if (sourceLength < length) {
+        const extended = new Uint8Array(length);
+        extended.set(bytes);
+        const edge = bytes.subarray(sourceLength - 4);
+        for (let i = sourceLength; i < length; i += 4) extended.set(edge, i);
+        bytes = extended;
+      }
       await backend.storage.write(position + ((y.target + row) * width + x.target + offset) * 4, bytes);
     }
   }
@@ -10290,13 +10315,18 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
           return frames;
         });
       } else if (!operandsOnly && token === "-shave") {
-        const geometry = parseMagickGeometry(tokens[++i] ?? "0x0"), width = Math.max(0, Math.round(geometry.width ?? 0)), height = Math.max(0, Math.round(geometry.height ?? width));
+        const geometry = tokens[++i] ?? "0x0", parsed = parseMagickGeometry(geometry);
+        const width = Math.max(0, Math.round(parsed.width ?? 0)), height = Math.max(0, Math.round(parsed.height ?? width));
         steps.push(async (image, backend) => {
           if (!image) return;
-          const left = Math.min(Math.floor((image.width - 1) / 2), width), top = Math.min(Math.floor((image.height - 1) / 2), height);
+          if (width * 2 >= image.width || height * 2 >= image.height) {
+            analysis.warnings += `magick: geometry does not contain image '${geometry}'
+`;
+            return image;
+          }
           return {
-            ...await transformStoredImage2(image, backend.storage, { kind: "extract", left, top, width: Math.max(1, image.width - left * 2), height: Math.max(1, image.height - top * 2) }, signal),
-            virtualCanvas: magickBorderCanvas(image, -left, -top)
+            ...await transformStoredImage2(image, backend.storage, { kind: "extract", left: width, top: height, width: image.width - width * 2, height: image.height - height * 2 }, signal),
+            virtualCanvas: magickBorderCanvas(image, -width, -height)
           };
         });
       } else if (!operandsOnly && token === "-trim") {
@@ -10310,6 +10340,7 @@ async function tryConvertFilesResult(argv, input, stdinBytes, signal, analysis)
         steps.push(async (image, backend) => {
           if (!image) return;
           const layout = magickExtentLayout(image, geometry, captured);
+          if (!layout) return image;
           const virtualCanvas = magickResizeCanvas(image, layout.width, layout.height);
           const source = image[magickInput];
           const canvas = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.844",
+  "version": "0.1.845",
   "description": "Extensible virtual shell with pluggable filesystems and streaming commands",
   "type": "module",
   "license": "MIT",
@@ -1415,7 +1415,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.844",
+    "@poe-platform/safe-fs": "0.1.845",
     "pdf-lib": "1.17.1",
     "@types/node": "^25.2.2",
     "@formatjs/intl-numberformat": "9.4.0",