toolcraft 0.0.795 → 0.0.797

package/composition.json

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

package/dist/composition.json

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

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

@@ -15,6 +15,9 @@ To bound aggregate pages across multiple live stores, pass the same
 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.
+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.
 `IntegerTable.entries()` replays records in unsigned key order with a fixed
 16-level node stack and batches of at most 128 records. It accepts zero-filled
 caller storage with `allocate`, `read` and `write`; mutation during traversal

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

@@ -9,7 +9,7 @@ export * from "./fs/webdav/index.js";
 export * from "./bridge/index.js";
 export * from "./python/index.js";
 export { parseXml, parseXmlSteps, parseXmlSourceSteps, normalizeXmlChunks, parseXmlStream, XmlLimitError } from "./xml.js";
-export type { XmlName, XmlAttribute, XmlContent, XmlElement, XmlLimits, XmlParserFrame, XmlFrameRequest } from "./xml.js";
+export type { XmlName, XmlAttribute, XmlContent, XmlElement, XmlLimits, XmlParserFrame, XmlFrameRequest, XmlNamespaceScope, XmlNamespaceRequest } from "./xml.js";
 export * from "./contracts/object.js";
 export { ObjectAuthority } from "./fs/object-authority.js";
 export * from "./fs/s3/index.js";

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

@@ -44,6 +44,8 @@ export declare class PagedStorage {
     private closing;
     constructor(context: PagedStorageContext, maxPages?: number, cache?: PagedStorageCache | undefined);
     allocate(length: number): number;
+    /** Acquire and unlink backing storage before observing a directory snapshot. */
+    prepare(): Promise<void>;
     private operation;
     private spill;
     private flush;

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

@@ -73,6 +73,11 @@ export class PagedStorage {
         this.end += length;
         return offset;
     }
+    /** Acquire and unlink backing storage before observing a directory snapshot. */
+    async prepare() {
+        await this.operation(async () => { if (!this.descriptor)
+            await this.spill(); });
+    }
     operation(action) {
         this.signal.throwIfAborted();
         const execute = () => {

package/node_modules/@poe-code/xml-ast/README.md

@@ -62,6 +62,16 @@ metadata. Keep the host stack in bounded backing storage. The parser caches one
 current frame; individual frame metadata and namespace scopes still have their own
 size cost. The default string and stream APIs retain their existing ancestry behavior.
 
+Also set `storeNamespaces: true` to resolve namespace scopes through host-backed
+immutable storage. `namespaceOperation: "get"` supplies a scope and prefix; fill
+`value` when present and set `complete: true`. For `"set"`, bind the supplied prefix
+and value in a new scope, then fill `result` with its storage `reference` and the
+number of distinct bindings (`size`). Frames carry this scope handle so shadowing
+never changes ancestor scopes. In this mode event elements have an empty
+`namespaces` map; their names and attributes still carry resolved namespace URIs.
+The codec remains filesystem-independent, and individual names, attribute values
+and namespace URIs still need a token storage strategy.
+
 Pass `undefined` as the source length to parse incrementally. Such read requests
 have `streaming: true` and request at most 512 UTF-16 units. Return any nonempty
 prefix available without pulling more input; set `complete: true` only when that

package/node_modules/@poe-code/xml-ast/dist/frames.d.ts

@@ -4,6 +4,7 @@ export interface XmlParserFrame {
     content: XmlContent[] | undefined;
     name: string;
     namespaces: Map<string, string>;
+    namespaceScope?: XmlNamespaceScope;
 }
 export type XmlFrameRequest = {
     readonly frameOperation: 'push';
@@ -26,3 +27,23 @@ export declare class XmlFrames {
     push(frame: XmlParserFrame): Generator<XmlFrameRequest, void, void>;
     pop(): Generator<XmlFrameRequest, XmlParserFrame | undefined, void>;
 }
+/** A host-owned immutable namespace scope; count includes the built-in xml prefix. */
+export interface XmlNamespaceScope {
+    readonly reference: number;
+    readonly size: number;
+}
+export type XmlNamespaceRequest = {
+    readonly namespaceOperation: 'get';
+    readonly scope: XmlNamespaceScope;
+    readonly prefix: string;
+    value?: string;
+    complete?: true;
+} | {
+    readonly namespaceOperation: 'set';
+    readonly scope: XmlNamespaceScope;
+    readonly prefix: string;
+    readonly value: string;
+    result?: XmlNamespaceScope;
+};
+export declare function namespaceValue(scope: Map<string, string> | XmlNamespaceScope, prefix: string): Generator<XmlNamespaceRequest, string | undefined, void>;
+export declare function bindNamespace(scope: Map<string, string> | XmlNamespaceScope, prefix: string, value: string): Generator<XmlNamespaceRequest, Map<string, string> | XmlNamespaceScope, void>;

package/node_modules/@poe-code/xml-ast/dist/frames.js

@@ -43,3 +43,23 @@ export class XmlFrames {
         return frame;
     }
 }
+export function* namespaceValue(scope, prefix) {
+    if (scope instanceof Map)
+        return scope.get(prefix);
+    const request = { namespaceOperation: 'get', scope, prefix };
+    yield request;
+    if (!request.complete)
+        throw new TypeError('Incomplete XML namespace read');
+    return request.value;
+}
+export function* bindNamespace(scope, prefix, value) {
+    if (scope instanceof Map) {
+        scope.set(prefix, value);
+        return scope;
+    }
+    const request = { namespaceOperation: 'set', scope, prefix, value };
+    yield request;
+    if (!request.result)
+        throw new TypeError('Incomplete XML namespace update');
+    return request.result;
+}

package/node_modules/@poe-code/xml-ast/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { type XmlFrameRequest } from "./frames.js";
-export type { XmlParserFrame, XmlFrameRequest } from "./frames.js";
+import { type XmlNamespaceRequest, type XmlFrameRequest } from "./frames.js";
+export type { XmlParserFrame, XmlFrameRequest, XmlNamespaceScope, XmlNamespaceRequest } from "./frames.js";
 export { normalizeXmlChunks } from "./characters.js";
 import { type XmlSourceStep } from "./source.js";
 export type { XmlSourceRead, XmlSourceStep } from "./source.js";
@@ -61,11 +61,14 @@ export interface XmlSourceLimits extends XmlStepLimits {
     readonly fragmentContent?: boolean;
     /** Store active parser frames through host-serviced requests. Requires retainTree: false. */
     readonly storeFrames?: boolean;
+    /** Resolve namespace scopes through host-serviced requests. Requires retainTree: false. */
+    readonly storeNamespaces?: boolean;
 }
-export type XmlParseStep = XmlSourceStep | XmlFrameRequest;
+export type XmlParseStep = XmlSourceStep | XmlFrameRequest | XmlNamespaceRequest;
 /** Parse a validated, BOM-free, line-normalized UTF-16 source via bounded read requests. */
 export declare function parseXmlSourceSteps(length: number | undefined, limits?: XmlStepLimits & {
     readonly storeFrames?: false;
+    readonly storeNamespaces?: false;
 }): Generator<XmlSourceStep, XmlElement, void>;
 export declare function parseXmlSourceSteps(length: number | undefined, limits: XmlSourceLimits): Generator<XmlParseStep, XmlElement, void>;
 export declare function parseXmlSteps(input: string, limits?: XmlStepLimits): Generator<number, XmlElement, void>;

package/node_modules/@poe-code/xml-ast/dist/index.js

@@ -1,4 +1,4 @@
-import { XmlFrames } from "./frames.js";
+import { XmlFrames, bindNamespace, namespaceValue } from "./frames.js";
 import { validCharacter } from "./characters.js";
 export { normalizeXmlChunks } from "./characters.js";
 import { XmlSource } from "./source.js";
@@ -255,6 +255,8 @@ export function* parseXmlSourceSteps(length, limits = {}) {
     validateLimits(limits);
     if (limits.storeFrames && limits.retainTree !== false)
         throw new TypeError("Stored XML frames require retainTree: false");
+    if (limits.storeNamespaces && limits.retainTree !== false)
+        throw new TypeError("Stored XML namespaces require retainTree: false");
     if (limits.fragmentContent && limits.retainTree !== false)
         throw new TypeError("XML content fragments require retainTree: false");
     const source = new XmlSource(length);
@@ -277,6 +279,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
         textLength += text.length;
     };
+    const initialNamespaces = limits.storeNamespaces ? yield* bindNamespace({ reference: 0, size: 0 }, "xml", xmlNamespace) : new Map([["xml", xmlNamespace]]);
     const stack = new XmlFrames(limits.storeFrames === true);
     let root;
     const prolog = [];
@@ -554,7 +557,8 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             }
             let attributes;
             const attrMeta = [];
-            let namespaces = (yield* stack.peek())?.namespaces ?? new Map([["xml", xmlNamespace]]);
+            const namespaceParent = yield* stack.peek();
+            let namespaces = namespaceParent?.namespaceScope ?? namespaceParent?.namespaces ?? (initialNamespaces instanceof Map ? new Map(initialNamespaces) : initialNamespaces);
             let ownsNamespaces = stack.length === 0;
             while (!repeated) {
                 const ws = (yield* skipWhitespace());
@@ -618,7 +622,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                         || (nsPrefix === "xml") !== (value === xmlNamespace)
                         || (nsPrefix !== "" && value === ""))
                         invalid("invalid namespace binding");
-                    if (!ownsNamespaces) {
+                    if (!ownsNamespaces && namespaces instanceof Map) {
                         const copy = new Map();
                         for (const [key, uri] of namespaces) {
                             copy.set(key, uri);
@@ -627,7 +631,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                         namespaces = copy;
                         ownsNamespaces = true;
                     }
-                    namespaces.set(nsPrefix, value);
+                    namespaces = yield* bindNamespace(namespaces, nsPrefix, value);
                     if (namespaces.size > maxNamespaces)
                         throw new XmlLimitError("maxNamespaces", "XML namespace scope limit exceeded");
                 }
@@ -639,10 +643,10 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     if (attribute === "xmlns" || attribute.startsWith("xmlns:"))
                         continue;
                     pendingWork += attribute.length;
-                    if (attrPrefix && !namespaces.has(attrPrefix))
+                    if (attrPrefix && (yield* namespaceValue(namespaces, attrPrefix)) === undefined)
                         invalid("unbound attribute prefix");
                     if (expanded) {
-                        const key = `${attrPrefix ? namespaces.get(attrPrefix) : ""}\0${attrLocal}`;
+                        const key = `${attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : ""}\0${attrLocal}`;
                         if (expanded.has(key))
                             invalid("duplicate expanded attribute");
                         expanded.add(key);
@@ -654,13 +658,13 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 yield 512;
                 pendingWork -= 512;
             }
-            if (prefix === "xmlns" || (prefix && !namespaces.has(prefix)))
+            if (prefix === "xmlns" || (prefix && (yield* namespaceValue(namespaces, prefix)) === undefined))
                 invalid("unbound element prefix");
             if (++nodes > maxNodes)
                 throw new XmlLimitError("maxNodes", "XML resource limit exceeded");
             if (stack.length + 1 > maxDepth)
                 throw new XmlLimitError("maxDepth", "XML resource limit exceeded");
-            const namespace = namespaces.get(prefix) ?? "";
+            const namespace = (yield* namespaceValue(namespaces, prefix)) ?? "";
             limits.onElement?.({ name, namespace, localName }, (yield* stack.peek())?.element, stack.length + 1);
             admitContent();
             const retainedAttributes = [];
@@ -670,7 +674,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     const value = attributes.get(attribute);
                     admitContent();
                     retainedAttributes.push({ name: attribute, localName: attrLocal,
-                        namespace: attribute === "xmlns" || attrPrefix === "xmlns" ? xmlnsNamespace : attrPrefix ? namespaces.get(attrPrefix) : "", value });
+                        namespace: attribute === "xmlns" || attrPrefix === "xmlns" ? xmlnsNamespace : attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : "", value });
                     pendingWork += attribute.length + 1;
                 }
             }
@@ -679,7 +683,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 pendingWork -= 512;
             }
             const content = retain ? [] : undefined;
-            const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent ? namespaces : emptyNamespaces, ...(root === undefined && retainContent ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
+            const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent && namespaces instanceof Map ? namespaces : emptyNamespaces, ...(root === undefined && retainContent ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
             const parent = (yield* stack.peek());
             if (parent) {
                 if (retainTree) {
@@ -705,7 +709,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 previousEmpty = { suffix: name + "/>", name, prefix, localName };
             limits.events?.({ type: "open", element, parent: parent?.element });
             if (!empty)
-                yield* stack.push({ element, content, name, namespaces });
+                yield* stack.push({ element, content, name, namespaces: namespaces instanceof Map ? namespaces : new Map(), ...(namespaces instanceof Map ? {} : { namespaceScope: namespaces }) });
             else
                 limits.events?.({ type: "close", element, parent: parent?.element });
         }

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

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

package/node_modules/toolcraft-schema/package.json

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

package/package.json

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