@poe-platform/safe-bash 0.1.763 → 0.1.764

package/dist/safe-bash/command-chunks/{chunk-S3G2B4OX.js → chunk-G3IIEU2N.js}

@@ -34122,6 +34122,187 @@ function downscaleImage(image, widthScale, heightScale) {
   return image;
 }
 
+// packages/pdf-ast/src/render/stroke.ts
+init_buffer();
+var MAX_STROKE_VERTICES = 1e6;
+function dashSubpath(path, pattern, phase) {
+  const cycle = pattern.reduce((sum, value) => sum + value, 0);
+  if (!(cycle > 0)) return [path];
+  let offset = (phase % cycle + cycle) % cycle, index = 0;
+  while (offset > 0) {
+    if (offset < pattern[index]) break;
+    offset -= pattern[index];
+    index = (index + 1) % pattern.length;
+  }
+  let remaining = pattern[index] - offset;
+  const points = path.closed ? [...path.points, path.points[0]] : path.points;
+  const result = [];
+  let current = [];
+  let steps = 0;
+  const flush = () => {
+    if (current.length) result.push({ points: current, closed: false });
+    current = [];
+  };
+  const advance = (point) => {
+    while (remaining <= 0) {
+      if (++steps > MAX_STROKE_VERTICES) throw new PdfError("E_LIMIT", "Stroke dash expansion exceeds the vertex limit");
+      if (index % 2 === 0) {
+        if (pattern[index] === 0) result.push({ points: [point, point], closed: false });
+        flush();
+      }
+      index = (index + 1) % pattern.length;
+      remaining = pattern[index];
+    }
+  };
+  for (let i = 1; i < points.length; i++) {
+    const start = points[i - 1], end = points[i];
+    const dx = end[0] - start[0], dy = end[1] - start[1];
+    const length = Math.hypot(dx, dy);
+    if (!Number.isFinite(length) || length / cycle * pattern.length > MAX_STROKE_VERTICES) {
+      throw new PdfError("E_LIMIT", "Stroke dash expansion exceeds the vertex limit");
+    }
+    let distance = 0;
+    while (distance < length) {
+      const point = [start[0] + dx * distance / length, start[1] + dy * distance / length];
+      advance(point);
+      const step = Math.min(remaining, length - distance);
+      if (distance + step === distance || ++steps > MAX_STROKE_VERTICES) throw new PdfError("E_LIMIT", "Stroke dash expansion exceeds the vertex limit");
+      distance += step;
+      remaining -= step;
+      if (index % 2 === 0) {
+        if (!current.length) current.push(point);
+        current.push([start[0] + dx * distance / length, start[1] + dy * distance / length]);
+      }
+    }
+  }
+  flush();
+  if (path.closed && result.length) {
+    const first = result[0], last = result[result.length - 1];
+    const start = path.points[0];
+    const firstPoint = first.points[0], lastPoint = last.points[last.points.length - 1];
+    if (firstPoint[0] === start[0] && firstPoint[1] === start[1] && lastPoint[0] === start[0] && lastPoint[1] === start[1]) {
+      if (first === last) result[0] = { points: first.points, closed: true };
+      else {
+        result[0] = { points: [...last.points, ...first.points.slice(1)], closed: false };
+        result.pop();
+      }
+    }
+  }
+  return result;
+}
+function strokeOutlines(paths, width, cap, join, miterLimit, dashArray = [], dashPhase = 0) {
+  const half = width / 2;
+  const contours = [];
+  const pattern = dashArray.length % 2 ? [...dashArray, ...dashArray] : dashArray;
+  let count = 0;
+  let contour = [];
+  const add = (x, y) => {
+    if (++count > MAX_STROKE_VERTICES) throw new PdfError("E_LIMIT", "Stroke outline exceeds the vertex limit");
+    contour.push([x, y]);
+  };
+  const arc = (point, dx1, dy1, dx2, dy2) => {
+    let a1 = Math.atan2(dy1, dx1), a2 = Math.atan2(dy2, dx2);
+    const ccw = a1 - a2 > 0 && a1 - a2 < Math.PI;
+    const step = Math.acos(half / (half + 0.125)) * 2;
+    add(point[0] + dx1, point[1] + dy1);
+    if (step > 0) {
+      if (!ccw) {
+        if (a1 > a2) a2 += 2 * Math.PI;
+        a2 -= step / 4;
+        if ((a2 - a1) / step > MAX_STROKE_VERTICES - count) throw new PdfError("E_LIMIT", "Stroke arc exceeds the vertex limit");
+        for (a1 += step; a1 < a2; a1 += step) add(point[0] + half * Math.cos(a1), point[1] + half * Math.sin(a1));
+      } else {
+        if (a1 < a2) a2 -= 2 * Math.PI;
+        a2 += step / 4;
+        if ((a1 - a2) / step > MAX_STROKE_VERTICES - count) throw new PdfError("E_LIMIT", "Stroke arc exceeds the vertex limit");
+        for (a1 -= step; a1 > a2; a1 -= step) add(point[0] + half * Math.cos(a1), point[1] + half * Math.sin(a1));
+      }
+    }
+    add(point[0] + dx2, point[1] + dy2);
+  };
+  const addCap = (point, next) => {
+    const length = Math.hypot(next[0] - point[0], next[1] - point[1]);
+    const dx = half * (next[1] - point[1]) / length;
+    const dy = half * (next[0] - point[0]) / length;
+    if (cap !== 1) {
+      const sx = cap === 2 ? dy : 0, sy = cap === 2 ? dx : 0;
+      add(point[0] - dx - sx, point[1] + dy - sy);
+      add(point[0] + dx - sx, point[1] - dy - sy);
+    } else {
+      const angle = Math.atan2(dy, -dx);
+      const step = Math.max(1e-3, Math.acos(half / (half + 0.125)) * 2);
+      add(point[0] - dx, point[1] + dy);
+      for (let a = angle + step; a < angle + Math.PI - step / 4; a += step) add(point[0] + half * Math.cos(a), point[1] + half * Math.sin(a));
+      add(point[0] + dx, point[1] - dy);
+    }
+  };
+  const addJoin = (prev, point, next) => {
+    const len1 = Math.hypot(point[0] - prev[0], point[1] - prev[1]);
+    const len2 = Math.hypot(next[0] - point[0], next[1] - point[1]);
+    const dx1 = half * (point[1] - prev[1]) / len1, dy1 = half * (point[0] - prev[0]) / len1;
+    const dx2 = half * (next[1] - point[1]) / len2, dy2 = half * (next[0] - point[0]) / len2;
+    const inner = (next[0] - point[0]) * (point[1] - prev[1]) - (next[1] - point[1]) * (point[0] - prev[0]) > 0;
+    if (!inner && join === 1) {
+      arc(point, dx1, -dy1, dx2, -dy2);
+      return;
+    }
+    if (inner || join === 0) {
+      const ax = prev[0] + dx1, ay = prev[1] - dy1;
+      const bx = point[0] + dx1, by = point[1] - dy1;
+      const cx = point[0] + dx2, cy = point[1] - dy2;
+      const dx = next[0] + dx2, dy = next[1] - dy2;
+      const den = (bx - ax) * (dy - cy) - (by - ay) * (dx - cx);
+      if (Math.abs(den) >= 1e-30) {
+        const t = ((ay - cy) * (dx - cx) - (ax - cx) * (dy - cy)) / den;
+        const x = ax + (bx - ax) * t, y = ay + (by - ay) * t;
+        if (Math.hypot(x - point[0], y - point[1]) <= half * (inner ? 1.01 : miterLimit)) {
+          add(x, y);
+          return;
+        }
+      } else if ((bx - prev[0]) * dy1 - (prev[1] - by) * dx1 < 0 !== (bx - next[0]) * dy1 - (next[1] - by) * dx1 < 0) {
+        add(bx, by);
+        return;
+      }
+    }
+    add(point[0] + dx1, point[1] - dy1);
+    add(point[0] + dx2, point[1] - dy2);
+  };
+  for (const path of paths) {
+    for (const subpath of pattern.length ? dashSubpath(path, pattern, dashPhase) : [path]) {
+      const points = [];
+      for (const point of subpath.points) {
+        const prev = points[points.length - 1];
+        if (!prev || Math.hypot(prev[0] - point[0], prev[1] - point[1]) > 1e-14) points.push(point);
+      }
+      let closed = subpath.closed;
+      if (closed && points.length > 1 && Math.hypot(points[0][0] - points[points.length - 1][0], points[0][1] - points[points.length - 1][1]) <= 1e-14) points.pop();
+      if (points.length < 3) closed = false;
+      if (points.length === 1 && subpath.points.length > 1 && cap === 1) {
+        contour = [];
+        const [x, y] = points[0];
+        addCap([x, y], [x + 1, y]);
+        addCap([x, y], [x - 1, y]);
+        contours.push(contour);
+      } else if (points.length >= 2) {
+        contour = [];
+        if (!closed) addCap(points[0], points[1]);
+        for (let i = closed ? 0 : 1; i < points.length - (closed ? 0 : 1); i++) {
+          addJoin(points[(i + points.length - 1) % points.length], points[i], points[(i + 1) % points.length]);
+        }
+        if (closed) {
+          contours.push(contour);
+          contour = [];
+        } else addCap(points[points.length - 1], points[points.length - 2]);
+        for (let i = points.length - (closed ? 1 : 2); i >= (closed ? 0 : 1); i--) {
+          addJoin(points[(i + 1) % points.length], points[i], points[(i + points.length - 1) % points.length]);
+        }
+        contours.push(contour);
+      }
+    }
+  }
+  return contours;
+}
+
 // packages/pdf-ast/src/render/raster.ts
 function encodePng(bitmap) {
   return encodeRgbaToPng(bitmap.width, bitmap.height, bitmap.data);
@@ -34820,111 +35001,60 @@ function blendPixel(rgba, width, height, px, py, color, alpha, blendMode, clipMa
   rgba[idx + 2] = Math.round((effB * a + cbB * dstA * (1 - a)) / outA * 255);
   rgba[idx + 3] = Math.round(outA * 255);
 }
-function drawAntiAliasedSegment(rgba, width, height, x0, y0, x1, y1, strokeWidth, color, alpha = 1, lineCap = 0, antialias = true, blendMode, clipMask) {
-  const halfW = Math.max(0.6, strokeWidth * 0.5);
-  const dx = x1 - x0;
-  const dy = y1 - y0;
-  const lenSq = dx * dx + dy * dy;
-  const segLen = Math.sqrt(lenSq);
-  const pad = lineCap === 2 ? halfW + 2 : halfW + 1;
-  const minX = Math.max(0, Math.floor(Math.min(x0, x1) - pad));
-  const maxX = Math.min(width - 1, Math.ceil(Math.max(x0, x1) + pad));
-  const minY = Math.max(0, Math.floor(Math.min(y0, y1) - pad));
-  const maxY = Math.min(height - 1, Math.ceil(Math.max(y0, y1) + pad));
-  for (let py = minY; py <= maxY; py++) {
-    for (let px = minX; px <= maxX; px++) {
-      const cx = px + 0.5;
-      const cy = py + 0.5;
-      if (segLen > 1e-6 && (lineCap === 0 || lineCap === 2)) {
-        const ux = dx / segLen;
-        const uy = dy / segLen;
-        const along = (cx - x0) * ux + (cy - y0) * uy;
-        const perp = Math.abs(-(cx - x0) * uy + (cy - y0) * ux);
-        const minAlong = lineCap === 2 ? -halfW : 0;
-        const maxAlong = lineCap === 2 ? segLen + halfW : segLen;
-        const overAlong = along < minAlong ? minAlong - along : along > maxAlong ? along - maxAlong : 0;
-        const dist2 = overAlong > 0 ? Math.max(perp, halfW + overAlong) : perp;
-        if (dist2 <= halfW + 0.75) {
-          const cov = antialias ? Math.max(0, Math.min(1, halfW + 0.5 - dist2)) : dist2 <= halfW + 0.25 ? 1 : 0;
-          blendPixel(rgba, width, height, px, py, color, cov * alpha, blendMode, clipMask);
-        }
-        continue;
-      }
-      let t = lenSq > 1e-6 ? ((cx - x0) * dx + (cy - y0) * dy) / lenSq : 0;
-      t = Math.max(0, Math.min(1, t));
-      const projX = x0 + t * dx;
-      const projY = y0 + t * dy;
-      const dist = Math.hypot(cx - projX, cy - projY);
-      if (dist <= halfW + 0.75) {
-        const cov = antialias ? Math.max(0, Math.min(1, halfW + 0.5 - dist)) : dist <= halfW + 0.25 ? 1 : 0;
-        blendPixel(rgba, width, height, px, py, color, cov * alpha, blendMode, clipMask);
-      }
-    }
-  }
-}
-function segmentsToScreenEdges(segments, pageHeight, scale, closeSubpaths = false) {
-  const edges = [];
-  let curX = 0;
-  let curY = 0;
-  let startX = 0;
-  let startY = 0;
-  let hasOpenSubpath = false;
+function segmentsToScreenPaths(segments, pageHeight, scale) {
+  const paths = [];
+  let points = [];
+  let current = [0, 0];
   const toScreen = (x, y) => [x * scale, (pageHeight - y) * scale];
-  for (const seg of segments) {
-    if (seg.kind === "move") {
-      if (closeSubpaths && hasOpenSubpath && (curX !== startX || curY !== startY)) {
-        edges.push({ x0: curX, y0: curY, x1: startX, y1: startY });
-      }
-      [curX, curY] = toScreen(seg.x, seg.y);
-      startX = curX;
-      startY = curY;
-      hasOpenSubpath = false;
-    } else if (seg.kind === "line") {
-      const [nx, ny] = toScreen(seg.x, seg.y);
-      edges.push({ x0: curX, y0: curY, x1: nx, y1: ny });
-      curX = nx;
-      curY = ny;
-      hasOpenSubpath = true;
-    } else if (seg.kind === "cubic") {
-      const [p1x, p1y] = toScreen(seg.x1, seg.y1);
-      const [p2x, p2y] = toScreen(seg.x2, seg.y2);
-      const [p3x, p3y] = toScreen(seg.x, seg.y);
-      const points = flattenCubic(curX, curY, p1x, p1y, p2x, p2y, p3x, p3y);
-      let px = curX;
-      let py = curY;
-      for (let i = 1; i < points.length; i++) {
-        const [qx, qy] = points[i];
-        edges.push({ x0: px, y0: py, x1: qx, y1: qy });
-        px = qx;
-        py = qy;
-      }
-      curX = p3x;
-      curY = p3y;
-      hasOpenSubpath = true;
-    } else if (seg.kind === "close") {
-      if (curX !== startX || curY !== startY) {
-        edges.push({ x0: curX, y0: curY, x1: startX, y1: startY });
-        curX = startX;
-        curY = startY;
-      }
-      hasOpenSubpath = false;
-    } else if (seg.kind === "rect") {
-      if (closeSubpaths && hasOpenSubpath && (curX !== startX || curY !== startY)) {
-        edges.push({ x0: curX, y0: curY, x1: startX, y1: startY });
-      }
-      const [rx0, ry0] = toScreen(seg.x, seg.y);
-      const [rx1, ry1] = toScreen(seg.x + seg.width, seg.y + seg.height);
-      edges.push(
-        { x0: rx0, y0: ry0, x1: rx1, y1: ry0 },
-        { x0: rx1, y0: ry0, x1: rx1, y1: ry1 },
-        { x0: rx1, y0: ry1, x1: rx0, y1: ry1 },
-        { x0: rx0, y0: ry1, x1: rx0, y1: ry0 }
-      );
-      hasOpenSubpath = false;
+  for (const segment of segments) {
+    if (segment.kind === "move") {
+      if (points.length) paths.push({ points, closed: false });
+      current = toScreen(segment.x, segment.y);
+      points = [current];
+    } else if (segment.kind === "line") {
+      if (!points.length) points = [current];
+      current = toScreen(segment.x, segment.y);
+      points.push(current);
+    } else if (segment.kind === "cubic") {
+      if (!points.length) points = [current];
+      const a = toScreen(segment.x1, segment.y1), b = toScreen(segment.x2, segment.y2);
+      const end = toScreen(segment.x, segment.y);
+      const curve = flattenCubic(current[0], current[1], a[0], a[1], b[0], b[1], end[0], end[1]);
+      for (let i = 1; i < curve.length; i++) points.push(curve[i]);
+      current = end;
+    } else if (segment.kind === "close") {
+      if (points.length) {
+        paths.push({ points, closed: true });
+        current = points[0];
+        points = [];
+      }
+    } else if (segment.kind === "rect") {
+      if (points.length) paths.push({ points, closed: false });
+      const first = toScreen(segment.x, segment.y);
+      paths.push({ points: [
+        first,
+        toScreen(segment.x + segment.width, segment.y),
+        toScreen(segment.x + segment.width, segment.y + segment.height),
+        toScreen(segment.x, segment.y + segment.height)
+      ], closed: true });
+      current = first;
+      points = [];
+    }
+  }
+  if (points.length) paths.push({ points, closed: false });
+  return paths;
+}
+function pathsToEdges(paths, closeSubpaths = false) {
+  const edges = [];
+  for (const { points, closed } of paths) {
+    for (let i = 1; i < points.length; i++) {
+      const a = points[i - 1], b = points[i];
+      edges.push({ x0: a[0], y0: a[1], x1: b[0], y1: b[1] });
+    }
+    if ((closed || closeSubpaths) && points.length > 1) {
+      const a = points[points.length - 1], b = points[0];
+      edges.push({ x0: a[0], y0: a[1], x1: b[0], y1: b[1] });
     }
-  }
-  if (closeSubpaths && hasOpenSubpath && (curX !== startX || curY !== startY)) {
-    edges.push({ x0: curX, y0: curY, x1: startX, y1: startY });
   }
   return edges;
 }
@@ -35111,7 +35241,7 @@ function renderDisplayListToBitmap(displayList, options = {}) {
       for (const clip of clips) {
         const { segments, fillRule } = "segments" in clip ? clip : { segments: clip, fillRule: "nonzero" };
         const layer = new Uint8Array(width * height * 4);
-        fillEdgesScanline4x4(layer, width, height, segmentsToScreenEdges(segments, displayList.height, scale, true), { r: 1, g: 1, b: 1 }, 1, fillRule);
+        fillEdgesScanline4x4(layer, width, height, pathsToEdges(segmentsToScreenPaths(segments, displayList.height, scale), true), { r: 1, g: 1, b: 1 }, 1, fillRule);
         for (let i = 3; i < layer.length; i += 4) clipMask[i] = Math.round(clipMask[i] * layer[i] / 255);
       }
       cachedClips = clips;
@@ -35158,62 +35288,38 @@ function renderDisplayListToBitmap(displayList, options = {}) {
     if (operation.kind === "path") {
       const path = operation.value;
       if (path.fillColor) {
-        const edges = segmentsToScreenEdges(path.segments, displayList.height, scale, true);
+        const edges = pathsToEdges(segmentsToScreenPaths(path.segments, displayList.height, scale), true);
         const clipScreen = path.clipRect ? [path.clipRect[0] * scale, (displayList.height - path.clipRect[3]) * scale, path.clipRect[2] * scale, (displayList.height - path.clipRect[1]) * scale] : void 0;
         fillEdgesScanline4x4(rgba, width, height, edges, path.fillColor, path.fillAlpha ?? 1, path.fillRule ?? "nonzero", clipScreen, original.kind === "glyph" ? aaTxt : aaVec, path.blendMode, clipMask);
       }
       if (path.strokeColor) {
-        const edges = segmentsToScreenEdges(path.segments, displayList.height, scale, false);
         const rawSw = path.strokeWidth * scale;
         const sw = Math.max(1, rawSw);
         const strokeAlpha = options.thinLineMode === "shape" && rawSw < 1 ? (path.strokeAlpha ?? 1) * Math.max(0.25, rawSw) : path.strokeAlpha ?? 1;
-        const dashArr = path.dashArray && path.dashArray.length > 0 ? path.dashArray.map((d) => Math.max(0, d * scale)) : void 0;
-        const dashCycle = dashArr ? dashArr.reduce((a, b) => a + b, 0) : 0;
-        let dashDist = (path.dashPhase ?? 0) * scale % (dashCycle || 1);
-        if (dashDist < 0) dashDist += dashCycle;
-        for (const e of edges) {
-          if (!dashArr || dashCycle <= 1e-4) {
-            drawAntiAliasedSegment(rgba, width, height, e.x0, e.y0, e.x1, e.y1, sw, path.strokeColor, strokeAlpha, path.lineCap ?? 0, original.kind === "glyph" ? aaTxt : aaVec, path.blendMode, clipMask);
-          } else {
-            const dx = e.x1 - e.x0;
-            const dy = e.y1 - e.y0;
-            const edgeLen = Math.hypot(dx, dy);
-            if (edgeLen <= 1e-4) continue;
-            let pos = 0;
-            while (pos < edgeLen) {
-              let cycleRem = dashDist % dashCycle;
-              let dIdx = 0;
-              while (dIdx < dashArr.length - 1 && cycleRem >= dashArr[dIdx]) {
-                cycleRem -= dashArr[dIdx];
-                dIdx++;
-              }
-              const segRemainInDash = Math.max(1e-4, dashArr[dIdx] - cycleRem);
-              const step = Math.min(edgeLen - pos, segRemainInDash);
-              if (dIdx % 2 === 0) {
-                const t0 = pos / edgeLen;
-                const t1 = (pos + step) / edgeLen;
-                drawAntiAliasedSegment(
-                  rgba,
-                  width,
-                  height,
-                  e.x0 + dx * t0,
-                  e.y0 + dy * t0,
-                  e.x0 + dx * t1,
-                  e.y0 + dy * t1,
-                  sw,
-                  path.strokeColor,
-                  strokeAlpha,
-                  path.lineCap ?? 0,
-                  original.kind === "glyph" ? aaTxt : aaVec,
-                  path.blendMode,
-                  clipMask
-                );
-              }
-              pos += step;
-              dashDist = (dashDist + step) % dashCycle;
-            }
-          }
-        }
+        const contours = strokeOutlines(
+          segmentsToScreenPaths(path.segments, displayList.height, scale),
+          sw,
+          path.lineCap ?? 0,
+          path.lineJoin ?? 0,
+          path.miterLimit ?? 10,
+          path.dashArray?.map((value) => Math.max(0, value * scale)),
+          (path.dashPhase ?? 0) * scale
+        );
+        const edges = pathsToEdges(contours.map((points) => ({ points, closed: true })));
+        const clipScreen = path.clipRect ? [path.clipRect[0] * scale, (displayList.height - path.clipRect[3]) * scale, path.clipRect[2] * scale, (displayList.height - path.clipRect[1]) * scale] : void 0;
+        fillEdgesScanline4x4(
+          rgba,
+          width,
+          height,
+          edges,
+          path.strokeColor,
+          strokeAlpha,
+          "nonzero",
+          clipScreen,
+          original.kind === "glyph" ? aaTxt : aaVec,
+          path.blendMode,
+          clipMask
+        );
       }
     } else if (operation.kind === "image") {
       const img = operation.value;
@@ -37474,3 +37580,15 @@ export {
  * Copyright 2012 Mozilla Foundation. Licensed under Apache-2.0.
  * See THIRD_PARTY_NOTICES.md for the source revision and adaptations.
  */
+/*!
+ * Anti-Grain Geometry - Version 2.3
+ * Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+ *
+ * Permission to copy, use, modify, sell and distribute this software
+ * is granted provided this copyright notice appears in all copies.
+ * This software is provided "as is" without express or implied
+ * warranty, and with no claim as to its suitability for any purpose.
+ *
+ * Adapted from PDFium agg_math_stroke.h and agg_vcgen_stroke.cpp.
+ * See THIRD_PARTY_NOTICES.md for the source revision and adaptations.
+ */

package/dist/safe-bash/command-chunks/{chunk-S5EX6UP5.js → chunk-RDPJGIQF.js}

@@ -1,7 +1,7 @@
 import {
   PdfDocument,
   renderPdfPageToPng
-} from "./chunk-S3G2B4OX.js";
+} from "./chunk-G3IIEU2N.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/commands/python/index.browser.js

@@ -16,7 +16,7 @@ import {
   pythonCommands,
   pythonDocumentPackages,
   pythonHostFailureCode
-} from "../../chunks/chunk-CRQDMBQA.js";
+} from "../../chunks/chunk-FSH7QRIC.js";
 import {
   PythonFailure,
   inspectPythonCapabilities

package/dist/safe-bash/commands/python/llm-module.js

@@ -7,6 +7,7 @@ import asyncio
 import copy
 import inspect
 import math
+import os
 from dataclasses import dataclass, field, replace
 from typing import Any, AsyncIterator, Callable, Mapping, Optional, Protocol, Sequence, Union
 
@@ -49,7 +50,8 @@ class Attachment:
     def payload(self):
         if not isinstance(self.path, str) or not self.path or "\0" in self.path:
             raise ValueError("Attachment requires an agent filesystem path")
-        result = {"path": self.path}
+        path = self.path if os.path.isabs(self.path) else os.path.join(os.getcwd(), self.path)
+        result = {"path": path}
         if self.mime_type is not None:
             result["mimeType"] = self.mime_type
         return result

package/dist/safe-bash/commands/python/shell-module.js

@@ -4,6 +4,7 @@ from __future__ import annotations
 import asyncio
 import math
 import inspect
+import os
 import subprocess
 from dataclasses import dataclass
 
@@ -59,6 +60,12 @@ def _payload(args, *, shell=False, input=None, cwd=None, env=None, timeout=None,
         elif not isinstance(input, (bytes, bytearray, memoryview)):
             raise TypeError('Binary input must be bytes')
         result['input'] = list(input)
+    # The host retains the original shell context; snapshot the current guest state.
+    if cwd is None:
+        cwd = os.getcwd()
+    elif cwd and not os.path.isabs(cwd):
+        cwd = os.path.join(os.getcwd(), cwd)
+    env = dict(os.environ if env is None else env)
     result.update(cwd=cwd, env=env, timeout=timeout, max_output_bytes=max_output_bytes)
     return result
 

package/dist/safe-bash/core.browser.js

@@ -158,7 +158,7 @@ import {
   sha256,
   sha384,
   sha512
-} from "./chunks/chunk-CRQDMBQA.js";
+} from "./chunks/chunk-FSH7QRIC.js";
 import {
   PythonFailure,
   inspectPythonCapabilities
@@ -85450,6 +85450,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     let inc = 1;
     let noRenumber = false;
     let joinBlanks = 1;
+    let hasFileOperand = false;
     const parseSecSpec = (v) => {
       if (v === "a" || v === "t" || v === "n") return { style: v };
       if (v.startsWith("p") && v.length > 1) {
@@ -85542,9 +85543,11 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       } else if (/^-i-?[0-9]{1,9}$/.test(a)) {
         inc = Number(a.slice(2));
       } else if (!a.startsWith("-")) {
-        if (cwd === void 0) return [];
+        if (cwd === void 0) return void 0;
         const fl = this.readSyncMemoryLines(resolvePath(cwd, a));
         if (!fl) return void 0;
+        if (!hasFileOperand) rawLines = [];
+        hasFileOperand = true;
         rawLines = [...rawLines, ...fl];
       } else {
         return void 0;
@@ -87258,11 +87261,11 @@ unsigned int ${ident}_len = ${view.byteLength};
     if (cmdName === "whoami") {
       if (opArgs.length !== 0 || this.tryReadMemoryFileViewSync("/etc/passwd", false) !== void 0) return void 0;
       if (getEnv("ID_EUID") !== void 0 || getEnv("EUID") !== void 0 || getEnv("ID_UID") !== void 0 || getEnv("UID") !== void 0) return void 0;
-      return getEnv("WHOAMI_USER") ?? getEnv("USER") ?? getEnv("LOGNAME") ?? "sandbox";
+      return getEnv("WHOAMI") ?? getEnv("USER") ?? getEnv("LOGNAME") ?? "sandbox";
     }
     if (cmdName === "id") {
       if (this.tryReadMemoryFileViewSync("/etc/passwd", false) !== void 0 || this.tryReadMemoryFileViewSync("/etc/group", false) !== void 0) return void 0;
-      for (const k of ["ID_UID", "UID", "ID_EUID", "EUID", "ID_GID", "GID", "ID_EGID", "EGID", "ID_USER", "USER", "LOGNAME", "ID_GROUP", "ID_GROUPS", "ID_CONTEXT"]) {
+      for (const k of ["ID_UID", "UID", "ID_EUID", "EUID", "ID_GID", "GID", "ID_EGID", "EGID", "ID_USER", "USER", "LOGNAME", "GROUP", "ID_GROUPS", "SELINUX_CONTEXT"]) {
         if (getEnv(k) !== void 0) return void 0;
       }
       if (opArgs.length === 0) return "uid=1000(sandbox) gid=1000(sandbox) groups=1000(sandbox)";
@@ -87275,10 +87278,12 @@ unsigned int ${ident}_len = ${view.byteLength};
     }
     if (cmdName === "hostname") {
       if (this.tryReadMemoryFileViewSync("/etc/hostname", false) !== void 0 || getEnv("HOSTNAME_DOMAIN") !== void 0 || getEnv("HOSTNAME_IP") !== void 0) return void 0;
-      const host2 = getEnv("HOSTNAME") ?? "sandbox";
-      if (opArgs.length === 0 || opArgs.length === 1 && (opArgs[0] === "-f" || opArgs[0] === "--fqdn" || opArgs[0] === "--long")) return host2;
+      const host2 = getEnv("HOSTNAME") || "sandbox";
+      if (opArgs.length === 0) return host2;
+      if (opArgs.length === 1 && (opArgs[0] === "-f" || opArgs[0] === "--fqdn" || opArgs[0] === "--long")) return host2.includes(".") ? host2 : `${host2}.vfs.local`;
       if (opArgs.length === 1 && (opArgs[0] === "-s" || opArgs[0] === "--short")) return host2.split(".")[0];
-      if (opArgs.length === 1 && (opArgs[0] === "-i" || opArgs[0] === "--ip-address" || opArgs[0] === "-I" || opArgs[0] === "--all-ip-addresses")) return "127.0.0.1";
+      if (opArgs.length === 1 && (opArgs[0] === "-i" || opArgs[0] === "--ip-address")) return "127.0.0.1";
+      if (opArgs.length === 1 && (opArgs[0] === "-I" || opArgs[0] === "--all-ip-addresses")) return "127.0.0.1 ";
       return void 0;
     }
     if (cmdName === "nproc") {
@@ -87460,6 +87465,7 @@ unsigned int ${ident}_len = ${view.byteLength};
     if (operands.length > 0) {
       for (const op of operands) tokens.push(op);
     } else {
+      if (rawLines === void 0) return void 0;
       for (const line of rawLines) {
         for (const t of line.split(/[ \t\r\n\f\v]+/)) {
           if (t.length > 0) tokens.push(t);
@@ -87524,6 +87530,7 @@ unsigned int ${ident}_len = ${view.byteLength};
       if (memLines === void 0) return void 0;
       linesToRead = memLines;
     }
+    if (linesToRead === void 0) return void 0;
     const tokens = [];
     for (const line of linesToRead) {
       for (const t of line.split(/[ \t\r\n\f\v]+/)) {
@@ -87604,6 +87611,7 @@ unsigned int ${ident}_len = ${view.byteLength};
       const vars = extractVars(operands[0]);
       return vars.length > 0 ? vars.join("\n") + "\n" : "";
     }
+    if (inStr === void 0) return void 0;
     const allowedVars = operands.length === 1 ? new Set(extractVars(operands[0])) : void 0;
     const raw = stateMonitor(rawState)?.raw ?? rawState;
     const isRestrictedEnv = raw._exported === void 0 && "_exported" in raw;
@@ -88805,7 +88813,18 @@ unsigned int ${ident}_len = ${view.byteLength};
     const list = part.script.lists[0];
     if (list.terminator || list.pipelines.length !== 1) return void 0;
     const pipeline = list.pipelines[0];
-    if (pipeline.negate) return void 0;
+    if (pipeline.negate || customRegisteredRegistries.has(this.commands)) return void 0;
+    for (const command4 of pipeline.commands) {
+      if (command4.kind !== "simple") continue;
+      const name2 = command4.words[0]?.plain;
+      if (!name2) continue;
+      if (name2 === "fmt" && command4 === pipeline.commands[0] && command4.redirects.length === 0 && !io.stdinIsDefault) return void 0;
+      const definition2 = this.getExternalCommand(name2);
+      if (definition2 && customRegisteredCommands.has(definition2.execute)) return void 0;
+      if (name2 === "uname" || name2 === "nproc" || name2 === "hostname" || name2 === "id" || name2 === "whoami") {
+        if (!definition2 || !internal_exports.builtInDirectContextExecutors.has(definition2.execute)) return void 0;
+      }
+    }
     if (pipeline.commands.length >= 2 && pipeline.commands.length <= 5) {
       if (syncPurePipelineSlotInUse || !this.budget.canSyncPurePipe || (0, yield_exports.hasYieldCheckpoint)(this.signal) || rawState.errexit || rawState.nounset || this.budget.commands + pipeline.commands.length > this.budget.limits.maxCommands) {
         return void 0;
@@ -89790,7 +89809,8 @@ unsigned int ${ident}_len = ${view.byteLength};
     if (cmd.kind !== "simple" || cmd.redirects.length > 0 && !hasSingleStdinRedir && !hasSingleHereStringRedir || cmd.words.length === 0) return void 0;
     let w0Plain = cmd.words[0].plain;
     if (!w0Plain || rawState.extensions?.builtins.has(w0Plain)) return void 0;
-    if (w0Plain === "xxd" || w0Plain === "od" || w0Plain === "mktemp" || w0Plain === "chmod") {
+    if (w0Plain === "fmt" && !hasSingleStdinRedir && !hasSingleHereStringRedir && !io.stdinIsDefault) return void 0;
+    if (w0Plain === "xxd" || w0Plain === "od" || w0Plain === "mktemp" || w0Plain === "chmod" || w0Plain === "uname" || w0Plain === "nproc" || w0Plain === "hostname" || w0Plain === "id" || w0Plain === "whoami") {
       const definition2 = this.getExternalCommand(w0Plain);
       if (!definition2 || !internal_exports.builtInDirectContextExecutors.has(definition2.execute)) return void 0;
     }
@@ -90432,11 +90452,11 @@ unsigned int ${ident}_len = ${view.byteLength};
         if (w0Plain === "comm") cjLines = this.evalSyncComm(stdinLines, allArgs, rawState.cwd);
         else if (w0Plain === "join") cjLines = this.evalSyncJoin(stdinLines, allArgs, rawState.cwd);
         else if (w0Plain === "paste") cjLines = this.evalSyncPaste(stdinLines ?? [], allArgs, rawState.cwd);
-        else if (w0Plain === "factor") cjLines = this.evalSyncFactor(stdinLines ?? [], allArgs);
-        else if (w0Plain === "tsort") cjLines = this.evalSyncTsort(stdinLines ?? [], allArgs, rawState.cwd);
+        else if (w0Plain === "factor") cjLines = this.evalSyncFactor(stdinLines, allArgs);
+        else if (w0Plain === "tsort") cjLines = this.evalSyncTsort(stdinLines, allArgs, rawState.cwd);
         else if (w0Plain === "jq") cjLines = this.evalSyncJq(void 0, allArgs, rawState.cwd);
         else if (w0Plain === "envsubst") {
-          const esOut = this.evalSyncEnvsubst("", allArgs, rawState);
+          const esOut = this.evalSyncEnvsubst(void 0, allArgs, rawState);
           if (esOut !== void 0) cjLines = esOut.endsWith("\n") ? esOut.slice(0, -1).split("\n") : esOut ? [esOut] : [];
         } else if (w0Plain === "numfmt") {
           const optArgs = [];