toolcraft 0.0.759 → 0.0.760

package/composition.json

@@ -133,7 +133,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.759",
+      "version": "0.0.760",
       "license": "MIT"
     },
     {
@@ -143,7 +143,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.759",
+      "version": "0.0.760",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -133,7 +133,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.759",
+      "version": "0.0.760",
       "license": "MIT"
     },
     {
@@ -143,7 +143,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.759",
+      "version": "0.0.760",
       "license": "MIT"
     },
     {

package/node_modules/@poe-code/safe-fs/README.md

@@ -295,6 +295,14 @@ 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).
 
+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.
+
+For Workers, `externalSpool` must store payloads outside isolate RAM and satisfy that contract, including atomic rename and retained identity. Memory and the S3 mock store payloads in RAM and are not external spools. Stock S3/WebDAV do not provide the atomic rename/retained-read contract needed for an overlay upper; setting a capability flag does not add it. A host must inject a qualified external adapter. On Node, rooted Real adapters provide the streaming overlay configuration under their documented external-tree isolation requirement. Mount and read-only wrappers forward the selected backend's capabilities; quota streaming additionally requires a real streaming-append route. S3's buffered append convenience path reports `streamingAppend: false`.
+
+The reusable metadata-only fixture in [`tests/fixtures/bounded-filesystem.ts`](tests/fixtures/bounded-filesystem.ts) generates file ranges and consumes slow writes without storing payload bytes. [`tests/overlay-bounded.test.ts`](tests/overlay-bounded.test.ts) checks fixed transfer sizes, source backpressure, cancellation/error cleanup, byte results, and Memory publication allocation/identity. These deterministic conformance checks do not qualify a deployed Worker backend; follow the [Worker QA plan](../../docs/plans/safe-fs-bounded-overlay-qa.md) for runtime measurements.
+
 `collectBytes(source, { maxBytes, maxMemoryBytes, signal })` snapshots streamed chunks into one growing buffer. `maxBytes` and `maxMemoryBytes` accept explicit `Infinity`. `maxMemoryBytes` limits owned capacity, the current input's full backing buffer, and overlapping allocations during growth; exhaustion throws `EFBIG`. Collection limits are disabled by default on Node, browser, and Worker targets. Each call owns its budget; concurrent collections do not consume one another’s allowance. The returned view may retain geometric spare capacity. Configured budgets cover collection, not caller-retained results, transport buffering, archive decoding, strings, or the rest of the runtime; use streaming APIs and limit concurrent workloads for larger inputs.
 
 <details>

package/node_modules/@poe-code/safe-fs/dist/fs/capabilities.js

@@ -141,8 +141,8 @@ export function readOnlyCapabilities(capabilities) {
     });
 }
 export function quotaCapabilities(capabilities) {
-    const streamingWrite = requireCapabilities(capabilities.write, capabilities.append, !capabilities.readOnly);
-    const streamingAppend = requireCapabilities(capabilities.append, !capabilities.readOnly);
+    const streamingWrite = requireCapabilities(capabilities.write, capabilities.append, capabilities.streamingAppend, !capabilities.readOnly);
+    const streamingAppend = requireCapabilities(capabilities.append, capabilities.streamingAppend, !capabilities.readOnly);
     const { streamingWrite: ignoredWrite, streamingAppend: ignoredAppend, ...rest } = capabilities;
     return Object.freeze({ ...rest, synchronousStagingResolution: false, retainedStagingCleanup: false, retainedStagingWrite: false, atomicStagingAncestry: false, synchronousDirectoryValidation: false, guardedStagingPublication: false, atomicFilePublication: false, descriptorWriteStream: false, atomicResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicEntryRemovalReceipt: false, atomicFileStaging: false, atomicDirectoryMetadata: false, trustedOwnedStaging: false,
         ...(streamingWrite === undefined ? {} : { streamingWrite }),

package/node_modules/@poe-code/safe-fs/dist/fs/memory/atomic-view.d.ts

@@ -1,6 +1,7 @@
 import type { FileStat, FileSystem } from "../../contracts/filesystem.js";
 /** Internal authority: inspections and stock mutations share one JavaScript turn. */
 export interface MemoryAtomicView {
+    replaceContents(source: string, destination: string): void;
     stat(path: string): FileStat | undefined;
     names(path: string): readonly string[];
 }

package/node_modules/@poe-code/safe-fs/dist/fs/memory/index.js

@@ -656,6 +656,26 @@ export class MemoryFileSystem {
             }
         }
         return owner.atomicView ??= {
+            replaceContents: (source, destination) => {
+                const from = this.entry(source, "overlayAtomicView").node;
+                const to = this.entry(destination, "overlayAtomicView").node;
+                if (from?.type !== "file" || to?.type !== "file" || from === to || from.nlink !== 1)
+                    this.fail("EINVAL", "overlayAtomicView", destination);
+                this.permission(to, 2, "overlayAtomicView", destination);
+                // Exchange owned storage, preserving destination inode/hardlinks and
+                // retained allocation snapshots. Stage cleanup releases the old contents.
+                const allocation = to.allocation, length = to.byteLength;
+                to.allocation = from.allocation;
+                to.byteLength = from.byteLength;
+                from.allocation = allocation;
+                from.byteLength = length;
+                to.view = undefined;
+                from.view = undefined;
+                to.sourceRef = undefined;
+                from.sourceRef = undefined;
+                this.changed(to);
+                this.changed(from);
+            },
             stat: (path) => {
                 this.validatePath(path, "overlayAtomicView");
                 let node = this.root;

package/node_modules/@poe-code/safe-fs/dist/fs/overlay/index.d.ts

@@ -82,6 +82,7 @@ export declare class OverlayFileSystem implements FileSystem {
     readStream(path: string, options?: ReadStreamOptions): ByteSource;
     private bounded;
     private streamToUpper;
+    private entryBytes;
     writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
 }
 export declare function createOverlayFileSystem(options: OverlayFileSystemOptions): OverlayFileSystem;

package/node_modules/@poe-code/safe-fs/dist/fs/overlay/index.js

@@ -95,8 +95,8 @@ export class OverlayFileSystem {
             : readable.every((capability) => capability === false) ? false : undefined;
         const retainedRead = streamingRead;
         const streamingWrite = writable && this.#upper.capabilities.streamingWrite === true
-            && this.#upper.capabilities.streamingRead === true
-            && typeof this.#upper.writeStream === "function" && typeof this.#upper.readStream === "function"
+            && retainedReadCapabilities(this.#upper).retainedRead === true
+            && typeof this.#upper.writeStream === "function"
             ? readable.every((capability) => capability === true) ? true : undefined : false;
         const append = !writable || this.#upper.capabilities.append === false ? false
             : this.#upper.capabilities.append === true ? true : undefined;
@@ -117,8 +117,8 @@ export class OverlayFileSystem {
             ["rename", requireCapabilities(mutation, upper.rename, upper.write)],
             ["copy", requireCapabilities(mutation, upper.write)],
             ["exclusiveCopy", requireCapabilities(mutation, upper.exclusiveCreate)],
-            ["truncate", requireCapabilities(mutation, upper.truncate)],
-            ["streamingAppend", requireCapabilities(mutation, streamingWrite, upper.streamingAppend)],
+            ["truncate", requireCapabilities(mutation, streamingWrite)],
+            ["streamingAppend", requireCapabilities(mutation, streamingWrite)],
             ["randomAccessWrite", requireCapabilities(mutation, upper.randomAccessWrite)],
             ["explicitDirectories", requireCapabilities(upper.explicitDirectories, this.#lower.capabilities.explicitDirectories)],
         ].filter(([, value]) => value !== undefined));
@@ -578,7 +578,7 @@ export class OverlayFileSystem {
             fail("ENOTSUP", path, "upper cannot preserve timestamps during copy-up");
         await this.#upper.utimes(path, stat.atimeMs, stat.mtimeMs, options);
     }
-    async clone(entry, destination, options, streaming = false) {
+    async clone(entry, destination, options) {
         if (entry.stat.type !== "directory" && ((entry.stat.nlink ?? 1) > 1
             || (entry.backend.capabilities.hardlinks === true && entry.stat.nlink === undefined))) {
             fail("ENOTSUP", entry.path, "copy-up cannot preserve hardlink identity");
@@ -591,23 +591,14 @@ export class OverlayFileSystem {
         }
         if (entry.stat.type === "directory")
             await this.#upper.mkdir(destination, { ...options, mode: entry.stat.mode & 0o7777 });
-        else if (streaming && entry.backend.readStream && entry.backend.capabilities.streamingRead !== false && this.#upper.writeStream) {
+        else {
+            if (this.#upper.capabilities.streamingWrite !== true || !this.#upper.writeStream)
+                fail("ENOTSUP", destination, "copy-up requires a streaming upper");
             this.permission(entry, 4);
             if (entry.stat.size > this.maxBufferBytes)
                 fail("EFBIG", entry.path);
-            const handle = await this.pinRead(entry, options);
-            let failed = true;
-            try {
-                const source = this.bounded(this.handleBytes(handle, options), entry.path, options);
-                await this.streamToUpper(destination, source, { ...options, mode: 0o600, flag: "wx" });
-                failed = false;
-            }
-            finally {
-                await finishCleanup(() => handle.close(), failed);
-            }
+            await this.streamToUpper(destination, this.bounded(this.entryBytes(entry, options), entry.path, options), { ...options, mode: 0o600, flag: "wx" });
         }
-        else
-            await this.#upper.writeFile(destination, await this.bytes(entry, options), { ...options, mode: 0o600, flag: "wx" });
         await this.preserve(destination, entry.stat, options);
     }
     rememberLink(entry, destination) {
@@ -686,11 +677,11 @@ export class OverlayFileSystem {
         }
         return location;
     }
-    async replace(location, options, operation, streaming = false, commitGuard) {
+    async replace(location, options, operation, commitGuard) {
         await this.parent(location.path, options);
         await this.staged(options, async (temporary) => {
             if (location.entry)
-                await this.clone(location.entry, temporary, options, streaming);
+                await this.clone(location.entry, temporary, options);
             await operation(temporary);
             options.signal?.throwIfAborted();
             commitGuard?.();
@@ -983,9 +974,10 @@ export class OverlayFileSystem {
                 }
             }
             await this.cleanGarbage(false);
-            const bytes = await this.bytes(original, options);
+            if (original.stat.size > this.maxBufferBytes)
+                fail("EFBIG", source);
             await this.replace(target, options, async (temporary) => {
-                await this.#upper.writeFile(temporary, bytes, { ...options, mode: original.stat.mode & 0o7777, flag: "w" });
+                await this.streamToUpper(temporary, this.entryBytes(original, options), { ...options, mode: original.stat.mode & 0o7777, flag: "w" });
                 if (this.#upper.chmod)
                     await this.#upper.chmod(temporary, original.stat.mode & 0o7777, options);
                 else if (((await this.#upper.lstat(temporary, options)).mode & 0o7777) !== (original.stat.mode & 0o7777))
@@ -1057,7 +1049,7 @@ export class OverlayFileSystem {
                     await this.#upper.chmod(entry.path, permissions, controls);
                 }
                 else {
-                    await this.replace({ path: entry.path, entry }, controls, temporary => this.#upper.chmod(temporary, permissions, controls), false, guard);
+                    await this.replace({ path: entry.path, entry }, controls, temporary => this.#upper.chmod(temporary, permissions, controls), guard);
                 }
             });
         }
@@ -1079,15 +1071,30 @@ export class OverlayFileSystem {
             if (entry.stat.type !== "file")
                 fail("EISDIR", path);
             this.permission(entry, 2);
-            await this.replace({ path: entry.path, entry }, options, async (temporary) => {
-                if (this.#upper.truncate)
-                    await this.#upper.truncate(temporary, length, options);
-                else {
-                    const previous = await this.#upper.readFile(temporary, { ...options, ...(this.maxBufferBytes === Infinity ? {} : { maxBytes: this.maxBufferBytes }) });
-                    const bytes = new Uint8Array(length);
-                    bytes.set(previous.subarray(0, length));
-                    await this.#upper.writeFile(temporary, bytes, options);
-                }
+            if ((entry.stat.nlink ?? 1) > 1 || (entry.backend.capabilities.hardlinks === true && entry.stat.nlink === undefined)) {
+                fail("ENOTSUP", path, "copy-up cannot preserve hardlink identity");
+            }
+            await this.parent(entry.path, options);
+            await this.staged(options, async (temporary) => {
+                const prefix = this.entryBytes(entry, { ...options, endExclusive: length });
+                const source = async function* () {
+                    let written = 0;
+                    for await (const chunk of prefix) {
+                        written += chunk.byteLength;
+                        yield chunk;
+                    }
+                    while (written < length) {
+                        options.signal?.throwIfAborted();
+                        const zero = new Uint8Array(Math.min(64 * 1024, length - written));
+                        written += zero.byteLength;
+                        yield zero;
+                    }
+                };
+                await this.streamToUpper(temporary, source(), { ...options, mode: 0o600, flag: "wx" });
+                await this.preserve(temporary, entry.stat, options);
+                await this.#upper.utimes(temporary, entry.stat.atimeMs, Date.now(), options);
+                options.signal?.throwIfAborted();
+                await this.#upper.rename(temporary, entry.path, options);
             });
         });
     }
@@ -1130,7 +1137,7 @@ export class OverlayFileSystem {
         }
     }
     async streamToUpper(path, source, options) {
-        if (!this.#upper.writeStream)
+        if (!this.#upper.writeStream || this.#upper.capabilities.streamingWrite !== true)
             fail("ENOTSUP", path);
         const input = readBytes(source, options.signal);
         let failed = false;
@@ -1145,39 +1152,74 @@ export class OverlayFileSystem {
             await finishCleanup(() => input.return(undefined), failed);
         }
     }
+    async *entryBytes(entry, options) {
+        this.permission(entry, 4);
+        const handle = this.activeStages.has(dirname(entry.path)) && entry.backend === this.#upper
+            ? await openRetainedReadFile(this.#upper, entry.path, options) : await this.pinRead(entry, options);
+        let failed = true;
+        try {
+            if (compareIdentity(await handle.stat(options), entry.stat) !== "same")
+                fail("EAGAIN", entry.path);
+            yield* this.handleBytes(handle, options);
+            failed = false;
+        }
+        finally {
+            await finishCleanup(() => handle.close(), failed);
+        }
+    }
     async writeStream(path, source, options = {}) {
         options.signal?.throwIfAborted();
         this.writeOptions(path, options);
+        if (this.capabilities.streamingWrite === false)
+            fail("ENOTSUP", path, "streaming requires retained reads and a streaming upper");
         await this.run(options, () => this.writeLocation(path, options));
-        if (this.capabilities.streamingWrite !== false) {
-            await this.staged(options, async (incoming) => {
-                const bounded = this.bounded(source, path, options);
-                await this.streamToUpper(incoming, bounded, { ...options, flag: "wx", mode: 0o600 });
-                const size = (await this.#upper.stat(incoming, options)).size;
-                await this.run(options, async () => {
-                    const location = await this.writeLocation(path, options);
-                    const append = options.flag === "a" || options.flag === "ax";
-                    if (append && (location.entry?.stat.size ?? 0) + size > this.maxBufferBytes)
-                        fail("EFBIG", path);
-                    if (this.publication.supported() && location.entry?.backend === this.#upper) {
-                        const bytes = await this.#upper.readFile(incoming, options);
-                        const parent = await this.required(dirname(location.path), options);
-                        await this.publication.writeFile(location.path, bytes, {
-                            ...options, parent: this.publication.stat(parent.path, parent.stat),
-                            expected: this.publication.stat(location.path, location.entry.stat), append,
-                        }, this.maxBufferBytes);
+        await this.staged(options, async (incoming) => {
+            await this.streamToUpper(incoming, this.bounded(source, path, options), { ...options, flag: "wx", mode: 0o600 });
+            const incomingEntry = { path: incoming, backend: this.#upper, stat: await this.#upper.lstat(incoming, options) };
+            await this.run(options, async () => {
+                const location = await this.writeLocation(path, options);
+                const append = options.flag === "a" || options.flag === "ax";
+                if (append && (location.entry?.stat.size ?? 0) + incomingEntry.stat.size > this.maxBufferBytes)
+                    fail("EFBIG", path);
+                if (this.publication.supported() && location.entry?.backend === this.#upper) {
+                    const parent = await this.required(dirname(location.path), options);
+                    const controls = { ...options, parent: this.publication.stat(parent.path, parent.stat),
+                        expected: this.publication.stat(location.path, location.entry.stat) };
+                    const guard = this.publication.prepareWrite(location.path, controls);
+                    if (append) {
+                        await this.staged(options, async (temporary) => {
+                            const previous = this.entryBytes(location.entry, options);
+                            const added = this.entryBytes(incomingEntry, options);
+                            await this.streamToUpper(temporary, (async function* () { yield* previous; yield* added; })(), { ...options, flag: "wx", mode: 0o600 });
+                            this.publication.replaceContents(temporary, location.path, guard);
+                        });
                     }
-                    else {
-                        await this.replace(location, options, async (temporary) => {
-                            await this.streamToUpper(temporary, this.#upper.readStream(incoming, options), { ...options, flag: append ? "a" : "w" });
-                        }, true);
+                    else
+                        this.publication.replaceContents(incoming, location.path, guard);
+                }
+                else {
+                    if (location.entry && ((location.entry.stat.nlink ?? 1) > 1
+                        || (location.entry.backend.capabilities.hardlinks === true && location.entry.stat.nlink === undefined))) {
+                        fail("ENOTSUP", path, "copy-up cannot preserve hardlink identity");
                     }
-                });
+                    await this.parent(location.path, options);
+                    await this.staged(options, async (temporary) => {
+                        const previous = append && location.entry ? this.entryBytes(location.entry, options) : undefined;
+                        const added = this.entryBytes(incomingEntry, options);
+                        await this.streamToUpper(temporary, (async function* () { if (previous)
+                            yield* previous; yield* added; })(), { ...options, flag: "wx", mode: location.entry ? 0o600 : options.mode ?? 0o666 });
+                        if (location.entry) {
+                            await this.preserve(temporary, location.entry.stat, options);
+                            await this.#upper.utimes(temporary, location.entry.stat.atimeMs, Date.now(), options);
+                        }
+                        options.signal?.throwIfAborted();
+                        await this.#upper.rename(temporary, location.path, options);
+                        this.linkMetadata.delete(location.path);
+                        this.linkOrigins.delete(location.path);
+                    });
+                }
             });
-            return;
-        }
-        const bytes = await collectBytes(source, { ...(this.maxBufferBytes === Infinity ? {} : { maxBytes: this.maxBufferBytes }), ...(options.signal ? { signal: options.signal } : {}) });
-        await this.writeFile(path, bytes, options);
+        });
     }
 }
 export function createOverlayFileSystem(options) {

package/node_modules/@poe-code/safe-fs/dist/fs/overlay/memory-publication.d.ts

@@ -29,6 +29,7 @@ export declare class OverlayMemoryPublication {
     private check;
     prepareChmod(path: string, options: ChmodOptions): (() => true) | undefined;
     prepareWrite(path: string, options: ConditionalWriteFileOptions): () => true;
+    replaceContents(source: string, destination: string, guard: () => true): void;
     writeFile(path: string, data: Uint8Array, options: ConditionalWriteFileOptions, maxBytes: number, guard?: () => void): Promise<FileStat>;
     removeFile(path: string, options: ConditionalRemoveFileOptions): Promise<void>;
     prepareDirectory(path: string, options: PrepareDirectoryOptions, guard?: () => void): Promise<FileStat>;

package/node_modules/@poe-code/safe-fs/dist/fs/overlay/memory-publication.js

@@ -203,6 +203,11 @@ export class OverlayMemoryPublication {
             return true;
         };
     }
+    replaceContents(source, destination, guard) {
+        const { upper } = this.stores();
+        guard();
+        upper.replaceContents(source, destination);
+    }
     async writeFile(path, data, options, maxBytes, guard) {
         const check = this.prepareWrite(path, options);
         check();

package/node_modules/@poe-code/safe-fs/dist/fs/quota/index.js

@@ -1,5 +1,6 @@
 import { FsError } from "../../contracts/errors.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
+import { readBytes } from "../../contracts/io.js";
 import { openRetainedReadFile, openRetainedResizeFile, quotaCapabilities, retainedReadCapabilities, retainedResizeCapabilities } from "../capabilities.js";
 import { admitDirectoryEntries } from "../directory-admission.js";
 import { forwardFileDescriptor, openFileDescriptor } from "../descriptor.js";
@@ -485,12 +486,16 @@ export function withFileSystemQuota(fs, options) {
         },
         writeStream(path, source, writeOptions) {
             return mutate(async () => {
+                if (fs.capabilities.streamingAppend !== true || !fs.writeStream)
+                    throw new FsError("ENOTSUP", { syscall: "writeStream", path });
                 const append = writeOptions?.flag === "a" || writeOptions?.flag === "ax";
                 if (!append)
                     await fs.writeFile(path, new Uint8Array(), writeOptions);
-                for await (const chunk of source) {
+                else
+                    await fs.writeStream(path, (async function* () { })(), writeOptions);
+                for await (const chunk of readBytes(source, writeOptions?.signal)) {
                     await assertDelta(path, await existingBytes(fs, path, writeOptions) + chunk.length, writeOptions);
-                    await fs.appendFile(path, chunk, writeOptions);
+                    await fs.writeStream(path, (async function* () { yield chunk; })(), { ...writeOptions, flag: "a" });
                 }
             });
         },
@@ -502,11 +507,11 @@ export function withFileSystemQuota(fs, options) {
             if (property === "publishStagedFileSet" || property === "prepareStagingResolution" || property === "prepareDirectoryAncestry" || property === "publishFileConditional" || property === "removeEntryConditional" || property === "writeFileConditional" || property === "removeFileConditional" || property === "resizeFile" || property === "canonicalizeMissingTarget" || property === "createStagedFile" || property === "publishStagedFile" || property === "removeStagedFile" || property === "prepareDirectory")
                 return undefined;
             if (property === "capabilities")
-                return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs)), ...(typeof fs.open === "function" ? {} : { open: false }) });
+                return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs)), ...(typeof fs.open === "function" ? {} : { open: false }), ...(typeof fs.writeStream === "function" ? {} : { streamingAppend: false }) });
             if (property === "capabilitiesFor")
                 return async (path, fsOptions) => {
                     const capabilities = await fs.capabilitiesFor?.(path, fsOptions) ?? fs.capabilities;
-                    return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs, capabilities)), ...(typeof fs.open === "function" ? {} : { open: false }) });
+                    return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs, capabilities)), ...(typeof fs.open === "function" ? {} : { open: false }), ...(typeof fs.writeStream === "function" ? {} : { streamingAppend: false }) });
                 };
             if (property === "openReadFile")
                 return (path, fsOptions = {}) => openRetainedReadFile(fs, path, fsOptions);

package/node_modules/@poe-code/safe-fs/dist/fs/s3/filesystem.d.ts

@@ -53,7 +53,7 @@ export declare class S3FileSystem implements FileSystem {
         truncate: boolean;
         atomicRenameNoReplace: false;
         rename: boolean;
-        streamingAppend: boolean;
+        streamingAppend: false;
         randomAccessWrite: false;
         readOnly: boolean;
         symlinks: false;

package/node_modules/@poe-code/safe-fs/dist/fs/s3/filesystem.js

@@ -152,8 +152,8 @@ export class S3FileSystem {
             atomicRenameNoReplace: false,
             rename: this.allowRename && options.transport.capabilities?.conditionalDelete === true
                 && (options.transport.capabilities?.conditionalCopy === true || options.transport.capabilities?.conditionalPut === true),
-            streamingAppend: options.transport.capabilities?.streamingWrite === true
-                && options.transport.capabilities?.conditionalPut === true && typeof options.transport.putObjectStream === "function",
+            // Conditional append currently collects the old and incoming bodies.
+            streamingAppend: false,
             randomAccessWrite: false,
             readOnly: options.readOnly ?? false,
             symlinks: false, hardlinks: false, permissions: false,

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.759",
+      "version": "0.0.760",
       "license": "MIT"
     }
   ]

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.759",
+  "version": "0.0.760",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.759",
+  "version": "0.0.760",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -175,7 +175,7 @@
     "@poe-code/terminal-text"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.759",
+    "toolcraft-schema": "0.0.760",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",