toolcraft 0.0.799 → 0.0.801

package/composition.json

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

package/dist/composition.json

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

package/dist/human-in-loop/approval-tasks.js

@@ -136,6 +136,9 @@ function getTaskListDirectory(taskList) {
     return isTaskListConfig(taskList) ? taskList.dir : "unknown";
 }
 function isDeepEqualStateMachine(left, right) {
+    if (left.initial !== right.initial) {
+        return false;
+    }
     if (!areEqualStrings(left.states, right.states)) {
         return false;
     }

package/dist/human-in-loop/plan-hash.js

@@ -44,7 +44,12 @@ function normalizePlan(value, seen) {
         }
         const normalized = {};
         for (const key of Object.keys(value).sort()) {
-            normalized[key] = normalizePlan(value[key], seen);
+            Object.defineProperty(normalized, key, {
+                value: normalizePlan(value[key], seen),
+                enumerable: true,
+                writable: true,
+                configurable: true
+            });
         }
         return normalized;
     }

package/dist/runtime.d.ts

@@ -227,10 +227,14 @@ export interface CommandRequirementOptions {
 }
 export declare function resolveCommandSecrets(command: Command<any, any, any, any>, env?: Record<string, string | undefined>): Record<string, string | undefined>;
 export declare function assertCommandRequirements(command: Command<any, any, any, any>, context: GroupCheckContext<any>, options?: CommandRequirementOptions): Promise<void>;
-export declare function defineCommand<TServices extends object = EmptyServices, TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TResult = unknown, TOwnScope extends ScopeInput = undefined, TOwnHumanInLoop extends HumanInLoopConfig<TParamsSchema> | null | undefined = undefined>(config: Omit<CommandConfig<TServices, TParamsSchema, TSecrets, TResult>, "name" | "scope" | "humanInLoop"> & {
+export declare function defineCommand<TServices extends object = EmptyServices, TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TResult = unknown, TOwnScope extends ScopeInput = undefined, TOwnHumanInLoop extends {
+    mode: HumanInLoopMode;
+} | null | undefined = undefined>(config: Omit<CommandConfig<TServices, TParamsSchema, TSecrets, TResult>, "name" | "scope" | "humanInLoop"> & {
     name: TName;
     scope?: TOwnScope;
-    humanInLoop?: TOwnHumanInLoop;
+    humanInLoop?: (TOwnHumanInLoop | {
+        [K in keyof TOwnHumanInLoop]: TOwnHumanInLoop[K];
+    }) & (HumanInLoopConfig<TParamsSchema> | null);
 }): Command<TServices, TParamsSchema, TSecrets, TResult> & TypedCommandMetadata<TName, TParamsSchema, TResult, TOwnScope, ResolveOwnHumanInLoopMode<TOwnHumanInLoop>>;
 export declare function defineStreamCommand<TServices extends object = EmptyServices, TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TEventSchema extends AnySchema = AnySchema, TOwnScope extends ScopeInput = undefined>(config: Omit<StreamCommandConfig<TServices, TParamsSchema, TSecrets, TEventSchema>, "name" | "scope"> & {
     name: TName;

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, XmlAttributeRequest, XmlAttributeRecord } from "./xml.js";
+export type { XmlName, XmlAttribute, XmlContent, XmlElement, XmlLimits, XmlParserFrame, XmlFrameRequest, XmlNamespaceScope, XmlNamespaceRequest, XmlSourceRead, XmlSourceSpan, 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

@@ -64,31 +64,48 @@ size cost. The default string and stream APIs retain their existing ancestry beh
 
 Also set `storeNamespaces: true` to resolve namespace scopes through host-backed
 immutable storage. `namespaceOperation: "get"` supplies a scope and prefix; fill
-`value` when present and set `complete: true`. For `"set"`, bind the supplied prefix
+`value` when present and set `complete: true`. For `"has"`, fill `found` using
+membership without reading the URI value. For `"set"`, bind the supplied prefix
 and value in a new scope, then fill `result` with its storage `reference` and the
 number of distinct bindings (`size`). Frames carry this scope handle so shadowing
 never changes ancestor scopes. In this mode event elements have an empty
 `namespaces` map; their names and attributes still carry resolved namespace URIs.
-The codec remains filesystem-independent, and individual names, attribute values
-and namespace URIs still need a token storage strategy.
+The codec remains filesystem-independent. With `deferNamespaces: true`, resolved
+URI metadata uses optional `namespaceReference` handles instead of complete strings.
+Service `namespaceOperation: "reference"` by supplying the token `reference` when
+present and setting `complete: true`. These handles belong to the host scope store;
+retain or stream them before retiring that store. Built-in xml/xmlns names keep
+their short namespace strings. Individual names still retain their token cost;
+attribute values can use the fragment protocol below.
 
 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,
+by `XmlAttributeRequest`, keeping records in caller-owned backing. When namespace
+storage is also enabled, `expanded` supplies the local name and a `namespace` scope
+and prefix. Check the pair of resolved URI and local name without joining them in
+memory; an empty prefix means no attribute namespace, regardless of the default
+element namespace. 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
+start tag. With `fragmentAttributes: true`, ordinary values are validated through source spans; all attribute
+values are stored as spans on attribute records and 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.
+This mode requires `storeAttributes: true`. Combining it with `storeNamespaces`
+also validates namespace declarations in bounded fragments. A namespace `set`
+request's `value` may then be a generator: strings are decoded value fragments,
+numbers are work checkpoints, and objects are source-read requests. Service each
+step before advancing, consume the complete value before filling `result`, and
+close the producer if storage fails. Reserved URI checks preserve their diagnostic
+order without joining fragments. Expanded-name events return complete URI strings
+unless deferred namespace metadata is enabled; 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
@@ -107,4 +124,16 @@ 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 and namespace declaration values still require their own memory budget.
+buffered API keeps the original declaration spelling.
+
+Combine `fragmentContent` with `deferContentNames: true` to validate long
+processing-instruction targets through source windows. Their events have an empty
+`target` and a `targetSource` span; replay that span before retiring the source.
+All body continuations carry the same target span. Short targets remain strings.
+The stored document engine transfers these spans to its own token store and
+streams targets during output. With `deferElementNames: true` and `retainTree: false`, long element local names
+also use `nameSource`/`localNameSource` spans. Closing tags compare source windows;
+element events retain the short `prefix` separately. Stored documents copy these
+names into token references for formatting, XPath and xq grouping. Attribute names
+and namespace prefixes longer than 512 UTF-16 units still retain their token cost;
+this option does not impose a name-length limit.

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

@@ -1,9 +1,14 @@
+import type { XmlSourceSpan } from "./source.js";
+import type { XmlNamespaceScope } from "./frames.js";
 export interface XmlAttributeRecord {
     name: string;
     prefix: string;
     localName: string;
     value: string;
     next: number;
+    nameSource?: XmlSourceSpan;
+    localNameSource?: XmlSourceSpan;
+    prefixSource?: XmlSourceSpan;
     source?: {
         start: number;
         end: number;
@@ -19,7 +24,13 @@ export type XmlAttributeRequest = {
     attributeOperation: 'has' | 'expanded';
     state: XmlAttributeState;
     name: string;
+    nameSource?: XmlSourceSpan;
     found?: boolean;
+    namespace?: {
+        scope: XmlNamespaceScope;
+        prefix: string;
+        prefixSource?: XmlSourceSpan;
+    };
 } | {
     attributeOperation: 'append';
     state: XmlAttributeState;
@@ -44,11 +55,15 @@ export declare class XmlAttributes {
     get length(): number;
     get size(): number;
     get first(): number;
-    has(name: string): Generator<XmlAttributeRequest, boolean, void>;
+    has(name: string, nameSource?: XmlSourceSpan): Generator<XmlAttributeRequest, boolean, void>;
     append(name: string, prefix: string, localName: string, value: string, source?: {
         start: number;
         end: number;
-    }): Generator<XmlAttributeRequest, void, void>;
+    }, nameSource?: XmlSourceSpan, localNameSource?: XmlSourceSpan, prefixSource?: XmlSourceSpan): Generator<XmlAttributeRequest, void, void>;
     read(reference: number, values: boolean): Generator<XmlAttributeRequest, XmlAttributeRecord, void>;
-    expanded(name: string): Generator<XmlAttributeRequest, boolean, void>;
+    expanded(name: string, namespace?: {
+        scope: XmlNamespaceScope;
+        prefix: string;
+        prefixSource?: XmlSourceSpan;
+    }, nameSource?: XmlSourceSpan): Generator<XmlAttributeRequest, boolean, void>;
 }

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

@@ -12,25 +12,25 @@ export class XmlAttributes {
     get length() { return this.state.length; }
     get size() { return this.state.size; }
     get first() { return this.state.first; }
-    *has(name) {
+    *has(name, nameSource) {
         if (!this.length)
             return false;
         if (!this.external)
             return this.names.has(name);
-        const request = { attributeOperation: 'has', state: this.state, name };
+        const request = { attributeOperation: 'has', state: this.state, name, ...(nameSource ? { nameSource } : {}) };
         yield request;
         if (request.found === undefined)
             throw new TypeError('Incomplete XML attribute lookup');
         return request.found;
     }
-    *append(name, prefix, localName, value, source) {
+    *append(name, prefix, localName, value, source, nameSource, localNameSource, prefixSource) {
         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 } : {}) } };
+        const request = { attributeOperation: 'append', state: this.state, attribute: { name, prefix, localName, value, ...(source ? { source } : {}), ...(nameSource ? { nameSource } : {}), ...(localNameSource ? { localNameSource } : {}), ...(prefixSource ? { prefixSource } : {}) } };
         yield request;
         if (!request.result)
             throw new TypeError('Incomplete XML attribute append');
@@ -47,13 +47,13 @@ export class XmlAttributes {
             throw new TypeError('Incomplete XML attribute read');
         return request.result;
     }
-    *expanded(name) {
+    *expanded(name, namespace, nameSource) {
         if (!this.external) {
             const found = this.expandedNames.has(name);
             this.expandedNames.add(name);
             return found;
         }
-        const request = { attributeOperation: 'expanded', state: this.state, name };
+        const request = { attributeOperation: 'expanded', state: this.state, name, ...(namespace ? { namespace } : {}), ...(nameSource ? { nameSource } : {}) };
         yield request;
         if (request.found === undefined)
             throw new TypeError('Incomplete XML expanded attribute lookup');

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

@@ -1,4 +1,5 @@
-import type { XmlContent, XmlElement } from './index.js';
+import type { XmlSourceStep, XmlSourceSpan } from './source.js';
+import type { XmlContent, XmlElement, XmlName } from './index.js';
 export interface XmlParserFrame {
     element: XmlElement;
     content: XmlContent[] | undefined;
@@ -33,17 +34,34 @@ export interface XmlNamespaceScope {
     readonly size: number;
 }
 export type XmlNamespaceRequest = {
+    readonly namespaceOperation: 'reference';
+    readonly scope: XmlNamespaceScope;
+    readonly prefix: string;
+    readonly prefixSource?: XmlSourceSpan;
+    reference?: number;
+    complete?: true;
+} | {
+    readonly namespaceOperation: 'has';
+    readonly scope: XmlNamespaceScope;
+    readonly prefix: string;
+    readonly prefixSource?: XmlSourceSpan;
+    found?: boolean;
+} | {
     readonly namespaceOperation: 'get';
     readonly scope: XmlNamespaceScope;
     readonly prefix: string;
+    readonly prefixSource?: XmlSourceSpan;
     value?: string;
     complete?: true;
 } | {
     readonly namespaceOperation: 'set';
     readonly scope: XmlNamespaceScope;
     readonly prefix: string;
-    readonly value: string;
+    readonly prefixSource?: XmlSourceSpan;
+    readonly value: string | Generator<XmlSourceStep | string, void, void>;
     result?: XmlNamespaceScope;
 };
-export declare function namespaceValue(scope: Map<string, string> | XmlNamespaceScope, prefix: string): Generator<XmlNamespaceRequest, string | undefined, void>;
-export declare function bindNamespace(scope: Map<string, string> | XmlNamespaceScope, prefix: string, value: string): Generator<XmlNamespaceRequest, Map<string, string> | XmlNamespaceScope, void>;
+export declare function namespaceValue(scope: Map<string, string> | XmlNamespaceScope, prefix: string, prefixSource?: XmlSourceSpan): Generator<XmlNamespaceRequest, string | undefined, void>;
+export declare function namespaceMetadata(scope: Map<string, string> | XmlNamespaceScope, prefix: string, deferred?: boolean, prefixSource?: XmlSourceSpan): Generator<XmlNamespaceRequest, Pick<XmlName, 'namespace' | 'namespaceReference'>, void>;
+export declare function hasNamespace(scope: Map<string, string> | XmlNamespaceScope, prefix: string, prefixSource?: XmlSourceSpan): Generator<XmlNamespaceRequest, boolean, void>;
+export declare function bindNamespace(scope: Map<string, string> | XmlNamespaceScope, prefix: string, value: string | Generator<XmlSourceStep | string, void, void>, prefixSource?: XmlSourceSpan): Generator<XmlNamespaceRequest, Map<string, string> | XmlNamespaceScope, void>;

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

@@ -43,21 +43,43 @@ export class XmlFrames {
         return frame;
     }
 }
-export function* namespaceValue(scope, prefix) {
+export function* namespaceValue(scope, prefix, prefixSource) {
     if (scope instanceof Map)
         return scope.get(prefix);
-    const request = { namespaceOperation: 'get', scope, prefix };
+    const request = { namespaceOperation: 'get', scope, prefix, ...(prefixSource ? { prefixSource } : {}) };
     yield request;
     if (!request.complete)
         throw new TypeError('Incomplete XML namespace read');
     return request.value;
 }
-export function* bindNamespace(scope, prefix, value) {
+export function* namespaceMetadata(scope, prefix, deferred = false, prefixSource) {
+    if (!deferred || scope instanceof Map)
+        return { namespace: (yield* namespaceValue(scope, prefix, prefixSource)) ?? '' };
+    if (prefix === 'xml')
+        return { namespace: 'http://www.w3.org/XML/1998/namespace' };
+    const request = { namespaceOperation: 'reference', scope, prefix, ...(prefixSource ? { prefixSource } : {}) };
+    yield request;
+    if (!request.complete)
+        throw new TypeError('Incomplete XML namespace reference lookup');
+    return { namespace: '', ...(request.reference === undefined ? {} : { namespaceReference: request.reference }) };
+}
+export function* hasNamespace(scope, prefix, prefixSource) {
+    if (scope instanceof Map)
+        return scope.has(prefix);
+    const request = { namespaceOperation: 'has', scope, prefix, ...(prefixSource ? { prefixSource } : {}) };
+    yield request;
+    if (request.found === undefined)
+        throw new TypeError('Incomplete XML namespace membership lookup');
+    return request.found;
+}
+export function* bindNamespace(scope, prefix, value, prefixSource) {
     if (scope instanceof Map) {
+        if (typeof value !== 'string')
+            throw new TypeError('Streamed XML namespace values require external scopes');
         scope.set(prefix, value);
         return scope;
     }
-    const request = { namespaceOperation: 'set', scope, prefix, value };
+    const request = { namespaceOperation: 'set', scope, prefix, value, ...(prefixSource ? { prefixSource } : {}) };
     yield request;
     if (!request.result)
         throw new TypeError('Incomplete XML namespace update');

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

@@ -3,13 +3,21 @@ export type { XmlAttributeRequest, XmlAttributeRecord, XmlAttributeState } from
 import { type XmlNamespaceRequest, type XmlFrameRequest } from "./frames.js";
 export type { XmlParserFrame, XmlFrameRequest, XmlNamespaceScope, XmlNamespaceRequest } from "./frames.js";
 export { normalizeXmlChunks } from "./characters.js";
-import { type XmlSourceStep } from "./source.js";
-export type { XmlSourceRead, XmlSourceStep } from "./source.js";
+import { type XmlSourceSpan, type XmlSourceStep } from "./source.js";
+export type { XmlSourceRead, XmlSourceSpan, XmlSourceStep } from "./source.js";
 import type { XmlStreamEvent } from "./stream.js";
 export { XmlLimitError } from "./errors.js";
 export interface XmlName {
     readonly name: string;
+    readonly nameSource?: XmlSourceSpan;
+    readonly nameReference?: number;
+    readonly localNameSource?: XmlSourceSpan;
+    readonly localNameReference?: number;
+    readonly prefix?: string;
+    readonly prefixSource?: XmlSourceSpan;
+    readonly prefixReference?: number;
     readonly namespace: string;
+    readonly namespaceReference?: number;
     readonly localName: string;
 }
 export interface XmlAttribute extends XmlName {
@@ -21,6 +29,8 @@ export type XmlContent = XmlElement | {
 } | {
     readonly kind: "processing-instruction";
     readonly target: string;
+    readonly targetSource?: XmlSourceSpan;
+    readonly targetReference?: number;
     readonly text: string;
 };
 export interface XmlElement extends XmlName {
@@ -65,6 +75,14 @@ export interface XmlSourceLimits extends XmlStepLimits {
     readonly storeFrames?: boolean;
     /** Resolve namespace scopes through host-serviced requests. Requires retainTree: false. */
     readonly storeNamespaces?: boolean;
+    /** Carry host namespace token references in event metadata. Requires stored namespaces. */
+    readonly deferNamespaces?: boolean;
+    /** Emit long processing-instruction targets as source spans. Requires fragmentContent. */
+    readonly deferContentNames?: boolean;
+    /** Defer long element names and, with external namespaces, their prefixes. */
+    readonly deferElementNames?: boolean;
+    /** Defer attribute names and namespace declaration prefixes to source spans. */
+    readonly deferAttributeNames?: boolean;
     /** Store attribute collections through host requests and emit resolved attributes individually. */
     readonly storeAttributes?: boolean;
     readonly fragmentAttributes?: boolean;

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

@@ -1,5 +1,5 @@
 import { XmlAttributes } from "./attributes.js";
-import { XmlFrames, bindNamespace, namespaceValue } from "./frames.js";
+import { XmlFrames, bindNamespace, namespaceValue, namespaceMetadata, hasNamespace } from "./frames.js";
 import { validCharacter } from "./characters.js";
 export { normalizeXmlChunks } from "./characters.js";
 import { XmlSource } from "./source.js";
@@ -68,6 +68,41 @@ function qualifiedNameSync(name, cache) {
     }
     return parts;
 }
+/** Validate a name span without retaining its spelling. */
+function* validateNameSpan(source, start, end) {
+    let first = true, colon = -1, work = 0;
+    for (let offset = start; offset < end;) {
+        let point = yield* source.charCodeAt(offset);
+        if (point >= 0xd800 && point <= 0xdbff && offset + 1 < end) {
+            const low = yield* source.charCodeAt(offset + 1);
+            if (low >= 0xdc00 && low <= 0xdfff)
+                point = 0x10000 + (point - 0xd800) * 1024 + low - 0xdc00;
+        }
+        if (point === 58) {
+            if (colon >= 0 || first)
+                invalid("invalid qualified name");
+            colon = offset;
+            first = true;
+        }
+        else {
+            if (!(first ? nameStart(point) : namePart(point)))
+                invalid("invalid qualified name");
+            first = false;
+        }
+        const size = point > 0xffff ? 2 : 1;
+        offset += size;
+        work += size;
+        if (work >= 512) {
+            yield 512;
+            work -= 512;
+        }
+    }
+    if (first)
+        invalid("invalid qualified name");
+    if (work)
+        yield work;
+    return colon;
+}
 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))
@@ -260,12 +295,20 @@ function validateLimits(limits) {
 }
 export function* parseXmlSourceSteps(length, limits = {}) {
     validateLimits(limits);
+    if (limits.deferAttributeNames && (!limits.storeAttributes || !limits.storeNamespaces))
+        throw new TypeError("Deferred attribute names require stored attributes and namespaces");
+    if (limits.deferElementNames && limits.retainTree !== false)
+        throw new TypeError("Deferred element names require retainTree: false");
+    if (limits.deferContentNames && !limits.fragmentContent)
+        throw new TypeError("Deferred XML content names require fragmentContent: true");
     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.deferNamespaces && !limits.storeNamespaces)
+        throw new TypeError("Deferred XML namespaces require stored namespaces");
     if (limits.storeNamespaces && limits.retainTree !== false)
         throw new TypeError("Stored XML namespaces require retainTree: false");
     if (limits.fragmentContent && limits.retainTree !== false)
@@ -322,7 +365,24 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         }
         return offset - start;
     };
-    const scanName = function* () {
+    const sameName = function* (left, right, span) {
+        if (!left.nameSource && !span)
+            return left.name === right;
+        const leftLength = left.nameSource ? left.nameSource.end - left.nameSource.start : left.name.length;
+        const rightLength = span ? span.end - span.start : right.length;
+        if (leftLength !== rightLength)
+            return false;
+        for (let index = 0; index < leftLength; index += 512) {
+            const end = Math.min(leftLength, index + 512);
+            const a = left.nameSource ? yield* source.slice(left.nameSource.start + index, left.nameSource.start + end) : left.name.slice(index, end);
+            const b = span ? yield* source.slice(span.start + index, span.start + end) : right.slice(index, end);
+            yield end - index;
+            if (a !== b)
+                return false;
+        }
+        return true;
+    };
+    const scanName = function* (defer) {
         const start = offset;
         while (yield* source.has(offset)) {
             const c = (yield* source.charCodeAt(offset));
@@ -335,6 +395,21 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 pendingWork -= 512;
             }
         }
+        if (defer && offset - start > 512) {
+            const colon = yield* validateNameSpan(source, start, offset);
+            if (defer === "content")
+                return ["", "", "", { start, end: offset }];
+            if (colon - start > 512 && !limits.storeNamespaces) {
+                const name = yield* source.slice(start, offset);
+                return [name, name.slice(0, colon - start), name.slice(colon - start + 1)];
+            }
+            const localStart = colon < 0 ? start : colon + 1;
+            const prefixSource = colon - start > 512 ? { start, end: colon } : undefined;
+            const prefix = colon < 0 || prefixSource ? "" : yield* source.slice(start, colon);
+            const localNameSource = offset - localStart > 512 ? { start: localStart, end: offset } : undefined;
+            const local = localNameSource ? "" : yield* source.slice(localStart, offset);
+            return ["", prefix, local, { start, end: offset }, localNameSource, prefixSource];
+        }
         const name = (yield* source.slice(start, offset));
         pendingWork += offset - start;
         while (pendingWork >= 512) {
@@ -344,7 +419,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
         return [name, prefix, localName];
     };
-    const rawContent = function* (kind, start, end, parent, target = "") {
+    const rawContent = function* (kind, start, end, parent, target = "", targetSource) {
         if (end - start > maxTextLength - textLength)
             throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
         textLength += end - start;
@@ -358,7 +433,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     finish--;
             }
             const text = yield* source.slice(cursor, finish);
-            const content = kind === "processing-instruction" ? { kind, target, text } : { kind, text };
+            const content = kind === "processing-instruction" ? { kind, target, text, ...(targetSource ? { targetSource } : {}) } : { kind, text };
             if (kind === "cdata" && retainTree)
                 parent.element.text += text;
             if (retain)
@@ -494,7 +569,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         else if ((yield* source.startsWith("<?", offset))) {
             const start = offset;
             offset += 2;
-            const [target] = yield* scanName();
+            const [target, , , targetSource] = yield* scanName(limits.deferContentNames ? "content" : undefined);
             while (pendingWork >= 512) {
                 yield 512;
                 pendingWork -= 512;
@@ -527,7 +602,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     yield 512;
                     pendingWork -= 512;
                 }
-                yield* rawContent("processing-instruction", body, end, yield* stack.peek(), target);
+                yield* rawContent("processing-instruction", body, end, yield* stack.peek(), target, targetSource);
             }
             offset = end + 2;
         }
@@ -536,14 +611,14 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         }
         else if ((yield* source.charCodeAt(offset + 1)) === 47) {
             offset += 2;
-            const [name] = yield* scanName();
+            const [name, , , nameSource] = yield* scanName(limits.deferElementNames ? "element" : undefined);
             yield* skipWhitespace();
             while (pendingWork >= 512) {
                 yield 512;
                 pendingWork -= 512;
             }
             const closed = (yield* source.slice(offset++, offset)) === ">" ? (yield* stack.pop()) : undefined;
-            if (closed?.name !== name) {
+            if (!closed || !(yield* sameName(closed.element, name, nameSource))) {
                 if (!limits.recover)
                     invalid("mismatched closing tag");
                 limits.recover("mismatched closing tag");
@@ -554,9 +629,9 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         else {
             offset++;
             const repeated = previousEmpty && (yield* source.startsWith(previousEmpty.suffix, offset)) ? previousEmpty : undefined;
-            const [name, prefix, localName] = repeated
+            const [name, prefix, localName, nameSource, localNameSource, prefixSource] = repeated
                 ? [repeated.name, repeated.prefix, repeated.localName]
-                : (yield* scanName());
+                : (yield* scanName(limits.deferElementNames ? "element" : undefined));
             if (repeated)
                 offset += name.length;
             // Preserve scan/validation work while reusing the admitted spelling.
@@ -581,12 +656,12 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     break;
                 if (ws === 0)
                     invalid("attributes require whitespace");
-                const [attribute, attrPrefix, attrLocal] = yield* scanName();
+                const [attribute, attrPrefix, attrLocal, nameSource, localNameSource, attrPrefixSource] = yield* scanName(limits.deferAttributeNames ? "attribute" : undefined);
                 while (pendingWork >= 512) {
                     yield 512;
                     pendingWork -= 512;
                 }
-                if ((yield* attributes.has(attribute)))
+                if ((yield* attributes.has(attribute, nameSource)))
                     invalid("duplicate attribute");
                 if (++attributeCount > maxAttributes)
                     throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
@@ -608,18 +683,23 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 }
                 if (end < 0)
                     invalid("unterminated attribute");
-                const fragmented = limits.fragmentAttributes && attribute !== "xmlns" && attrPrefix !== "xmlns";
-                let value = "";
+                const fragmented = limits.fragmentAttributes && (limits.storeNamespaces || attribute !== "xmlns" && attrPrefix !== "xmlns");
+                const valueStart = offset;
+                let value = "", size = 0, matchesXml = true, matchesXmlns = true;
                 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
+                        else {
+                            matchesXml = matchesXml && part === xmlNamespace.slice(size, size + part.length);
+                            matchesXmlns = matchesXmlns && part === xmlnsNamespace.slice(size, size + part.length);
                             size += part.length;
+                        }
                     }
+                    matchesXml = matchesXml && size === xmlNamespace.length;
+                    matchesXmlns = matchesXmlns && size === xmlnsNamespace.length;
                     if (size > maxTextLength - textLength)
                         throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
                     textLength += size;
@@ -646,13 +726,14 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     }
                     admitText(value);
                 }
-                yield* attributes.append(attribute, attrPrefix, attrLocal, value, fragmented ? { start: offset, end } : undefined);
+                yield* attributes.append(attribute, attrPrefix, attrLocal, value, limits.fragmentAttributes ? { start: offset, end } : undefined, nameSource, localNameSource, attrPrefixSource);
                 offset = end + 1;
-                if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
-                    const nsPrefix = attribute === "xmlns" ? "" : attribute.slice(6);
-                    if (nsPrefix === "xmlns" || value === xmlnsNamespace
-                        || (nsPrefix === "xml") !== (value === xmlNamespace)
-                        || (nsPrefix !== "" && value === ""))
+                if (attribute === "xmlns" || attrPrefix === "xmlns") {
+                    const nsPrefix = attribute === "xmlns" ? "" : attrLocal;
+                    const nsPrefixSource = attrPrefix === "xmlns" ? localNameSource : undefined;
+                    if (nsPrefix === "xmlns" || (fragmented ? matchesXmlns : value === xmlnsNamespace)
+                        || (nsPrefix === "xml") !== (fragmented ? matchesXml : value === xmlNamespace)
+                        || ((nsPrefix !== "" || nsPrefixSource) && (fragmented ? size === 0 : value === "")))
                         invalid("invalid namespace binding");
                     if (!ownsNamespaces && namespaces instanceof Map) {
                         const copy = new Map();
@@ -663,7 +744,8 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                         namespaces = copy;
                         ownsNamespaces = true;
                     }
-                    namespaces = yield* bindNamespace(namespaces, nsPrefix, value);
+                    namespaces = yield* bindNamespace(namespaces, nsPrefix, fragmented
+                        ? textFragments(source, valueStart, end, true, limits.recover ? () => { } : undefined, true) : value, nsPrefixSource);
                     if (namespaces.size > maxNamespaces)
                         throw new XmlLimitError("maxNamespaces", "XML namespace scope limit exceeded");
                 }
@@ -673,14 +755,15 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     const record = yield* attributes.read(cursor, false);
                     cursor = record.next;
                     const { name: attribute, prefix: attrPrefix, localName: attrLocal } = record;
-                    if (attribute === "xmlns" || attribute.startsWith("xmlns:"))
+                    if (attribute === "xmlns" || attrPrefix === "xmlns")
                         continue;
                     pendingWork += attribute.length;
-                    if (attrPrefix && (yield* namespaceValue(namespaces, attrPrefix)) === undefined)
+                    if ((attrPrefix || record.prefixSource) && !(yield* hasNamespace(namespaces, attrPrefix, record.prefixSource)))
                         invalid("unbound attribute prefix");
                     if (attributes.length > 1) {
-                        const key = `${attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : ""}\0${attrLocal}`;
-                        if (yield* attributes.expanded(key))
+                        const backed = limits.storeAttributes && !(namespaces instanceof Map) ? namespaces : undefined;
+                        const key = backed ? attrLocal : `${attrPrefix ? (yield* namespaceValue(namespaces, attrPrefix)) : ""}\0${attrLocal}`;
+                        if (yield* attributes.expanded(key, backed ? { scope: backed, prefix: attrPrefix, ...(record.prefixSource ? { prefixSource: record.prefixSource } : {}) } : undefined, record.localNameSource))
                             invalid("duplicate expanded attribute");
                     }
                 }
@@ -690,14 +773,15 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 yield 512;
                 pendingWork -= 512;
             }
-            if (prefix === "xmlns" || (prefix && (yield* namespaceValue(namespaces, prefix)) === undefined))
+            if (prefix === "xmlns" || ((prefix || prefixSource) && !(yield* hasNamespace(namespaces, prefix, prefixSource))))
                 invalid("unbound element prefix");
             if (++nodes > maxNodes)
                 throw new XmlLimitError("maxNodes", "XML resource limit exceeded");
             if (stack.length + 1 > maxDepth)
                 throw new XmlLimitError("maxDepth", "XML resource limit exceeded");
-            const namespace = (yield* namespaceValue(namespaces, prefix)) ?? "";
-            limits.onElement?.({ name, namespace, localName }, (yield* stack.peek())?.element, stack.length + 1);
+            const namespace = yield* namespaceMetadata(namespaces, prefix, limits.deferNamespaces, prefixSource);
+            const elementName = { name, localName, ...(nameSource ? { nameSource, prefix } : {}), ...(localNameSource ? { localNameSource } : {}), ...(prefixSource ? { prefixSource } : {}) };
+            limits.onElement?.({ ...elementName, ...namespace }, (yield* stack.peek())?.element, stack.length + 1);
             admitContent();
             const retainedAttributes = [];
             if (retainContent) {
@@ -717,7 +801,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 pendingWork -= 512;
             }
             const content = retain ? [] : undefined;
-            const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent && namespaces instanceof Map ? namespaces : emptyNamespaces, ...(root === undefined && retainContent ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
+            const element = { kind: "element", ...elementName, ...namespace, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent && namespaces instanceof Map ? namespaces : emptyNamespaces, ...(root === undefined && retainContent ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
             const parent = (yield* stack.peek());
             if (parent) {
                 if (retainTree) {
@@ -739,7 +823,7 @@ 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.length && name.length <= 512 && (yield* source.slice(offset - name.length - 3, offset)) === `<${name}/>`)
+            if (empty && !nameSource && !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) {
@@ -747,8 +831,9 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 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)) : "";
+                    const namespace = attribute.name === "xmlns" || attribute.prefix === "xmlns" ? { namespace: xmlnsNamespace }
+                        : attribute.prefix || attribute.prefixSource ? yield* namespaceMetadata(namespaces, attribute.prefix, limits.deferNamespaces, attribute.prefixSource) : { namespace: "" };
+                    const nameMetadata = { name: attribute.name, localName: attribute.localName, ...(attribute.nameSource ? { nameSource: attribute.nameSource, prefix: attribute.prefix } : {}), ...(attribute.localNameSource ? { localNameSource: attribute.localNameSource } : {}), ...(attribute.prefixSource ? { prefixSource: attribute.prefixSource } : {}) };
                     let continuation = false;
                     if (attribute.source) {
                         for (const part of textFragments(source, attribute.source.start, attribute.source.end, true, limits.recover ? () => { } : undefined, true)) {
@@ -756,13 +841,13 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                                 yield part;
                                 continue;
                             }
-                            limits.onAttribute({ name: attribute.name, localName: attribute.localName, namespace, value: part }, element, continuation);
+                            limits.onAttribute({ ...nameMetadata, ...namespace, value: part }, element, continuation);
                             continuation = true;
                             yield 1;
                         }
                     }
                     if (!continuation) {
-                        limits.onAttribute({ name: attribute.name, localName: attribute.localName, namespace, value: attribute.value }, element);
+                        limits.onAttribute({ ...nameMetadata, ...namespace, value: attribute.value }, element);
                         yield 1;
                     }
                 }

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

@@ -1,3 +1,7 @@
+export interface XmlSourceSpan {
+    readonly start: number;
+    readonly end: number;
+}
 /** Fill value before advancing. Streaming reads may be short; mark complete at EOF. */
 export interface XmlSourceRead {
     readonly offset: number;

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

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

package/node_modules/toolcraft-design/dist/prompts/primitives/spinner.js

@@ -23,6 +23,7 @@ export function spinner() {
     };
     return {
         start(message = "") {
+            clearTimer();
             currentMessage = stripAnsi(message);
             if (format === "json") {
                 return;

package/node_modules/toolcraft-schema/package.json

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

package/package.json

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