toolcraft 0.0.797 → 0.0.798

package/composition.json

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

package/dist/composition.json

@@ -138,7 +138,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.797",
+      "version": "0.0.798",
       "license": "MIT"
     },
     {
@@ -148,7 +148,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.797",
+      "version": "0.0.798",
       "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,17 @@ 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. Individual attribute names and values 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

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

@@ -0,0 +1,47 @@
+export interface XmlAttributeRecord {
+    name: string;
+    prefix: string;
+    localName: string;
+    value: string;
+    next: 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): 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) {
+        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 } };
+        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,16 @@ 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 onAttribute?: (attribute: XmlAttribute, element: XmlElement) => 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";
@@ -255,6 +256,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.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 +558,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 +578,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)) !== "=")
@@ -613,8 +615,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     pendingWork -= 512;
                 }
                 admitText(value);
-                (attributes ??= new Map()).set(attribute, value);
-                attrMeta.push([attribute, attrPrefix, attrLocal]);
+                yield* attributes.append(attribute, attrPrefix, attrLocal, value);
                 offset = end + 1;
                 if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
                     const nsPrefix = attribute === "xmlns" ? "" : attribute.slice(6);
@@ -636,20 +637,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 +669,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 +708,20 @@ 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)) : "";
+                    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.798",
       "license": "MIT"
     }
   ]

package/node_modules/toolcraft-schema/package.json

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

package/package.json

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