toolcraft 0.0.790 → 0.0.791

package/composition.json

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

package/dist/composition.json

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

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

@@ -69,3 +69,13 @@ 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.
+
+With `retainTree: false`, `parseXmlSourceSteps` accepts `fragmentContent: true`
+to emit text, CDATA, comment and processing-instruction bodies in at most 512 UTF-16 units without splitting surrogate
+pairs. Content events with `continuation: true` belong to the preceding logical
+node; store their bodies separately and retain one node identity. Yielded steps
+let the host await each fragment before parsing more. Text validation and entity
+decoding replay bounded source windows before publishing a logical node, retaining
+its diagnostic and limit ordering. Numeric entity references are decoded without
+materializing the token. Names, attribute values, namespace scopes and XML
+declarations still require their own memory budget.

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

@@ -54,6 +54,9 @@ export interface XmlStepLimits extends XmlLimits {
     readonly events?: (event: XmlStreamEvent) => void;
 }
 export interface XmlSourceLimits extends XmlStepLimits {
+    /** Emit content bodies in bounded fragments, marking continuations of the same logical
+     * node. Requires retainTree: false; consumers must preserve fragment identity. */
+    readonly fragmentContent?: boolean;
     /** Store active parser frames through host-serviced requests. Requires retainTree: false. */
     readonly storeFrames?: boolean;
 }

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

@@ -67,6 +67,95 @@ function qualifiedNameSync(name, cache) {
     }
     return parts;
 }
+function* entity(source, start, end, recover) {
+    // Inspect only a bounded prefix, even for arbitrarily long numeric references.
+    const prefix = typeof source === "string" ? source.slice(start, Math.min(end, start + 4))
+        : yield* source.slice(start, Math.min(end, start + 4));
+    const predefined = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+    if (end - start <= 4 && Object.hasOwn(predefined, prefix))
+        return predefined[prefix];
+    const hexadecimal = prefix.startsWith("#x"), digits = start + (hexadecimal ? 2 : 1);
+    if (!prefix.startsWith("#") || digits >= end) {
+        if (!recover)
+            invalid("undeclared entity");
+        recover("undeclared entity");
+        return "";
+    }
+    let point = 0;
+    for (let index = digits; index < end; index++) {
+        const code = typeof source === "string" ? source.charCodeAt(index) : yield* source.charCodeAt(index);
+        const digit = code >= 48 && code <= 57 ? code - 48 : hexadecimal && code >= 65 && code <= 70 ? code - 55
+            : hexadecimal && code >= 97 && code <= 102 ? code - 87 : -1;
+        if (digit < 0)
+            invalid("undeclared entity");
+        point = point * (hexadecimal ? 16 : 10) + digit;
+        if (point > 0x10ffff)
+            invalid("invalid character reference");
+        if ((index - digits + 1) % 512 === 0)
+            yield 512;
+    }
+    if ((end - digits) % 512)
+        yield (end - digits) % 512;
+    if (!validCharacter(point))
+        invalid("invalid character reference");
+    return String.fromCodePoint(point);
+}
+/** Decoded text fragments; source read/work requests remain host-serviced. */
+function* textParts(source, start, end, decode, recover) {
+    let cursor = start;
+    while (cursor < end) {
+        let finish = Math.min(end, cursor + 512);
+        if (finish < end) {
+            const last = yield* source.charCodeAt(finish - 1);
+            if (last >= 0xd800 && last <= 0xdbff)
+                finish--;
+        }
+        const raw = yield* source.slice(cursor, finish);
+        const found = decode ? raw.indexOf("&") : -1;
+        if (found < 0) {
+            yield raw;
+            yield raw.length;
+            cursor = finish;
+            continue;
+        }
+        const amp = cursor + found;
+        if (found) {
+            yield raw.slice(0, found);
+            yield found;
+        }
+        const semicolon = yield* source.indexOf(";", amp + 1, end);
+        if (semicolon < 0) {
+            if (!recover)
+                invalid("unterminated entity");
+            recover("unterminated entity");
+            cursor = amp + 1;
+            decode = false;
+            continue;
+        }
+        const part = yield* entity(source, amp + 1, semicolon, recover);
+        if (part)
+            yield part;
+        yield 1;
+        cursor = semicolon + 1;
+    }
+}
+function* textFragments(source, start, end, decode, recover) {
+    let pending = "";
+    for (const part of textParts(source, start, end, decode, recover)) {
+        if (typeof part !== "string") {
+            yield part;
+            continue;
+        }
+        pending += part;
+        while (pending.length >= 512) {
+            const last = pending.charCodeAt(511), width = last >= 0xd800 && last <= 0xdbff ? 511 : 512;
+            yield pending.slice(0, width);
+            pending = pending.slice(width);
+        }
+    }
+    if (pending)
+        yield pending;
+}
 function* entities(text, recover) {
     let result = "";
     let offset = 0;
@@ -82,39 +171,7 @@ function* entities(text, recover) {
             recover("unterminated entity");
             return result + text.slice(start + 1);
         }
-        const entity = text.slice(start + 1, end);
-        const predefined = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
-        if (Object.hasOwn(predefined, entity))
-            result += predefined[entity];
-        else {
-            const hexadecimal = entity.startsWith("#x");
-            const digits = entity.slice(hexadecimal ? 2 : 1);
-            if (!entity.startsWith("#") || !digits.length) {
-                if (!recover)
-                    invalid("undeclared entity");
-                recover("undeclared entity");
-                offset = end + 1;
-                continue;
-            }
-            let point = 0;
-            for (let index = 0; index < digits.length; index++) {
-                const code = digits.charCodeAt(index);
-                const digit = code >= 48 && code <= 57 ? code - 48 : hexadecimal && code >= 65 && code <= 70 ? code - 55
-                    : hexadecimal && code >= 97 && code <= 102 ? code - 87 : -1;
-                if (digit < 0)
-                    invalid("undeclared entity");
-                point = point * (hexadecimal ? 16 : 10) + digit;
-                if (point > 0x10ffff)
-                    invalid("invalid character reference");
-                if ((index + 1) % 512 === 0)
-                    yield 512;
-            }
-            if (digits.length % 512)
-                yield digits.length % 512;
-            if (!validCharacter(point))
-                invalid("invalid character reference");
-            result += String.fromCodePoint(point);
-        }
+        result += yield* entity(text, start + 1, end, recover);
         offset = end + 1;
     }
     return result;
@@ -194,6 +251,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.fragmentContent && limits.retainTree !== false)
+        throw new TypeError("XML content fragments require retainTree: false");
     const source = new XmlSource(length);
     const maxDepth = limits.maxDepth ?? Infinity;
     const maxNodes = limits.maxNodes ?? Infinity;
@@ -267,6 +326,33 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
         return [name, prefix, localName];
     };
+    const rawContent = function* (kind, start, end, parent, target = "") {
+        if (end - start > maxTextLength - textLength)
+            throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
+        textLength += end - start;
+        admitContent();
+        let cursor = start, continuation = false;
+        do {
+            let finish = limits.fragmentContent ? Math.min(end, cursor + 512) : end;
+            if (finish < end) {
+                const last = yield* source.charCodeAt(finish - 1);
+                if (last >= 0xd800 && last <= 0xdbff)
+                    finish--;
+            }
+            const text = yield* source.slice(cursor, finish);
+            const content = kind === "processing-instruction" ? { kind, target, text } : { kind, text };
+            if (kind === "cdata" && retainTree)
+                parent.element.text += text;
+            if (retain)
+                (parent?.content ?? (root ? epilog : prolog)).push(content);
+            limits.events?.({ type: "content", content, parent: parent?.element,
+                ...(continuation ? { continuation: true } : {}) });
+            if (limits.fragmentContent)
+                yield Math.max(1, text.length);
+            continuation = true;
+            cursor = finish;
+        } while (cursor < end);
+    };
     while (yield* source.has(offset)) {
         pendingWork += 1;
         if (pendingWork >= 512) {
@@ -278,6 +364,49 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         if ((yield* source.charCodeAt(offset)) !== 60) {
             const next = (yield* source.indexOf("<", offset));
             const endPos = next < 0 ? source.length : next;
+            if (limits.fragmentContent) {
+                if ((yield* source.indexOf("]]>", offset, endPos)) >= 0)
+                    invalid("CDATA terminator in text");
+                const parent = yield* stack.peek();
+                let size = 0, outsideText = false;
+                // Validate before emitting any part of the logical node. This preserves
+                // entity/recovery diagnostics and limit precedence without retaining it.
+                for (const part of textFragments(source, offset, endPos, !!parent, limits.recover)) {
+                    if (typeof part !== "string") {
+                        yield part;
+                        continue;
+                    }
+                    size += part.length;
+                    if (!parent)
+                        for (const character of part) {
+                            if (!" \t\r\n".includes(character))
+                                outsideText = true;
+                        }
+                }
+                if (size > maxTextLength - textLength)
+                    throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
+                textLength += size;
+                if (outsideText)
+                    invalid("text outside the root");
+                if (size) {
+                    admitContent();
+                    if (limits.events) {
+                        let continuation = false;
+                        for (const part of textFragments(source, offset, endPos, !!parent, limits.recover ? () => { } : undefined)) {
+                            if (typeof part !== "string") {
+                                yield part;
+                                continue;
+                            }
+                            limits.events({ type: "content", content: { kind: "text", text: part }, parent: parent?.element,
+                                ...(continuation ? { continuation: true } : {}) });
+                            continuation = true;
+                            yield 1;
+                        }
+                    }
+                }
+                offset = endPos;
+                continue;
+            }
             const text = (yield* source.slice(offset, endPos));
             pendingWork += (endPos - offset) + text.length;
             while (pendingWork >= 512) {
@@ -329,17 +458,10 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         }
         else if ((yield* source.startsWith("<!--", offset))) {
             const end = yield* find(source, "-->", offset + 4);
-            const text = end < 0 ? "" : yield* source.slice(offset + 4, end);
-            if (end < 0 || (yield* find(text, "--", 0)) >= 0 || text.endsWith("-")) {
+            if (end < 0 || (yield* source.indexOf("--", offset + 4, end)) >= 0
+                || (end > offset + 4 && (yield* source.charCodeAt(end - 1)) === 45))
                 invalid("malformed comment");
-            }
-            const parent = (yield* stack.peek());
-            admitText(text);
-            admitContent();
-            if (retain) {
-                (parent?.content ?? (root ? epilog : prolog)).push({ kind: "comment", text });
-            }
-            limits.events?.({ type: "content", content: { kind: "comment", text }, parent: parent?.element });
+            yield* rawContent("comment", offset + 4, end, yield* stack.peek());
             offset = end + 3;
         }
         else if ((yield* source.startsWith("<![CDATA[", offset))) {
@@ -348,15 +470,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             const end = yield* find(source, "]]>", offset + 9);
             if (end < 0)
                 invalid("unterminated CDATA");
-            const cdataText = (yield* source.slice(offset + 9, end));
-            admitText(cdataText);
-            const parent = (yield* stack.peek());
-            if (retainTree)
-                parent.element.text += cdataText;
-            admitContent();
-            if (retain)
-                parent.content.push({ kind: "cdata", text: cdataText });
-            limits.events?.({ type: "content", content: { kind: "cdata", text: cdataText }, parent: parent.element });
+            yield* rawContent("cdata", offset + 9, end, yield* stack.peek());
             offset = end + 3;
         }
         else if ((yield* source.startsWith("<?", offset))) {
@@ -370,34 +484,31 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             const end = yield* find(source, "?>", offset);
             if (end < 0)
                 invalid("unterminated processing instruction");
-            const content = (yield* source.slice(offset, end));
             if (target.length === 3 && target.toLowerCase() === "xml") {
+                const content = yield* source.slice(offset, end);
                 if (start !== 0 || target !== "xml"
-                    || !(yield* validDeclaration(content, limits.expectedEncoding))) {
+                    || !(yield* validDeclaration(content, limits.expectedEncoding)))
                     invalid("unsupported XML declaration");
-                }
                 if (retainContent)
-                    declaration = (yield* source.slice(start, end + 2));
+                    declaration = yield* source.slice(start, end + 2);
             }
-            else if (content && !" \t\n\r".includes(content[0]))
-                invalid("invalid processing instruction");
-            if (!(target.length === 3 && target.toLowerCase() === "xml")) {
-                const parent = (yield* stack.peek());
-                let wsStart = 0;
-                while (wsStart < content.length && " \t\n\r".includes(content[wsStart]))
-                    wsStart++;
-                pendingWork += wsStart;
+            else {
+                if (offset < end && !" \t\n\r".includes(yield* source.slice(offset, offset + 1)))
+                    invalid("invalid processing instruction");
+                let body = offset;
+                while (body < end && " \t\n\r".includes(yield* source.slice(body, body + 1))) {
+                    body++;
+                    pendingWork++;
+                    if (pendingWork >= 512) {
+                        yield 512;
+                        pendingWork -= 512;
+                    }
+                }
                 while (pendingWork >= 512) {
                     yield 512;
                     pendingWork -= 512;
                 }
-                const text = content.slice(wsStart);
-                admitText(text);
-                admitContent();
-                if (retain) {
-                    (parent?.content ?? (root ? epilog : prolog)).push({ kind: "processing-instruction", target, text });
-                }
-                limits.events?.({ type: "content", content: { kind: "processing-instruction", target, text }, parent: parent?.element });
+                yield* rawContent("processing-instruction", body, end, yield* stack.peek(), target);
             }
             offset = end + 2;
         }

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

@@ -20,5 +20,5 @@ export declare class XmlSource {
     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>;
-    indexOf(value: string, offset: number): Generator<XmlSourceStep, number, void>;
+    indexOf(value: string, offset: number, end?: number): Generator<XmlSourceStep, number, void>;
 }

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

@@ -55,15 +55,16 @@ export class XmlSource {
         }
         return true;
     }
-    *indexOf(value, offset) {
+    *indexOf(value, offset, end = Infinity) {
         let tail = '';
-        while (yield* this.has(offset)) {
-            const part = tail + this.window.slice(offset - this.start);
+        while (offset < end && (yield* this.has(offset))) {
+            const stop = Math.min(end, this.start + this.window.length);
+            const part = tail + this.window.slice(offset - this.start, stop - this.start);
             const found = part.indexOf(value);
             if (found >= 0)
                 return offset - tail.length + found;
             tail = value.length > 1 ? part.slice(-(value.length - 1)) : '';
-            offset = this.start + this.window.length;
+            offset = stop;
         }
         return -1;
     }

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

@@ -5,6 +5,7 @@ export type XmlStreamEvent = {
     readonly parent: XmlElement | undefined;
 } | {
     readonly type: "content";
+    readonly continuation?: boolean;
     readonly content: Exclude<XmlContent, XmlElement>;
     readonly parent: XmlElement | undefined;
 };

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

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

package/node_modules/toolcraft-schema/package.json

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

package/package.json

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