toolcraft 0.0.881 → 0.0.883

package/composition.json

@@ -138,7 +138,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.881",
+      "version": "0.0.883",
       "license": "MIT"
     },
     {
@@ -148,7 +148,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.881",
+      "version": "0.0.883",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -138,7 +138,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.881",
+      "version": "0.0.883",
       "license": "MIT"
     },
     {
@@ -148,7 +148,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.881",
+      "version": "0.0.883",
       "license": "MIT"
     },
     {

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

@@ -14,7 +14,10 @@ To bound aggregate pages across multiple live stores, pass the same
 `new PagedStorageCache(16)` as the third argument to each `PagedStorage` constructor.
 This shares a 256 KiB resident-page budget; `cache.residentBytes` reports current
 page retention. Eviction uses each store's filesystem, and each store still owns
-its `close()` cleanup. The budget excludes caller buffers and backend storage.
+its `close()` cleanup. Use `new PagedStorageCache(16, 65536)` to coalesce scratch
+I/O into 64 KiB pages within a 1 MiB budget, for example with object-backed files.
+Page sizes must be multiples of 16 KiB, up to 1 MiB; individual `read()` calls
+remain limited to 16 KiB. The budget excludes caller buffers and backend storage.
 Call `await storage.prepare()` before opening a directory iterator when its
 snapshot includes the scratch directory. It acquires and unlinks the backing
 handle up front, so later spills do not mutate that directory's namespace.

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

@@ -20,6 +20,7 @@ export interface ObjectFileAcquireOptions extends FsOptions {
 }
 export interface ObjectFileStaging {
     readPage(index: number, options?: FsOptions): Promise<Uint8Array | undefined>;
+    /** Own acknowledged bytes; the caller may reuse its buffer after settlement. */
     writePage(index: number, bytes: Uint8Array, options?: FsOptions): Promise<void>;
     truncate(size: number, options?: FsOptions): Promise<void>;
     close(): Promise<void>;

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

@@ -296,13 +296,16 @@ export function withObjectFileDescriptors(filesystem, store, options = {}) {
                                     const page = Math.floor(offset / chunkBytes);
                                     const within = offset % chunkBytes;
                                     const length = Math.min(buffer.byteLength - copied, chunkBytes - within);
-                                    let bytes = within === 0 && length === chunkBytes ? undefined : await readStagedPage(page, forwarded);
+                                    const complete = within === 0 && length === chunkBytes;
+                                    // Staging owns acknowledged bytes. Borrow the caller's complete
+                                    // page until writePage settles instead of allocating another copy.
+                                    let bytes = complete ? buffer.subarray(copied, copied + length) : await readStagedPage(page, forwarded);
                                     if (!bytes) {
                                         bytes = new Uint8Array(chunkBytes);
-                                        if (within !== 0 || length !== chunkBytes)
-                                            bytes.set(await readBase(page * chunkBytes, chunkBytes, forwarded));
+                                        bytes.set(await readBase(page * chunkBytes, chunkBytes, forwarded));
                                     }
-                                    bytes.set(buffer.subarray(copied, copied + length), within);
+                                    if (!complete)
+                                        bytes.set(buffer.subarray(copied, copied + length), within);
                                     await perform(forwarded, selected => state.staging.writePage(page, bytes, selected));
                                     copied += length;
                                 }

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

@@ -13,9 +13,10 @@ type Page = {
  * filesystem and cleanup ownership. Serializes cache users through eviction IO. */
 export declare class PagedStorageCache {
     private readonly maxPages;
+    readonly pageBytes: number;
     private readonly pages;
     private active;
-    constructor(maxPages: number);
+    constructor(maxPages: number, pageBytes?: number);
     get residentBytes(): number;
     run<T>(action: () => Promise<T>): Promise<T>;
     acquire(): Promise<Page>;
@@ -31,6 +32,7 @@ export declare class PagedStorage {
     private readonly maxPages;
     private readonly cache?;
     private readonly pages;
+    private readonly pageBytes;
     private readonly controller;
     private readonly signal;
     private descriptor;

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

@@ -1,18 +1,22 @@
 import { FsError, isFsError } from "./contracts/errors.js";
-const pageBytes = 16 * 1024;
+const defaultPageBytes = 16 * 1024;
 let serial = 0;
 /** Shares one resident-page limit across stores, retaining each store's caller
  * filesystem and cleanup ownership. Serializes cache users through eviction IO. */
 export class PagedStorageCache {
     maxPages;
+    pageBytes;
     pages = new Map();
     active = Promise.resolve();
-    constructor(maxPages) {
+    constructor(maxPages, pageBytes = defaultPageBytes) {
         this.maxPages = maxPages;
+        this.pageBytes = pageBytes;
+        if (!Number.isSafeInteger(pageBytes) || pageBytes < defaultPageBytes || pageBytes > 1024 * 1024 || pageBytes % defaultPageBytes !== 0)
+            throw new RangeError("Invalid storage page size");
         if (!Number.isSafeInteger(maxPages) || maxPages < 1)
             throw new RangeError("Invalid storage page cache size");
     }
-    get residentBytes() { return this.pages.size * pageBytes; }
+    get residentBytes() { return this.pages.size * this.pageBytes; }
     run(action) {
         const work = this.active.then(action);
         this.active = work.then(() => undefined, () => undefined);
@@ -20,7 +24,7 @@ export class PagedStorageCache {
     }
     async acquire() {
         if (this.pages.size < this.maxPages)
-            return { bytes: new Uint8Array(pageBytes), dirty: false };
+            return { bytes: new Uint8Array(this.pageBytes), dirty: false };
         const [page, release] = this.pages.entries().next().value;
         await release();
         this.pages.delete(page);
@@ -46,6 +50,7 @@ export class PagedStorage {
     maxPages;
     cache;
     pages = new Map();
+    pageBytes;
     controller = new AbortController();
     signal;
     descriptor;
@@ -63,6 +68,7 @@ export class PagedStorage {
         this.cache = cache;
         if (!Number.isSafeInteger(maxPages) || maxPages < 1)
             throw new RangeError("Invalid storage page cache size");
+        this.pageBytes = cache?.pageBytes ?? defaultPageBytes;
         this.signal = AbortSignal.any([context.signal, this.controller.signal]);
     }
     allocate(length) {
@@ -129,15 +135,15 @@ export class PagedStorage {
         if (!page.dirty)
             return;
         let offset = 0;
-        while (offset < pageBytes) {
+        while (offset < this.pageBytes) {
             this.signal.throwIfAborted();
-            const count = await this.descriptor.write(page.bytes.subarray(offset), number * pageBytes + offset, { signal: this.signal });
+            const count = await this.descriptor.write(page.bytes.subarray(offset), number * this.pageBytes + offset, { signal: this.signal });
             this.signal.throwIfAborted();
-            if (!Number.isSafeInteger(count) || count <= 0 || count > pageBytes - offset)
+            if (!Number.isSafeInteger(count) || count <= 0 || count > this.pageBytes - offset)
                 throw new FsError("EIO");
             offset += count;
         }
-        this.diskLength = Math.max(this.diskLength, (number + 1) * pageBytes);
+        this.diskLength = Math.max(this.diskLength, (number + 1) * this.pageBytes);
         page.dirty = false;
     }
     async page(number) {
@@ -161,17 +167,17 @@ export class PagedStorage {
         }
         // Flush owns the bytes until its awaited write completes. Reuse only then;
         // zero new/unwritten ranges so the previous page cannot leak into them.
-        const page = reusable ?? (this.cache ? await this.cache.acquire() : { bytes: new Uint8Array(pageBytes), dirty: false });
+        const page = reusable ?? (this.cache ? await this.cache.acquire() : { bytes: new Uint8Array(this.pageBytes), dirty: false });
         // Shared eviction may await IO owned by a different, still-live signal.
         this.signal.throwIfAborted();
         if (reusable)
             page.bytes.fill(0);
-        if (number * pageBytes < this.diskLength) {
+        if (number * this.pageBytes < this.diskLength) {
             let offset = 0;
-            while (offset < pageBytes) {
-                const count = await this.descriptor.read(page.bytes.subarray(offset), number * pageBytes + offset, { signal: this.signal });
+            while (offset < this.pageBytes) {
+                const count = await this.descriptor.read(page.bytes.subarray(offset), number * this.pageBytes + offset, { signal: this.signal });
                 this.signal.throwIfAborted();
-                if (!Number.isSafeInteger(count) || count <= 0 || count > pageBytes - offset)
+                if (!Number.isSafeInteger(count) || count <= 0 || count > this.pageBytes - offset)
                     throw new FsError("EIO");
                 offset += count;
             }
@@ -191,9 +197,9 @@ export class PagedStorage {
         return this.operation(async () => {
             for (let offset = 0; offset < bytes.length;) {
                 const target = position + offset;
-                const page = await this.page(Math.floor(target / pageBytes));
-                const count = Math.min(bytes.length - offset, pageBytes - target % pageBytes);
-                page.bytes.set(bytes.subarray(offset, offset + count), target % pageBytes);
+                const page = await this.page(Math.floor(target / this.pageBytes));
+                const count = Math.min(bytes.length - offset, this.pageBytes - target % this.pageBytes);
+                page.bytes.set(bytes.subarray(offset, offset + count), target % this.pageBytes);
                 page.dirty = true;
                 offset += count;
             }
@@ -205,15 +211,15 @@ export class PagedStorage {
         return position;
     }
     read(position, length) {
-        if (!Number.isSafeInteger(position) || position < 8 || !Number.isSafeInteger(length) || length < 0 || length > pageBytes || position + length > this.end)
+        if (!Number.isSafeInteger(position) || position < 8 || !Number.isSafeInteger(length) || length < 0 || length > defaultPageBytes || position + length > this.end)
             throw new RangeError("Invalid paged storage range");
         return this.operation(async () => {
             const bytes = new Uint8Array(length);
             for (let offset = 0; offset < length;) {
                 const source = position + offset;
-                const page = await this.page(Math.floor(source / pageBytes));
-                const count = Math.min(length - offset, pageBytes - source % pageBytes);
-                bytes.set(page.bytes.subarray(source % pageBytes, source % pageBytes + count), offset);
+                const page = await this.page(Math.floor(source / this.pageBytes));
+                const count = Math.min(length - offset, this.pageBytes - source % this.pageBytes);
+                bytes.set(page.bytes.subarray(source % this.pageBytes, source % this.pageBytes + count), offset);
                 offset += count;
             }
             return bytes;

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

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

package/node_modules/toolcraft-schema/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.881",
+  "version": "0.0.883",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -177,7 +177,7 @@
     "saxes"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.881",
+    "toolcraft-schema": "0.0.883",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",