toolcraft 0.0.800 → 0.0.802

package/composition.json

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

package/dist/composition.json

@@ -138,7 +138,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.800",
+      "version": "0.0.802",
       "license": "MIT"
     },
     {
@@ -148,7 +148,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.800",
+      "version": "0.0.802",
       "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/fs/devices/path.js

@@ -1,3 +1,4 @@
+import { plainDevicePathResolvers } from "./plain-path.js";
 import { FsError, isFsError } from "../../contracts/errors.js";
 import { pathByteLength, validatePath } from "../../contracts/virtual-path.js";
 import { capturePathNamespace, pathNamespace } from "../path-namespace.js";
@@ -146,6 +147,11 @@ export async function resolveDevicePath(filesystem, path, options, followFinal =
         const fast = tryResolveMemoryDevicePath(filesystem, path, resizeCreate);
         if (fast !== undefined)
             return fast;
+        if (followFinal && resizeCreate === undefined && traversal === undefined && isCleanAbsolutePath(path) && path !== "/" && path !== "/dev" && !path.startsWith("/dev/")) {
+            const resolved = await plainDevicePathResolvers.get(filesystem)?.(path, options);
+            if (resolved !== undefined)
+                return resolved;
+        }
     }
     const namespace = capturePathNamespace(filesystem, options);
     if (resizeCreate !== undefined)

package/node_modules/@poe-code/safe-fs/dist/fs/devices/plain-path.d.ts

@@ -0,0 +1,2 @@
+import type { FileSystem, FsOptions } from "../../contracts/filesystem.js";
+export declare const plainDevicePathResolvers: WeakMap<FileSystem, (path: string, options: FsOptions) => Promise<string | undefined>>;

package/node_modules/@poe-code/safe-fs/dist/fs/devices/plain-path.js

@@ -0,0 +1,3 @@
+// Private backend hooks, not cached path observations. A hook may only accept
+// an ordinary existing path after freshly checking every component for symlinks.
+export const plainDevicePathResolvers = new WeakMap();

package/node_modules/@poe-code/safe-fs/dist/fs/real/index.js

@@ -1,3 +1,4 @@
+import { plainDevicePathResolvers } from "../devices/plain-path.js";
 import { platform } from "#safe-fs-platform";
 import { snapshotStagingCreation } from "../staging-cleanup.js";
 import { snapshotConditionalChmod } from "../conditional-chmod.js";
@@ -121,6 +122,30 @@ export class RealFileSystem {
             throw new FsError("ENOTSUP", { syscall: "root", message: "this backend requires a POSIX host" });
         }
         this.configuredRoot = root;
+        if (Object.getPrototypeOf(this) === RealFileSystem.prototype) {
+            plainDevicePathResolvers.set(this, async (path, options) => {
+                if (this.lstat !== realImplementation.lstat?.value || this.readlink !== realImplementation.readlink?.value)
+                    return undefined;
+                try {
+                    let target = await this.root(options);
+                    const components = path.slice(1).split("/");
+                    for (let index = 0; index < components.length; index++) {
+                        options.signal?.throwIfAborted();
+                        target = join(target, components[index]);
+                        const stat = await native.lstat(target);
+                        options.signal?.throwIfAborted();
+                        if ((!stat.isFile() && !stat.isDirectory()) || (index < components.length - 1 && !stat.isDirectory()))
+                            return undefined;
+                    }
+                    return path;
+                }
+                catch {
+                    options.signal?.throwIfAborted();
+                    // Missing entries, symlinks and other failures use generic routing.
+                    return undefined;
+                }
+            });
+        }
         this.renameNoReplace = typeof options === "string" ? undefined : options.renameNoReplace;
         if (this.renameNoReplace !== undefined) {
             if (!platform.nativeFileSystem.atomicRename)
@@ -140,10 +165,15 @@ export class RealFileSystem {
         })();
         const root = await this.rootPromise;
         options.signal?.throwIfAborted();
-        if (await native.realpath(root) !== root)
+        const [canonical, metadata] = await Promise.allSettled([native.realpath(root), native.stat(root)]);
+        if (canonical.status === "rejected")
+            throw canonical.reason;
+        if (canonical.value !== root)
             throw new FsError("EACCES");
         options.signal?.throwIfAborted();
-        if (!(await native.stat(root)).isDirectory())
+        if (metadata.status === "rejected")
+            throw metadata.reason;
+        if (!metadata.value.isDirectory())
             throw new FsError("ENOTDIR");
         options.signal?.throwIfAborted();
         return root;

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

@@ -131,5 +131,9 @@ processing-instruction targets through source windows. Their events have an empt
 `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. Element and attribute names still require their
-own memory budget.
+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,3 +1,4 @@
+import type { XmlSourceSpan } from "./source.js";
 import type { XmlNamespaceScope } from "./frames.js";
 export interface XmlAttributeRecord {
     name: string;
@@ -5,6 +6,9 @@ export interface XmlAttributeRecord {
     localName: string;
     value: string;
     next: number;
+    nameSource?: XmlSourceSpan;
+    localNameSource?: XmlSourceSpan;
+    prefixSource?: XmlSourceSpan;
     source?: {
         start: number;
         end: number;
@@ -20,10 +24,12 @@ export type XmlAttributeRequest = {
     attributeOperation: 'has' | 'expanded';
     state: XmlAttributeState;
     name: string;
+    nameSource?: XmlSourceSpan;
     found?: boolean;
     namespace?: {
         scope: XmlNamespaceScope;
         prefix: string;
+        prefixSource?: XmlSourceSpan;
     };
 } | {
     attributeOperation: 'append';
@@ -49,14 +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, namespace?: {
         scope: XmlNamespaceScope;
         prefix: string;
-    }): Generator<XmlAttributeRequest, boolean, void>;
+        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, namespace) {
+    *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, ...(namespace ? { namespace } : {}) };
+        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,4 @@
-import type { XmlSourceStep } from './source.js';
+import type { XmlSourceStep, XmlSourceSpan } from './source.js';
 import type { XmlContent, XmlElement, XmlName } from './index.js';
 export interface XmlParserFrame {
     element: XmlElement;
@@ -37,27 +37,31 @@ 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 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 namespaceMetadata(scope: Map<string, string> | XmlNamespaceScope, prefix: string, deferred?: boolean): Generator<XmlNamespaceRequest, Pick<XmlName, 'namespace' | 'namespaceReference'>, void>;
-export declare function hasNamespace(scope: Map<string, string> | XmlNamespaceScope, prefix: string): Generator<XmlNamespaceRequest, boolean, void>;
-export declare function bindNamespace(scope: Map<string, string> | XmlNamespaceScope, prefix: string, value: string | Generator<XmlSourceStep | string, void, void>): 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,43 +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* namespaceMetadata(scope, prefix, deferred = false) {
+export function* namespaceMetadata(scope, prefix, deferred = false, prefixSource) {
     if (!deferred || scope instanceof Map)
-        return { namespace: (yield* namespaceValue(scope, prefix)) ?? '' };
+        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 };
+    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) {
+export function* hasNamespace(scope, prefix, prefixSource) {
     if (scope instanceof Map)
         return scope.has(prefix);
-    const request = { namespaceOperation: 'has', scope, 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) {
+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

@@ -9,6 +9,13 @@ 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;
@@ -72,6 +79,10 @@ export interface XmlSourceLimits extends XmlStepLimits {
     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

@@ -70,7 +70,7 @@ function qualifiedNameSync(name, cache) {
 }
 /** Validate a name span without retaining its spelling. */
 function* validateNameSpan(source, start, end) {
-    let first = true, colon = false, work = 0;
+    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) {
@@ -79,9 +79,9 @@ function* validateNameSpan(source, start, end) {
                 point = 0x10000 + (point - 0xd800) * 1024 + low - 0xdc00;
         }
         if (point === 58) {
-            if (colon || first)
+            if (colon >= 0 || first)
                 invalid("invalid qualified name");
-            colon = true;
+            colon = offset;
             first = true;
         }
         else {
@@ -101,6 +101,7 @@ function* validateNameSpan(source, start, end) {
         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.
@@ -294,6 +295,10 @@ 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)
@@ -360,7 +365,24 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         }
         return offset - start;
     };
-    const scanName = function* (defer = false) {
+    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));
@@ -374,8 +396,19 @@ export function* parseXmlSourceSteps(length, limits = {}) {
             }
         }
         if (defer && offset - start > 512) {
-            yield* validateNameSpan(source, start, offset);
-            return ["", "", "", { start, end: offset }];
+            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;
@@ -536,7 +569,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
         else if ((yield* source.startsWith("<?", offset))) {
             const start = offset;
             offset += 2;
-            const [target, , , targetSource] = yield* scanName(limits.deferContentNames);
+            const [target, , , targetSource] = yield* scanName(limits.deferContentNames ? "content" : undefined);
             while (pendingWork >= 512) {
                 yield 512;
                 pendingWork -= 512;
@@ -578,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");
@@ -596,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.
@@ -623,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");
@@ -693,13 +726,14 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     }
                     admitText(value);
                 }
-                yield* attributes.append(attribute, attrPrefix, attrLocal, value, limits.fragmentAttributes ? { 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 (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 !== "" && (fragmented ? size === 0 : value === "")))
+                        || ((nsPrefix !== "" || nsPrefixSource) && (fragmented ? size === 0 : value === "")))
                         invalid("invalid namespace binding");
                     if (!ownsNamespaces && namespaces instanceof Map) {
                         const copy = new Map();
@@ -711,7 +745,7 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                         ownsNamespaces = true;
                     }
                     namespaces = yield* bindNamespace(namespaces, nsPrefix, fragmented
-                        ? textFragments(source, valueStart, end, true, limits.recover ? () => { } : undefined, true) : value);
+                        ? textFragments(source, valueStart, end, true, limits.recover ? () => { } : undefined, true) : value, nsPrefixSource);
                     if (namespaces.size > maxNamespaces)
                         throw new XmlLimitError("maxNamespaces", "XML namespace scope limit exceeded");
                 }
@@ -721,15 +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* hasNamespace(namespaces, attrPrefix)))
+                    if ((attrPrefix || record.prefixSource) && !(yield* hasNamespace(namespaces, attrPrefix, record.prefixSource)))
                         invalid("unbound attribute prefix");
                     if (attributes.length > 1) {
                         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 } : undefined))
+                        if (yield* attributes.expanded(key, backed ? { scope: backed, prefix: attrPrefix, ...(record.prefixSource ? { prefixSource: record.prefixSource } : {}) } : undefined, record.localNameSource))
                             invalid("duplicate expanded attribute");
                     }
                 }
@@ -739,14 +773,15 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                 yield 512;
                 pendingWork -= 512;
             }
-            if (prefix === "xmlns" || (prefix && !(yield* hasNamespace(namespaces, prefix))))
+            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* namespaceMetadata(namespaces, prefix, limits.deferNamespaces);
-            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) {
@@ -766,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) {
@@ -788,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) {
@@ -797,7 +832,8 @@ export function* parseXmlSourceSteps(length, limits = {}) {
                     const attribute = yield* attributes.read(cursor, true);
                     cursor = attribute.next;
                     const namespace = attribute.name === "xmlns" || attribute.prefix === "xmlns" ? { namespace: xmlnsNamespace }
-                        : attribute.prefix ? yield* namespaceMetadata(namespaces, attribute.prefix, limits.deferNamespaces) : { namespace: "" };
+                        : 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)) {
@@ -805,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/tiny-stdio-mcp-server/dist/composition.json

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

package/node_modules/toolcraft-design/dist/explorer/detail-content.js

@@ -6,7 +6,7 @@ export function prepareDetailContent(content, width) {
         return { text: "", lines: [[]] };
     }
     width = Math.max(1, width);
-    const key = `${contentHash(content)}:${width}`;
+    const key = `${width}:${content}`;
     const cached = markdownCache.get(key);
     if (cached !== undefined)
         return cached;
@@ -22,11 +22,3 @@ export function prepareDetailContent(content, width) {
     markdownCache.set(key, prepared);
     return prepared;
 }
-function contentHash(content) {
-    let hash = 2166136261;
-    for (let index = 0; index < content.length; index += 1) {
-        hash ^= content.charCodeAt(index);
-        hash = Math.imul(hash, 16777619);
-    }
-    return hash >>> 0;
-}

package/node_modules/toolcraft-design/dist/explorer/keymap.js

@@ -112,6 +112,6 @@ function canonical(value) { return value.trim().toLowerCase().replace("control+"
 function eventKey(event) {
     const name = event.name ?? event.ch ?? "";
     const modifiers = [event.ctrl ? "ctrl" : "", event.meta ? "meta" : "", event.shift ? "shift" : ""].filter(Boolean);
-    const normalized = name === "return" ? "return" : name.toLowerCase();
+    const normalized = name === " " ? "space" : name.toLowerCase();
     return [...modifiers, normalized].join("+");
 }

package/node_modules/toolcraft-design/dist/explorer/reducer.js

@@ -941,7 +941,7 @@ function isBackspace(key) {
     return key.name === "backspace" || key.name === "delete";
 }
 function isSelectionSpace(key) {
-    return key.name === "space" || key.ch === " ";
+    return key.name !== "paste" && (key.name === "space" || key.ch === " ");
 }
 function isConfirmYes(key) {
     return key.ch === "y" || key.ch === "Y";

package/node_modules/toolcraft-design/dist/explorer/runtime.js

@@ -101,7 +101,8 @@ class ExplorerRuntime {
                 for (const ch of event.text.replaceAll("\n", "").replaceAll("\r", "")) {
                     this.dispatch({
                         type: "key",
-                        key: { ch, name: ch, ctrl: false, meta: false, shift: false }
+                        // Pasted characters are text, even when they have a key binding.
+                        key: { ch, name: "paste", ctrl: false, meta: false, shift: false }
                     });
                 }
                 return;

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.800",
+  "version": "0.0.802",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

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