@poe-platform/safe-fs 0.1.814 → 0.1.816

package/README.md

@@ -317,6 +317,8 @@ Every raw filesystem operation accepts an optional `signal`. Additional fields a
 
 `access` takes a separate mode bitmask from `ACCESS_MODES`. `chmod` takes a mode, `utimes` takes millisecond timestamps, and `truncate` takes a byte length (default 0). For conditional chmod, check `capabilitiesFor(path, { conditionalChmod: true })` (or `capabilities`) and require `conditionalChmod: true`; supply `parent`, `expected`, and complete root-to-parent `ancestors` together. An optional mutation-free `commitGuard` must return literal `true` synchronously. Memory validates at its metadata commit; mount and supported Memory overlays preserve wrapper ancestry. Real uses its existing externally isolated host-tree boundary and does not prevent races with other processes. Backend limits still apply. Node-shaped bridge methods translate their own options rather than accepting these raw option objects; see the [bridge signatures](src/bridge/filesystem.ts).
 
+Cross-mount streamed copies start reading the source before opening the destination for writing. An initial read failure leaves the destination unchanged; later read or write failures can leave partial destination bytes.
+
 Overlay copy-up, copy, stream replacement/append and resize transfer retained ranges in 64 KiB chunks through the injected upper's stream writer. Resize streams the retained prefix and bounded zero chunks. Stream writes stage input before publication; cancellation or transfer failure leaves the destination unchanged and cleans staging. Stock Memory overlays transfer staged storage into existing upper inodes, preserving hardlinks without an additional whole-file buffer. `readFile` and `writeFile` remain buffering convenience APIs; use `readStream`/`writeStream` for large payloads. `maxBufferBytes` retains its existing optional total-byte admission semantics, not a working-memory guarantee.
 
 A streaming overlay needs an upper with `atomicRename`, `streamingWrite`, retained reads (`retainedRead` plus `openReadFile`), exclusive create, directory mutation, permissions and timestamps. Both layers must provide retained, bounded range reads with stable file and directory identities. For example, inject these host-authorized adapters with `createOverlayFileSystem({ upper: externalSpool, lower: retainedSource })`, then use `overlay.writeStream(path, source)`. The upper must await each consumed chunk, keep transport queues bounded, and preserve ownership until publication. Supply bounded chunks at the input boundary; the overlay cannot undo a payload-wide allocation already made by its caller. Whole-file-only uppers explicitly reject transfer operations with `ENOTSUP`; they do not silently collect streams.

package/dist/safe-fs/fs/mount/index.js

@@ -1308,7 +1308,16 @@ export class MountFileSystem {
                 const source = readBytes(reader.readStream(origin.local, options), options.signal);
                 let failed = false;
                 try {
-                    await writer.writeStream(target.local, source, writeOptions);
+                    // Admit lazy reader startup before the writer can truncate its target.
+                    // Later transfer failures retain the backend's partial-write semantics.
+                    const first = await source.next();
+                    await writer.writeStream(target.local, (async function* () {
+                        let item = first;
+                        while (!item.done) {
+                            yield item.value;
+                            item = await source.next();
+                        }
+                    })(), writeOptions);
                 }
                 catch (error) {
                     failed = true;

package/dist/xml-ast/index.d.ts

@@ -54,6 +54,8 @@ export interface XmlStepLimits extends XmlLimits {
     readonly events?: (event: XmlStreamEvent) => void;
 }
 export interface XmlSourceLimits extends XmlStepLimits {
+    /** Keep normalized declaration fields instead of the complete source spelling. */
+    readonly compactDeclaration?: boolean;
     /** Emit content bodies in bounded fragments, marking continuations of the same logical
      * node. Requires retainTree: false; consumers must preserve fragment identity. */
     readonly fragmentContent?: boolean;

package/dist/xml-ast/index.js

@@ -176,11 +176,10 @@ function* entities(text, recover) {
     }
     return result;
 }
-function* validDeclaration(content, expectedEncoding) {
-    let offset = 0;
+function* readDeclaration(source, offset, end, expectedEncoding) {
     const whitespace = function* () {
         const start = offset;
-        while (offset < content.length && " \t\n\r".includes(content[offset])) {
+        while (offset < end && " \t\n\r".includes(yield* source.slice(offset, offset + 1))) {
             offset++;
             if ((offset - start) % 512 === 0)
                 yield 512;
@@ -189,53 +188,58 @@ function* validDeclaration(content, expectedEncoding) {
             yield (offset - start) % 512;
         return offset - start;
     };
-    const field = function* (name) {
-        if (content.slice(offset, offset + name.length) !== name)
+    const field = function* (name, maxLength) {
+        if ((yield* source.slice(offset, Math.min(end, offset + name.length))) !== name)
             return undefined;
         offset += name.length;
         yield name.length;
         yield* whitespace();
-        if (content[offset++] !== "=")
+        if (offset >= end || (yield* source.charCodeAt(offset++)) !== 61)
             return undefined;
         yield* whitespace();
-        const quote = content[offset++];
+        if (offset >= end)
+            return undefined;
+        const quote = yield* source.slice(offset++, offset);
         if (quote !== "'" && quote !== '"')
             return undefined;
         const start = offset;
-        while (offset < content.length && content[offset] !== quote) {
+        while (offset < end && (yield* source.slice(offset, offset + 1)) !== quote) {
             offset++;
             if ((offset - start) % 512 === 0)
                 yield 512;
         }
         if ((offset - start) % 512)
             yield (offset - start) % 512;
-        if (offset >= content.length)
+        if (offset >= end || offset - start > maxLength)
             return undefined;
-        return content.slice(start, offset++);
+        return yield* source.slice(start, offset++);
     };
-    if (!(yield* whitespace()) || (yield* field("version")) !== "1.0")
-        return false;
+    if (!(yield* whitespace()) || (yield* field("version", 3)) !== "1.0")
+        return undefined;
+    let result = '<?xml version="1.0"';
     let spacing = yield* whitespace();
-    if (content.slice(offset, offset + 8) === "encoding") {
+    if ((yield* source.slice(offset, Math.min(end, offset + 8))) === "encoding") {
         if (!spacing)
-            return false;
-        const encoding = yield* field("encoding");
-        if (encoding === undefined || encoding.length > 8 || !["utf-8", "utf-16", "utf-16le", "utf-16be"].includes(encoding.toLowerCase()))
-            return false;
+            return undefined;
+        const encoding = yield* field("encoding", 8);
+        if (encoding === undefined || !["utf-8", "utf-16", "utf-16le", "utf-16be"].includes(encoding.toLowerCase()))
+            return undefined;
         if (expectedEncoding !== undefined && encoding.toLowerCase() !== expectedEncoding.toLowerCase()
             && !(encoding.toLowerCase() === "utf-16" && (expectedEncoding === "UTF-16LE" || expectedEncoding === "UTF-16BE")))
-            return false;
+            return undefined;
+        result += ` encoding="${encoding}"`;
         spacing = yield* whitespace();
     }
-    if (content.slice(offset, offset + 10) === "standalone") {
+    if ((yield* source.slice(offset, Math.min(end, offset + 10))) === "standalone") {
         if (!spacing)
-            return false;
-        const standalone = yield* field("standalone");
-        if (standalone === undefined || standalone.length > 3 || !["yes", "no"].includes(standalone))
-            return false;
+            return undefined;
+        const standalone = yield* field("standalone", 3);
+        if (standalone === undefined || !["yes", "no"].includes(standalone))
+            return undefined;
+        result += ` standalone="${standalone}"`;
         yield* whitespace();
     }
-    return offset === content.length;
+    return offset === end ? result + "?>" : undefined;
 }
 function validateLimits(limits) {
     for (const limit of [limits.maxDepth, limits.maxNodes, limits.maxAttributes, limits.maxContentNodes, limits.maxAttributesPerElement, limits.maxNamespaces]) {
@@ -485,12 +489,13 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             if (end < 0)
                 invalid("unterminated processing instruction");
             if (target.length === 3 && target.toLowerCase() === "xml") {
-                const content = yield* source.slice(offset, end);
-                if (start !== 0 || target !== "xml"
-                    || !(yield* validDeclaration(content, limits.expectedEncoding)))
+                if (start !== 0 || target !== "xml")
+                    invalid("unsupported XML declaration");
+                const parsed = yield* readDeclaration(source, offset, end, limits.expectedEncoding);
+                if (parsed === undefined)
                     invalid("unsupported XML declaration");
                 if (retainContent)
-                    declaration = yield* source.slice(start, end + 2);
+                    declaration = limits.compactDeclaration ? parsed : yield* source.slice(start, end + 2);
             }
             else {
                 if (offset < end && !" \t\n\r".includes(yield* source.slice(offset, offset + 1)))

package/package.json

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