toolcraft 0.0.798 → 0.0.799

package/composition.json

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

package/dist/composition.json

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

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

@@ -81,7 +81,14 @@ receive resolved attributes in source order, after the open event and before any
 content or close event. The parser yields between attributes so a host can await
 storage or a consumer. Namespace declarations may follow prefixed attributes;
 resolution and duplicate-expanded-name validation still happen after the complete
-start tag. Individual attribute names and values retain their token cost.
+start tag. With `fragmentAttributes: true`, ordinary values are validated and
+stored as source spans on attribute records, then replayed in at most 512 UTF-16
+units. Hosts must preserve the optional `source` field in append/read requests.
+The third `onAttribute` argument is `true` for continuations of the same logical
+attribute; await each fragment before requesting the next step. Empty attributes
+still emit once. Entity diagnostics are emitted during validation, not replay.
+This mode requires `storeAttributes: true`. Namespace declaration values and
+individual names still retain their token cost.
 
 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
@@ -100,5 +107,4 @@ decoding replay bounded source windows before publishing a logical node, retaini
 its diagnostic and limit ordering. Numeric entity references are decoded without
 materializing the token. Set `compactDeclaration: true` to retain normalized declaration fields without
 copying long whitespace spans; validation always reads bounded windows. The
-buffered API keeps the original declaration spelling. Names, attribute values
-and namespace scopes still require their own memory budget.
+buffered API keeps the original declaration spelling. Names and namespace declaration values still require their own memory budget.

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

@@ -4,6 +4,10 @@ export interface XmlAttributeRecord {
     localName: string;
     value: string;
     next: number;
+    source?: {
+        start: number;
+        end: number;
+    };
 }
 export interface XmlAttributeState {
     reference: number;
@@ -41,7 +45,10 @@ export declare class XmlAttributes {
     get size(): number;
     get first(): number;
     has(name: string): Generator<XmlAttributeRequest, boolean, void>;
-    append(name: string, prefix: string, localName: string, value: string): Generator<XmlAttributeRequest, void, void>;
+    append(name: string, prefix: string, localName: string, value: string, source?: {
+        start: number;
+        end: number;
+    }): Generator<XmlAttributeRequest, void, void>;
     read(reference: number, values: boolean): Generator<XmlAttributeRequest, XmlAttributeRecord, void>;
     expanded(name: string): Generator<XmlAttributeRequest, boolean, void>;
 }

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

@@ -23,14 +23,14 @@ export class XmlAttributes {
             throw new TypeError('Incomplete XML attribute lookup');
         return request.found;
     }
-    *append(name, prefix, localName, value) {
+    *append(name, prefix, localName, value, source) {
         if (!this.external) {
             this.names.set(name, value);
             this.records.push({ name, prefix, localName });
             this.state = { reference: 0, first: 1, length: this.records.length, size: this.names.size };
             return;
         }
-        const request = { attributeOperation: 'append', state: this.state, attribute: { name, prefix, localName, value } };
+        const request = { attributeOperation: 'append', state: this.state, attribute: { name, prefix, localName, value, ...(source ? { source } : {}) } };
         yield request;
         if (!request.result)
             throw new TypeError('Incomplete XML attribute append');

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

@@ -67,7 +67,8 @@ export interface XmlSourceLimits extends XmlStepLimits {
     readonly storeNamespaces?: boolean;
     /** Store attribute collections through host requests and emit resolved attributes individually. */
     readonly storeAttributes?: boolean;
-    readonly onAttribute?: (attribute: XmlAttribute, element: XmlElement) => void;
+    readonly fragmentAttributes?: boolean;
+    readonly onAttribute?: (attribute: XmlAttribute, element: XmlElement, continuation?: boolean) => void;
 }
 export type XmlParseStep = XmlSourceStep | XmlFrameRequest | XmlNamespaceRequest | XmlAttributeRequest;
 /** Parse a validated, BOM-free, line-normalized UTF-16 source via bounded read requests. */

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

@@ -102,7 +102,7 @@ function* entity(source, start, end, recover) {
     return String.fromCodePoint(point);
 }
 /** Decoded text fragments; source read/work requests remain host-serviced. */
-function* textParts(source, start, end, decode, recover) {
+function* textParts(source, start, end, decode, recover, attribute = false) {
     let cursor = start;
     while (cursor < end) {
         let finish = Math.min(end, cursor + 512);
@@ -111,7 +111,13 @@ function* textParts(source, start, end, decode, recover) {
             if (last >= 0xd800 && last <= 0xdbff)
                 finish--;
         }
-        const raw = yield* source.slice(cursor, finish);
+        let raw = yield* source.slice(cursor, finish);
+        if (attribute) {
+            let normalized = "";
+            for (const character of raw)
+                normalized += "\t\n\r".includes(character) ? " " : character;
+            raw = normalized;
+        }
         const found = decode ? raw.indexOf("&") : -1;
         if (found < 0) {
             yield raw;
@@ -140,9 +146,9 @@ function* textParts(source, start, end, decode, recover) {
         cursor = semicolon + 1;
     }
 }
-function* textFragments(source, start, end, decode, recover) {
+function* textFragments(source, start, end, decode, recover, attribute = false) {
     let pending = "";
-    for (const part of textParts(source, start, end, decode, recover)) {
+    for (const part of textParts(source, start, end, decode, recover, attribute)) {
         if (typeof part !== "string") {
             yield part;
             continue;
@@ -254,6 +260,8 @@ function validateLimits(limits) {
 }
 export function* parseXmlSourceSteps(length, limits = {}) {
     validateLimits(limits);
+    if (limits.fragmentAttributes && !limits.storeAttributes)
+        throw new TypeError("XML attribute fragments require storeAttributes: true");
     if (limits.storeFrames && limits.retainTree !== false)
         throw new TypeError("Stored XML frames require retainTree: false");
     if (limits.storeAttributes && limits.retainTree !== false)
@@ -600,22 +608,45 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 }
                 if (end < 0)
                     invalid("unterminated attribute");
-                const raw = (yield* source.slice(offset, end));
-                pendingWork += raw.length * 2;
-                while (pendingWork >= 512) {
-                    yield 512;
-                    pendingWork -= 512;
+                const fragmented = limits.fragmentAttributes && attribute !== "xmlns" && attrPrefix !== "xmlns";
+                let value = "";
+                if (fragmented) {
+                    if ((yield* source.indexOf("<", offset, end)) >= 0)
+                        invalid("less-than in attribute");
+                    let size = 0;
+                    for (const part of textFragments(source, offset, end, true, limits.recover, true)) {
+                        if (typeof part !== "string")
+                            yield part;
+                        else
+                            size += part.length;
+                    }
+                    if (size > maxTextLength - textLength)
+                        throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
+                    textLength += size;
                 }
-                if (raw.indexOf("<") >= 0)
-                    invalid("less-than in attribute");
-                const normalized = /[\t\n\r]/.test(raw) ? raw.replace(/[\t\n\r]/g, " ") : raw;
-                const value = normalized.indexOf("&") < 0 ? (pendingWork += normalized.length, normalized) : yield* entities(normalized, limits.recover);
-                while (pendingWork >= 512) {
-                    yield 512;
-                    pendingWork -= 512;
+                else {
+                    const raw = (yield* source.slice(offset, end));
+                    pendingWork += raw.length * 2;
+                    while (pendingWork >= 512) {
+                        yield 512;
+                        pendingWork -= 512;
+                    }
+                    if (raw.indexOf("<") >= 0)
+                        invalid("less-than in attribute");
+                    let normalized = raw;
+                    if (raw.includes("\t") || raw.includes("\n") || raw.includes("\r")) {
+                        normalized = "";
+                        for (const character of raw)
+                            normalized += "\t\n\r".includes(character) ? " " : character;
+                    }
+                    value = normalized.indexOf("&") < 0 ? (pendingWork += normalized.length, normalized) : yield* entities(normalized, limits.recover);
+                    while (pendingWork >= 512) {
+                        yield 512;
+                        pendingWork -= 512;
+                    }
+                    admitText(value);
                 }
-                admitText(value);
-                yield* attributes.append(attribute, attrPrefix, attrLocal, value);
+                yield* attributes.append(attribute, attrPrefix, attrLocal, value, fragmented ? { start: offset, end } : undefined);
                 offset = end + 1;
                 if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
                     const nsPrefix = attribute === "xmlns" ? "" : attribute.slice(6);
@@ -718,8 +749,22 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     cursor = attribute.next;
                     const namespace = attribute.name === "xmlns" || attribute.prefix === "xmlns" ? xmlnsNamespace
                         : attribute.prefix ? (yield* namespaceValue(namespaces, attribute.prefix)) : "";
-                    limits.onAttribute({ name: attribute.name, localName: attribute.localName, namespace, value: attribute.value }, element);
-                    yield 1;
+                    let continuation = false;
+                    if (attribute.source) {
+                        for (const part of textFragments(source, attribute.source.start, attribute.source.end, true, limits.recover ? () => { } : undefined, true)) {
+                            if (typeof part !== "string") {
+                                yield part;
+                                continue;
+                            }
+                            limits.onAttribute({ name: attribute.name, localName: attribute.localName, namespace, value: part }, element, continuation);
+                            continuation = true;
+                            yield 1;
+                        }
+                    }
+                    if (!continuation) {
+                        limits.onAttribute({ name: attribute.name, localName: attribute.localName, namespace, value: attribute.value }, element);
+                        yield 1;
+                    }
                 }
             }
             if (!empty)

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

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

package/node_modules/toolcraft-schema/package.json

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

package/package.json

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