toolcraft 0.0.789 → 0.0.790

package/composition.json

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

package/dist/composition.json

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

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 } from "./xml.js";
+export type { XmlName, XmlAttribute, XmlContent, XmlElement, XmlLimits, XmlParserFrame, XmlFrameRequest } 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/xml-ast/README.md

@@ -54,3 +54,18 @@ limits)`: numbers are work checkpoints; read requests specify UTF-16 `offset` an
 iterator. The source must already be validated and normalized. This supports the
 same repairs and events without a complete source string; tokens and open ancestry
 still remain resident. Close the iterator and backing on errors or cancellation.
+
+For tree-free external parsing, set `storeFrames: true` alongside `retainTree: false`.
+The iterator also yields `frameOperation` requests: `push` saves the supplied frame,
+`pop` removes the latest frame, and `peek` needs its `frame` filled with the saved
+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.
+
+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
+read reaches EOF (an empty EOF read is valid). Earlier offsets may be requested
+again, so retain source spans in caller-backed storage. With `normalizeXmlChunks`,
+pass `true` as the second argument to flush at input-chunk boundaries and preserve
+early parser failures. The string parser and known-length protocol are unchanged.

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

@@ -1,3 +1,3 @@
 export declare function validCharacter(point: number): boolean;
 /** Validate scalar values and normalize XML line endings in fixed windows. */
-export declare function normalizeXmlChunks(source: AsyncIterable<string> | Iterable<string>): AsyncGenerator<string>;
+export declare function normalizeXmlChunks(source: AsyncIterable<string> | Iterable<string>, flushChunks?: boolean): AsyncGenerator<string>;

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

@@ -5,7 +5,7 @@ export function validCharacter(point) {
         || (point >= 0x10000 && point <= 0x10ffff);
 }
 /** Validate scalar values and normalize XML line endings in fixed windows. */
-export async function* normalizeXmlChunks(source) {
+export async function* normalizeXmlChunks(source, flushChunks = false) {
     let first = true, afterCR = false, high = 0, output = '';
     for await (const chunk of source) {
         for (let index = 0; index < chunk.length; index++) {
@@ -41,6 +41,10 @@ export async function* normalizeXmlChunks(source) {
                 output = '';
             }
         }
+        if (flushChunks && output) {
+            yield output;
+            output = '';
+        }
     }
     if (high)
         throw new SyntaxError('Invalid XML: invalid character');

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

@@ -0,0 +1,28 @@
+import type { XmlContent, XmlElement } from './index.js';
+export interface XmlParserFrame {
+    element: XmlElement;
+    content: XmlContent[] | undefined;
+    name: string;
+    namespaces: Map<string, string>;
+}
+export type XmlFrameRequest = {
+    readonly frameOperation: 'push';
+    readonly frame: XmlParserFrame;
+} | {
+    readonly frameOperation: 'pop';
+} | {
+    readonly frameOperation: 'peek';
+    frame?: XmlParserFrame;
+};
+/** External mode caches only the current frame. The host owns the linked stack. */
+export declare class XmlFrames {
+    private readonly external;
+    private readonly frames;
+    private depth;
+    private current;
+    constructor(external: boolean);
+    get length(): number;
+    peek(): Generator<XmlFrameRequest, XmlParserFrame | undefined, void>;
+    push(frame: XmlParserFrame): Generator<XmlFrameRequest, void, void>;
+    pop(): Generator<XmlFrameRequest, XmlParserFrame | undefined, void>;
+}

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

@@ -0,0 +1,45 @@
+/** External mode caches only the current frame. The host owns the linked stack. */
+export class XmlFrames {
+    external;
+    frames = [];
+    depth = 0;
+    current;
+    constructor(external) {
+        this.external = external;
+    }
+    get length() { return this.external ? this.depth : this.frames.length; }
+    *peek() {
+        if (!this.external)
+            return this.frames.at(-1);
+        if (!this.depth)
+            return undefined;
+        if (!this.current) {
+            const request = { frameOperation: 'peek' };
+            yield request;
+            if (!request.frame)
+                throw new TypeError('Incomplete XML frame read');
+            this.current = request.frame;
+        }
+        return this.current;
+    }
+    *push(frame) {
+        if (!this.external) {
+            this.frames.push(frame);
+            return;
+        }
+        yield { frameOperation: 'push', frame };
+        this.current = frame;
+        this.depth++;
+    }
+    *pop() {
+        if (!this.external)
+            return this.frames.pop();
+        if (!this.depth)
+            return undefined;
+        const frame = yield* this.peek();
+        yield { frameOperation: 'pop' };
+        this.depth--;
+        this.current = undefined;
+        return frame;
+    }
+}

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

@@ -1,3 +1,5 @@
+import { type XmlFrameRequest } from "./frames.js";
+export type { XmlParserFrame, XmlFrameRequest } from "./frames.js";
 export { normalizeXmlChunks } from "./characters.js";
 import { type XmlSourceStep } from "./source.js";
 export type { XmlSourceRead, XmlSourceStep } from "./source.js";
@@ -51,8 +53,16 @@ export interface XmlStepLimits extends XmlLimits {
      * false. Drive the step iterator to await external consumers between windows. */
     readonly events?: (event: XmlStreamEvent) => void;
 }
+export interface XmlSourceLimits extends XmlStepLimits {
+    /** Store active parser frames through host-serviced requests. Requires retainTree: false. */
+    readonly storeFrames?: boolean;
+}
+export type XmlParseStep = XmlSourceStep | XmlFrameRequest;
 /** Parse a validated, BOM-free, line-normalized UTF-16 source via bounded read requests. */
-export declare function parseXmlSourceSteps(length: number, limits?: XmlStepLimits): Generator<XmlSourceStep, XmlElement, void>;
+export declare function parseXmlSourceSteps(length: number | undefined, limits?: XmlStepLimits & {
+    readonly storeFrames?: 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>;
 export declare function parseXml(input: string, limits?: XmlLimits): XmlElement;
 export { parseXmlStream, type XmlStreamLimits, type XmlStreamEvent } from "./stream.js";

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

@@ -1,3 +1,4 @@
+import { XmlFrames } from "./frames.js";
 import { validCharacter } from "./characters.js";
 export { normalizeXmlChunks } from "./characters.js";
 import { XmlSource } from "./source.js";
@@ -189,9 +190,10 @@ function validateLimits(limits) {
     if (limits.events && limits.retainTree !== false)
         throw new TypeError("XML events require retainTree: false");
 }
-/** Parse a validated, BOM-free, line-normalized UTF-16 source via bounded read requests. */
 export function* parseXmlSourceSteps(length, limits = {}) {
     validateLimits(limits);
+    if (limits.storeFrames && limits.retainTree !== false)
+        throw new TypeError("Stored XML frames require retainTree: false");
     const source = new XmlSource(length);
     const maxDepth = limits.maxDepth ?? Infinity;
     const maxNodes = limits.maxNodes ?? Infinity;
@@ -212,7 +214,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
         textLength += text.length;
     };
-    const stack = [];
+    const stack = new XmlFrames(limits.storeFrames === true);
     let root;
     const prolog = [];
     const epilog = [];
@@ -230,7 +232,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
     let pendingWork = 0;
     const skipWhitespace = function* () {
         const start = offset;
-        while (offset < source.length) {
+        while (yield* source.has(offset)) {
             const c = (yield* source.charCodeAt(offset));
             if (c !== 32 && c !== 9 && c !== 10 && c !== 13)
                 break;
@@ -245,7 +247,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
     };
     const scanName = function* () {
         const start = offset;
-        while (offset < source.length) {
+        while (yield* source.has(offset)) {
             const c = (yield* source.charCodeAt(offset));
             if (c === 32 || c === 9 || c === 13 || c === 10 || c === 47 || c === 61 || c === 62 || c === 63)
                 break;
@@ -265,7 +267,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
         return [name, prefix, localName];
     };
-    while (offset < source.length) {
+    while (yield* source.has(offset)) {
         pendingWork += 1;
         if (pendingWork >= 512) {
             while (pendingWork >= 512) {
@@ -290,7 +292,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 pendingWork -= 512;
             }
             admitText(resolved);
-            const parent = stack.at(-1);
+            const parent = (yield* stack.peek());
             if (parent) {
                 if (retainTree)
                     parent.element.text += resolved;
@@ -331,7 +333,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             if (end < 0 || (yield* find(text, "--", 0)) >= 0 || text.endsWith("-")) {
                 invalid("malformed comment");
             }
-            const parent = stack.at(-1);
+            const parent = (yield* stack.peek());
             admitText(text);
             admitContent();
             if (retain) {
@@ -348,7 +350,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 invalid("unterminated CDATA");
             const cdataText = (yield* source.slice(offset + 9, end));
             admitText(cdataText);
-            const parent = stack.at(-1);
+            const parent = (yield* stack.peek());
             if (retainTree)
                 parent.element.text += cdataText;
             admitContent();
@@ -380,7 +382,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             else if (content && !" \t\n\r".includes(content[0]))
                 invalid("invalid processing instruction");
             if (!(target.length === 3 && target.toLowerCase() === "xml")) {
-                const parent = stack.at(-1);
+                const parent = (yield* stack.peek());
                 let wsStart = 0;
                 while (wsStart < content.length && " \t\n\r".includes(content[wsStart]))
                     wsStart++;
@@ -410,14 +412,14 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 yield 512;
                 pendingWork -= 512;
             }
-            const closed = (yield* source.slice(offset++, offset)) === ">" ? stack.pop() : undefined;
+            const closed = (yield* source.slice(offset++, offset)) === ">" ? (yield* stack.pop()) : undefined;
             if (closed?.name !== name) {
                 if (!limits.recover)
                     invalid("mismatched closing tag");
                 limits.recover("mismatched closing tag");
             }
             if (closed)
-                limits.events?.({ type: "close", element: closed.element, parent: stack.at(-1)?.element });
+                limits.events?.({ type: "close", element: closed.element, parent: (yield* stack.peek())?.element });
         }
         else {
             offset++;
@@ -436,7 +438,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             }
             let attributes;
             const attrMeta = [];
-            let namespaces = stack.at(-1)?.namespaces ?? new Map([["xml", xmlNamespace]]);
+            let namespaces = (yield* stack.peek())?.namespaces ?? new Map([["xml", xmlNamespace]]);
             let ownsNamespaces = stack.length === 0;
             while (!repeated) {
                 const ws = (yield* skipWhitespace());
@@ -543,7 +545,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             if (stack.length + 1 > maxDepth)
                 throw new XmlLimitError("maxDepth", "XML resource limit exceeded");
             const namespace = namespaces.get(prefix) ?? "";
-            limits.onElement?.({ name, namespace, localName }, stack.at(-1)?.element, stack.length + 1);
+            limits.onElement?.({ name, namespace, localName }, (yield* stack.peek())?.element, stack.length + 1);
             admitContent();
             const retainedAttributes = [];
             if (retainContent && attributes) {
@@ -562,7 +564,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             }
             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 parent = stack.at(-1);
+            const parent = (yield* stack.peek());
             if (parent) {
                 if (retainTree) {
                     parent.element.children.push(element);
@@ -587,7 +589,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 previousEmpty = { suffix: name + "/>", name, prefix, localName };
             limits.events?.({ type: "open", element, parent: parent?.element });
             if (!empty)
-                stack.push({ element, content, name, namespaces });
+                yield* stack.push({ element, content, name, namespaces });
             else
                 limits.events?.({ type: "close", element, parent: parent?.element });
         }
@@ -603,8 +605,8 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             invalid("incomplete document");
         limits.recover("incomplete document");
         while (stack.length) {
-            const closed = stack.pop();
-            limits.events?.({ type: "close", element: closed.element, parent: stack.at(-1)?.element });
+            const closed = (yield* stack.pop());
+            limits.events?.({ type: "close", element: closed.element, parent: (yield* stack.peek())?.element });
             yield 1;
         }
     }

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

@@ -1,16 +1,22 @@
-/** Fill value with exactly the requested UTF-16 span before advancing the parser. */
+/** Fill value before advancing. Streaming reads may be short; mark complete at EOF. */
 export interface XmlSourceRead {
     readonly offset: number;
     readonly length: number;
+    readonly streaming?: boolean;
     value?: string;
+    complete?: boolean;
 }
 export type XmlSourceStep = number | XmlSourceRead;
 /** One fixed window; individual returned tokens still have their own size cost. */
 export declare class XmlSource {
-    readonly length: number;
     private window;
     private start;
-    constructor(length: number);
+    private end;
+    private readonly streaming;
+    constructor(length: number | undefined);
+    get length(): number;
+    private load;
+    has(offset: number): Generator<XmlSourceStep, boolean, void>;
     slice(start: number, end?: number): Generator<XmlSourceStep, string, void>;
     charCodeAt(offset: number): Generator<XmlSourceStep, number, void>;
     startsWith(value: string, offset: number): Generator<XmlSourceStep, boolean, void>;

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

@@ -1,27 +1,44 @@
 /** One fixed window; individual returned tokens still have their own size cost. */
 export class XmlSource {
-    length;
     window = '';
     start = -1;
+    end;
+    streaming;
     constructor(length) {
-        this.length = length;
-        if (!Number.isSafeInteger(length) || length < 0)
-            throw new RangeError("Invalid XML source length");
+        if (length !== undefined && (!Number.isSafeInteger(length) || length < 0))
+            throw new RangeError('Invalid XML source length');
+        this.streaming = length === undefined;
+        this.end = length ?? Infinity;
+    }
+    get length() { return this.end; }
+    *load(offset) {
+        if (offset >= this.end || offset >= this.start && offset < this.start + this.window.length)
+            return;
+        const start = this.streaming ? offset : Math.floor(offset / 4096) * 4096;
+        const request = { offset: start, length: Math.min(this.streaming ? 512 : 4096, this.end - start),
+            ...(this.streaming ? { streaming: true } : {}) };
+        yield request;
+        if (typeof request.value !== 'string' || request.value.length > request.length ||
+            (!this.streaming && request.value.length !== request.length) ||
+            (!request.value.length && !request.complete && this.streaming))
+            throw new TypeError('Incomplete XML source read');
+        if (this.streaming && request.complete)
+            this.end = start + request.value.length;
+        this.window = request.value;
+        this.start = start;
+    }
+    *has(offset) {
+        yield* this.load(offset);
+        return offset < this.end;
     }
     *slice(start, end = this.length) {
         start = start < 0 ? Math.max(0, this.length + start) : Math.min(start, this.length);
         end = end < 0 ? Math.max(0, this.length + end) : Math.min(end, this.length);
         let result = '';
-        while (start < end) {
-            if (start < this.start || start >= this.start + this.window.length) {
-                const offset = Math.floor(start / 4096) * 4096;
-                const read = { offset, length: Math.min(4096, this.length - offset) };
-                yield read;
-                if (typeof read.value !== 'string' || read.value.length !== read.length)
-                    throw new TypeError('Incomplete XML source read');
-                this.window = read.value;
-                this.start = offset;
-            }
+        while (start < Math.min(end, this.length)) {
+            yield* this.load(start);
+            if (start >= this.end)
+                break;
             const stop = Math.min(end, this.start + this.window.length);
             result += this.window.slice(start - this.start, stop - this.start);
             start = stop;
@@ -32,15 +49,21 @@ export class XmlSource {
         return (yield* this.slice(offset, offset + 1)).charCodeAt(0);
     }
     *startsWith(value, offset) {
-        return (yield* this.slice(offset, offset + value.length)) === value;
+        for (let index = 0; index < value.length; index++) {
+            if ((yield* this.charCodeAt(offset + index)) !== value.charCodeAt(index))
+                return false;
+        }
+        return true;
     }
     *indexOf(value, offset) {
-        while (offset < this.length) {
-            const end = Math.min(this.length, offset + 4096 + value.length - 1);
-            const found = (yield* this.slice(offset, end)).indexOf(value);
+        let tail = '';
+        while (yield* this.has(offset)) {
+            const part = tail + this.window.slice(offset - this.start);
+            const found = part.indexOf(value);
             if (found >= 0)
-                return offset + found;
-            offset += 4096;
+                return offset - tail.length + found;
+            tail = value.length > 1 ? part.slice(-(value.length - 1)) : '';
+            offset = this.start + this.window.length;
         }
         return -1;
     }

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

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

package/node_modules/toolcraft-schema/package.json

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

package/package.json

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