toolcraft 0.0.797 → 0.0.799

package/composition.json

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

package/dist/composition.json

@@ -138,7 +138,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.797",
+      "version": "0.0.799",
       "license": "MIT"
     },
     {
@@ -148,7 +148,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.797",
+      "version": "0.0.799",
       "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, XmlParserFrame, XmlFrameRequest, XmlNamespaceScope, XmlNamespaceRequest } from "./xml.js";
+export type { XmlName, XmlAttribute, XmlContent, XmlElement, XmlLimits, XmlParserFrame, XmlFrameRequest, XmlNamespaceScope, XmlNamespaceRequest, XmlAttributeRequest, XmlAttributeRecord } 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

@@ -72,6 +72,24 @@ never changes ancestor scopes. In this mode event elements have an empty
 The codec remains filesystem-independent, and individual names, attribute values
 and namespace URIs still need a token storage strategy.
 
+Set `storeAttributes: true` to move current-tag attribute values, source order,
+and duplicate-name state behind `attributeOperation` requests (`has`, `append`,
+`read`, and `expanded`). Service the request's `found` or `result` field as described
+by `XmlAttributeRequest`, keeping records in caller-owned backing. With this flag,
+element `attributes` arrays are empty. Supply `onAttribute(attribute, element)` to
+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. 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
 prefix available without pulling more input; set `complete: true` only when that
@@ -89,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

@@ -0,0 +1,54 @@
+export interface XmlAttributeRecord {
+    name: string;
+    prefix: string;
+    localName: string;
+    value: string;
+    next: number;
+    source?: {
+        start: number;
+        end: number;
+    };
+}
+export interface XmlAttributeState {
+    reference: number;
+    first: number;
+    length: number;
+    size: number;
+}
+export type XmlAttributeRequest = {
+    attributeOperation: 'has' | 'expanded';
+    state: XmlAttributeState;
+    name: string;
+    found?: boolean;
+} | {
+    attributeOperation: 'append';
+    state: XmlAttributeState;
+    attribute: Omit<XmlAttributeRecord, 'next'>;
+    result?: XmlAttributeState;
+} | {
+    attributeOperation: 'read';
+    state: XmlAttributeState;
+    reference: number;
+    values: boolean;
+    result?: XmlAttributeRecord;
+};
+/** Buffered APIs use local collections; external parsing retains only a store
+ * handle and one current attribute. Hosts preserve order and last-value recovery. */
+export declare class XmlAttributes {
+    private readonly external;
+    private state;
+    private readonly names;
+    private readonly records;
+    private readonly expandedNames;
+    constructor(external: boolean);
+    get length(): number;
+    get size(): number;
+    get first(): number;
+    has(name: string): Generator<XmlAttributeRequest, boolean, 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

@@ -0,0 +1,62 @@
+/** Buffered APIs use local collections; external parsing retains only a store
+ * handle and one current attribute. Hosts preserve order and last-value recovery. */
+export class XmlAttributes {
+    external;
+    state = { reference: 0, first: 0, length: 0, size: 0 };
+    names = new Map();
+    records = [];
+    expandedNames = new Set();
+    constructor(external) {
+        this.external = external;
+    }
+    get length() { return this.state.length; }
+    get size() { return this.state.size; }
+    get first() { return this.state.first; }
+    *has(name) {
+        if (!this.length)
+            return false;
+        if (!this.external)
+            return this.names.has(name);
+        const request = { attributeOperation: 'has', state: this.state, name };
+        yield request;
+        if (request.found === undefined)
+            throw new TypeError('Incomplete XML attribute lookup');
+        return request.found;
+    }
+    *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, ...(source ? { source } : {}) } };
+        yield request;
+        if (!request.result)
+            throw new TypeError('Incomplete XML attribute append');
+        this.state = request.result;
+    }
+    *read(reference, values) {
+        if (!this.external) {
+            const attribute = this.records[reference - 1];
+            return { ...attribute, value: values ? this.names.get(attribute.name) : '', next: reference < this.length ? reference + 1 : 0 };
+        }
+        const request = { attributeOperation: 'read', state: this.state, reference, values };
+        yield request;
+        if (!request.result)
+            throw new TypeError('Incomplete XML attribute read');
+        return request.result;
+    }
+    *expanded(name) {
+        if (!this.external) {
+            const found = this.expandedNames.has(name);
+            this.expandedNames.add(name);
+            return found;
+        }
+        const request = { attributeOperation: 'expanded', state: this.state, name };
+        yield request;
+        if (request.found === undefined)
+            throw new TypeError('Incomplete XML expanded attribute lookup');
+        return request.found;
+    }
+}

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

@@ -1,3 +1,5 @@
+import { type XmlAttributeRequest } from "./attributes.js";
+export type { XmlAttributeRequest, XmlAttributeRecord, XmlAttributeState } from "./attributes.js";
 import { type XmlNamespaceRequest, type XmlFrameRequest } from "./frames.js";
 export type { XmlParserFrame, XmlFrameRequest, XmlNamespaceScope, XmlNamespaceRequest } from "./frames.js";
 export { normalizeXmlChunks } from "./characters.js";
@@ -63,12 +65,17 @@ export interface XmlSourceLimits extends XmlStepLimits {
     readonly storeFrames?: boolean;
     /** Resolve namespace scopes through host-serviced requests. Requires retainTree: false. */
     readonly storeNamespaces?: boolean;
+    /** Store attribute collections through host requests and emit resolved attributes individually. */
+    readonly storeAttributes?: boolean;
+    readonly fragmentAttributes?: boolean;
+    readonly onAttribute?: (attribute: XmlAttribute, element: XmlElement, continuation?: boolean) => void;
 }
-export type XmlParseStep = XmlSourceStep | XmlFrameRequest | XmlNamespaceRequest;
+export type XmlParseStep = XmlSourceStep | XmlFrameRequest | XmlNamespaceRequest | XmlAttributeRequest;
 /** 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;
+    readonly storeAttributes?: 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,3 +1,4 @@
+import { XmlAttributes } from "./attributes.js";
 import { XmlFrames, bindNamespace, namespaceValue } from "./frames.js";
 import { validCharacter } from "./characters.js";
 export { normalizeXmlChunks } from "./characters.js";
@@ -101,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);
@@ -110,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;
@@ -139,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;
@@ -253,8 +260,12 @@ 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)
+        throw new TypeError("Stored XML attributes require retainTree: false");
     if (limits.storeNamespaces && limits.retainTree !== false)
         throw new TypeError("Stored XML namespaces require retainTree: false");
     if (limits.fragmentContent && limits.retainTree !== false)
@@ -555,8 +566,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 yield 512;
                 pendingWork -= 512;
             }
-            let attributes;
-            const attrMeta = [];
+            const attributes = new XmlAttributes(limits.storeAttributes === true);
             const namespaceParent = yield* stack.peek();
             let namespaces = namespaceParent?.namespaceScope ?? namespaceParent?.namespaces ?? (initialNamespaces instanceof Map ? new Map(initialNamespaces) : initialNamespaces);
             let ownsNamespaces = stack.length === 0;
@@ -576,11 +586,11 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     yield 512;
                     pendingWork -= 512;
                 }
-                if (attributes?.has(attribute))
+                if ((yield* attributes.has(attribute)))
                     invalid("duplicate attribute");
                 if (++attributeCount > maxAttributes)
                     throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
-                if ((attributes?.size ?? 0) >= maxAttributesPerElement)
+                if (attributes.size >= maxAttributesPerElement)
                     throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
                 yield* skipWhitespace();
                 if ((yield* source.slice(offset++, offset)) !== "=")
@@ -598,23 +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);
-                (attributes ??= new Map()).set(attribute, value);
-                attrMeta.push([attribute, attrPrefix, attrLocal]);
+                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);
@@ -636,20 +668,20 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                         throw new XmlLimitError("maxNamespaces", "XML namespace scope limit exceeded");
                 }
             }
-            if (attrMeta.length > 0) {
-                const expanded = attrMeta.length > 1 ? new Set() : undefined;
-                for (let i = 0; i < attrMeta.length; i++) {
-                    const [attribute, attrPrefix, attrLocal] = attrMeta[i];
+            if (attributes.length > 0) {
+                for (let cursor = attributes.first; cursor;) {
+                    const record = yield* attributes.read(cursor, false);
+                    cursor = record.next;
+                    const { name: attribute, prefix: attrPrefix, localName: attrLocal } = record;
                     if (attribute === "xmlns" || attribute.startsWith("xmlns:"))
                         continue;
                     pendingWork += attribute.length;
                     if (attrPrefix && (yield* namespaceValue(namespaces, attrPrefix)) === undefined)
                         invalid("unbound attribute prefix");
-                    if (expanded) {
+                    if (attributes.length > 1) {
                         const key = `${attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : ""}\0${attrLocal}`;
-                        if (expanded.has(key))
+                        if (yield* attributes.expanded(key))
                             invalid("duplicate expanded attribute");
-                        expanded.add(key);
                     }
                 }
             }
@@ -668,13 +700,15 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             limits.onElement?.({ name, namespace, localName }, (yield* stack.peek())?.element, stack.length + 1);
             admitContent();
             const retainedAttributes = [];
-            if (retainContent && attributes) {
-                for (let i = 0; i < attrMeta.length; i++) {
-                    const [attribute, attrPrefix, attrLocal] = attrMeta[i];
-                    const value = attributes.get(attribute);
+            if (retainContent) {
+                for (let cursor = attributes.first; cursor;) {
+                    const record = yield* attributes.read(cursor, !limits.storeAttributes);
+                    cursor = record.next;
+                    const { name: attribute, prefix: attrPrefix, localName: attrLocal, value } = record;
                     admitContent();
-                    retainedAttributes.push({ name: attribute, localName: attrLocal,
-                        namespace: attribute === "xmlns" || attrPrefix === "xmlns" ? xmlnsNamespace : attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : "", value });
+                    if (!limits.storeAttributes)
+                        retainedAttributes.push({ name: attribute, localName: attrLocal,
+                            namespace: attribute === "xmlns" || attrPrefix === "xmlns" ? xmlnsNamespace : attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : "", value });
                     pendingWork += attribute.length + 1;
                 }
             }
@@ -705,9 +739,34 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             }
             // Only cache compact, attribute-free spellings. Namespace resolution and
             // every admission counter still run for each distinct physical element.
-            if (empty && !attributes && name.length <= 512 && (yield* source.slice(offset - name.length - 3, offset)) === `<${name}/>`)
+            if (empty && !attributes.length && name.length <= 512 && (yield* source.slice(offset - name.length - 3, offset)) === `<${name}/>`)
                 previousEmpty = { suffix: name + "/>", name, prefix, localName };
             limits.events?.({ type: "open", element, parent: parent?.element });
+            if (limits.storeAttributes && limits.onAttribute && retainContent) {
+                yield 1;
+                for (let cursor = attributes.first; cursor;) {
+                    const attribute = yield* attributes.read(cursor, true);
+                    cursor = attribute.next;
+                    const namespace = attribute.name === "xmlns" || attribute.prefix === "xmlns" ? xmlnsNamespace
+                        : attribute.prefix ? (yield* namespaceValue(namespaces, attribute.prefix)) : "";
+                    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)
                 yield* stack.push({ element, content, name, namespaces: namespaces instanceof Map ? namespaces : new Map(), ...(namespaces instanceof Map ? {} : { namespaceScope: namespaces }) });
             else

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

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

package/node_modules/toolcraft-schema/package.json

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

package/package.json

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