@poe-platform/safe-bash 0.1.762 → 0.1.764

package/dist/safe-playwright-cloudflare/browser-snapshot-labels.d.ts

@@ -0,0 +1,14 @@
+export interface SnapshotScript {
+    incrementalAriaSnapshot(node: Node, options: {
+        mode: string;
+        refPrefix?: string;
+        track?: string;
+        doNotRenderActive?: boolean;
+    }): {
+        full: string;
+        incremental?: string;
+        iframeRefs: string[];
+    };
+    _safeBashSnapshotLabels?: boolean;
+}
+export declare function installSnapshotLabelCache(injected: SnapshotScript): void;

package/dist/safe-playwright-cloudflare/browser-snapshot-labels.js

@@ -0,0 +1,62 @@
+// Chromium's control.labels NodeList scans the tree for each control. Reverse
+// the lookup through native label.control once per tree and synchronous capture.
+// Only the provider's utility world is changed; restore its descriptors even
+// when capture throws, and never keep an index across DOM mutations.
+export function installSnapshotLabelCache(injected) {
+    if (injected._safeBashSnapshotLabels)
+        return;
+    const snapshot = injected.incrementalAriaSnapshot;
+    injected.incrementalAriaSnapshot = function (node, options) {
+        const roots = new Map();
+        const descriptors = [];
+        try {
+            for (const constructor of [
+                HTMLButtonElement,
+                HTMLInputElement,
+                HTMLMeterElement,
+                HTMLOutputElement,
+                HTMLProgressElement,
+                HTMLSelectElement,
+                HTMLTextAreaElement
+            ]) {
+                const prototype = constructor.prototype;
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, "labels");
+                if (!descriptor?.get)
+                    throw new Error("Native labels getter is unavailable");
+                descriptors.push([prototype, descriptor]);
+                Object.defineProperty(prototype, "labels", {
+                    ...descriptor,
+                    get() {
+                        if (this instanceof HTMLInputElement && this.type === "hidden")
+                            return null;
+                        const root = this.getRootNode();
+                        let controls = roots.get(root);
+                        if (!controls) {
+                            controls = new Map();
+                            roots.set(root, controls);
+                            const labels = Array.from(root.querySelectorAll("label"));
+                            if (root instanceof HTMLLabelElement)
+                                labels.unshift(root);
+                            for (const label of labels) {
+                                const control = label.control;
+                                if (!control)
+                                    continue;
+                                let associated = controls.get(control);
+                                if (!associated)
+                                    controls.set(control, (associated = []));
+                                associated.push(label);
+                            }
+                        }
+                        return controls.get(this) ?? [];
+                    }
+                });
+            }
+            return snapshot.call(this, node, options);
+        }
+        finally {
+            for (const [prototype, descriptor] of descriptors)
+                Object.defineProperty(prototype, "labels", descriptor);
+        }
+    };
+    injected._safeBashSnapshotLabels = true;
+}

package/dist/safe-playwright-cloudflare/browser-snapshot-scheduler.js

@@ -1,3 +1,4 @@
+import { installSnapshotLabelCache } from './browser-snapshot-labels.js';
 /** Serialize native frame capture before cold utility scripts become CDP payloads.
  * The pinned provider recurses only after this callback returns, so descendants
  * do not retain a parent slot. Native traversal, retries and refs stay intact. */
@@ -54,7 +55,13 @@ export function createBrowserSnapshotScheduler() {
     }
     function snapshotAction(progress, frame, action) {
         return function (continuePolling) {
-            return schedule(progress, frame, () => action.call(this, continuePolling));
+            return schedule(progress, frame, async () => {
+                const context = await progress.race(frame._utilityContext());
+                const injected = await progress.race(context.injectedScript());
+                await progress.race(injected.evaluate(installSnapshotLabelCache));
+                progress.signal.throwIfAborted();
+                return action.call(this, continuePolling);
+            });
         };
     }
     function prepareFrame(frame) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.762",
+  "version": "0.1.764",
   "description": "Extensible virtual shell with pluggable filesystems and streaming commands",
   "type": "module",
   "license": "MIT",
@@ -841,7 +841,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.762",
+    "@poe-platform/safe-fs": "0.1.764",
     "pdf-lib": "1.17.1",
     "@noble/hashes": "2.4.0",
     "pako": "3.0.1",

package/third-party/pdf-ast/THIRD_PARTY_NOTICES.md

@@ -215,6 +215,20 @@ adapter; other cases use independently rendered PDF.js pixels.
 
 Source: https://github.com/chromium/pdfium/blob/a84323421e94f484faca52dd9d027934eba42ab8/third_party/agg23/agg_curves.cpp
 
+`src/render/stroke.ts` adapts the cap, join, miter and arc calculations from
+`third_party/agg23/agg_math_stroke.h`, with forward/backward contour assembly
+from `agg_vcgen_stroke.cpp`, at the same PDFium revision and under the same AGG
+permission terms. The adapter uses double-precision arrays, PDFium's
+`miter_join_revert` bevel fallback, and a one-million-vertex expansion limit.
+Local dash splitting preserves joins across vertices and closed seams, resets
+phase per subpath, and handles odd arrays and zero-length round dots.
+`src/render/stroke-joins.test.ts` checks native cap/join vectors plus independent
+PDF.js pixels; Poppler also confirms the final zero-length dash is omitted.
+The native harness calls unchanged upstream math routines with minimal support
+headers and local contour assembly; it is not the full upstream generator.
+
+Source: https://github.com/chromium/pdfium/blob/a84323421e94f484faca52dd9d027934eba42ab8/third_party/agg23/agg_math_stroke.h
+
 
 # SVG labels
 
@@ -359,6 +373,19 @@ device pixel as the enlargement threshold. `image-downsampling.test.ts` adds
 memory-only stripe, alpha, transform, stencil, and save/reopen regressions;
 the unchanged upstream issue13372 fixture also covers reduced patterned masks.
 
+ExtGState soft-mask evaluation and rendering follow PDF.js `handleSMask`,
+`beginGroup`, `_prepareSMaskCanvas`, and `_bakeSMaskCanvas` at the same revision
+(Mozilla Foundation, Apache-2.0). The adapter captures page-coordinate mask
+paints, resets group alpha/blend/soft-mask state, converts the luminosity
+backdrop before filtering, and builds a 256-entry transfer table. Isolated
+Forms retain their own paint groups so outer opacity is applied once.
+Bitmap masks retain only the current prepared surface; SVG masks use the
+export resolution while isolated Form contents remain vector groups.
+`soft-mask.test.ts` ports four unchanged upstream equality fixtures, recorded
+in `src/fixtures/SOURCES.md`, and adds local alpha/transform/group tests plus
+the original issue17069 signature regression. Soft-mask evaluation is bounded
+by the existing eight-level Form limit; mask-only text is excluded from extraction.
+
 Malformed dictionary-key recovery follows PDF.js `Parser.getObj`, skipping
 stray non-Name tokens only in local repair mode. Damaged optional ToUnicode
 streams follow `PartialEvaluator.readToUnicode` error recovery while retaining