@poe-platform/safe-fs 0.1.740 → 0.1.741

package/README.md

@@ -113,6 +113,11 @@ call `staging.cleanup.close()` in `finally`. Memory and its supported wrappers
 retain only the owned staging entries; replacement entries remain protected.
 See the [staging contract](src/contracts/filesystem.md#atomic-owned-staging).
 
+Capture `retainFileSystemCleanup(scoped, callback, { maxOperations })` before
+cancellation to clean up through a bounded view after ordinary scoped operations
+close. Cleanup preserves its owning scope and limits across separately bundled
+command runtimes, including restrictions added by filesystem wrappers.
+
 | Backend or wrapper | Use it for |
 | --- | --- |
 | `createMemoryFileSystem()` | Isolated, nonpersistent storage with links, permissions, timestamps, and streams; each path resolution admits at most 65,536 cumulative UTF-16 code units across the input and followed symlink targets, rejecting excess with `ENAMETOOLONG` before component allocation |

package/dist/safe-fs/fs/scoped.js

@@ -8,6 +8,7 @@ import { openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabi
 import { createStagingCleanup, snapshotStagingCreation } from "./staging-cleanup.js";
 import { inspectStagingBindings, runStagingGuard, snapshotDirectoryAncestry, snapshotStagingResolution } from "./staging-ancestry.js";
 const originals = new WeakMap();
+const retainedCleanupSymbol = Symbol.for("safe-fs.retainedCleanup");
 const retargeters = new WeakMap();
 export function retargetScopedFileSystem(scoped, charge, signal, cleanupCharge = charge, maxPathComponents) {
     const fn = retargeters.get(scoped);
@@ -233,6 +234,8 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
             return Reflect.set(original, property, value, original);
         },
         get(_target, property) {
+            if (property === retainedCleanupSymbol)
+                return cleanupBinding;
             if (property === "capabilities") {
                 const rawCaps = original.capabilities;
                 if (cachedComputedCaps !== undefined &&
@@ -510,6 +513,7 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
             return scoped;
         },
     });
+    const cleanupBinding = Object.freeze({ filesystem: view, retain: retainFileSystemCleanup });
     const originalRecord = { filesystem: original, signal, cleanupCharge, creationMask, maxPathComponents };
     originals.set(view, originalRecord);
     retargeters.set(view, (nextCharge, nextSignal, nextCleanupCharge, nextMaxPathComponents) => {
@@ -538,6 +542,13 @@ export function retainFileSystemCleanup(filesystem, cleanupCallback, options) {
     if (typeof cleanupCallback !== "function")
         throw new TypeError("cleanup callback must be a function");
     const scope = originals.get(filesystem);
+    if (!scope) {
+        // Bundled commands can hold another module copy. Delegate only for this
+        // exact view, never through a wrapper that happens to forward its symbols.
+        const binding = Reflect.get(filesystem, retainedCleanupSymbol);
+        if (binding?.filesystem === filesystem && typeof binding.retain === "function" && binding.retain !== retainFileSystemCleanup)
+            return binding.retain(filesystem, cleanupCallback, options);
+    }
     scope?.signal.throwIfAborted();
     const backing = scope?.filesystem ?? filesystem;
     const pending = new Set();

package/dist/safe-fs/xml.js

@@ -273,6 +273,7 @@ export function* parseXmlSteps(input, limits = {}) {
     let nodes = 0;
     let attributeCount = 0;
     let contentNodes = 0;
+    let previousEmpty;
     const admitContent = () => {
         if (++contentNodes > maxContentNodes)
             throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
@@ -440,17 +441,23 @@ export function* parseXmlSteps(input, limits = {}) {
         }
         else {
             offset++;
-            const [name, prefix, localName, wName] = scanName();
+            const repeated = previousEmpty && source.startsWith(previousEmpty.suffix, offset) ? previousEmpty : undefined;
+            const [name, prefix, localName, wName] = repeated
+                ? [repeated.name, repeated.prefix, repeated.localName, repeated.name.length * 2]
+                : scanName();
+            if (repeated)
+                offset += name.length;
+            // Preserve scan/validation work while reusing the admitted spelling.
             pendingWork += wName;
             while (pendingWork >= 512) {
                 yield 512;
                 pendingWork -= 512;
             }
-            const attributes = new Map();
+            let attributes;
             const attrMeta = [];
             let namespaces = stack.at(-1)?.namespaces ?? new Map([["xml", xmlNamespace]]);
             let ownsNamespaces = stack.length === 0;
-            while (true) {
+            while (!repeated) {
                 const ws = skipWhitespace();
                 pendingWork += ws;
                 while (pendingWork >= 512) {
@@ -468,6 +475,7 @@ export function* parseXmlSteps(input, limits = {}) {
                     yield 512;
                     pendingWork -= 512;
                 }
+                attributes ??= new Map();
                 if (attributes.has(attribute))
                     invalid("duplicate attribute");
                 if (++attributeCount > maxAttributes)
@@ -560,7 +568,7 @@ export function* parseXmlSteps(input, limits = {}) {
             limits.onElement?.({ name, namespace, localName }, stack.at(-1)?.element, stack.length + 1);
             admitContent();
             const retainedAttributes = [];
-            if (retainContent) {
+            if (retainContent && attributes) {
                 for (let i = 0; i < attrMeta.length; i++) {
                     const [attribute, attrPrefix, attrLocal] = attrMeta[i];
                     const value = attributes.get(attribute);
@@ -590,6 +598,10 @@ export function* parseXmlSteps(input, limits = {}) {
                 offset++;
             if (source[offset++] !== ">")
                 invalid("unterminated start tag");
+            // Only cache compact, attribute-free spellings. Namespace resolution and
+            // every admission counter still run for each distinct physical element.
+            if (empty && !attributes && name.length <= 512 && source.slice(offset - name.length - 3, offset) === `<${name}/>`)
+                previousEmpty = { suffix: name + "/>", name, prefix, localName };
             if (!empty)
                 stack.push({ element, content, name, namespaces });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.740",
+  "version": "0.1.741",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",