@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/node_modules/@poe-code/user-error/README.md

@@ -0,0 +1,56 @@
+# @poe-code/user-error
+
+The shared user-error type every workspace package throws for expected user
+mistakes, and the guard the CLI renders them with.
+
+`src/cli/errors.ts` cannot be imported from `packages/*`, so package code used to
+throw a plain `Error` for recoverable conditions. `src/cli/bootstrap.ts` then
+treated each one as a crash: an `Error:` prefix plus a `See logs at
+~/.poe-code/logs/errors.log` pointer to a log that adds nothing for a typo. This
+package gives packages a classification the CLI honours.
+
+## Usage
+
+```ts
+import { UserError, isUserError } from "@poe-code/user-error";
+
+throw new UserError('Unknown agent "clyde". Try: claude, codex, gemini.');
+
+throw new UserError("No API key found.", {
+  hint: "Create one at https://poe.com/api_key",
+  cause: readError
+});
+
+if (isUserError(error)) {
+  // render the message as guidance: no stack trace, no log pointer
+}
+```
+
+Throw a `UserError` when the user can fix the condition themselves, and say how:
+name the value that was rejected and the valid ones, the path that was searched,
+or the URL that issues the key. Keep plain `Error` for genuine failures — those
+should reach the log.
+
+## Public API
+
+- `UserError`: `Error` subclass with `name === "UserError"` and an optional
+  `hint` for the recovery step. Accepts the standard `cause` option.
+- `isUserError(error)`: true for a `UserError` **or** any `Error` whose `name` is
+  `"UserError"`.
+
+## Cross-bundle recognition
+
+`isUserError` matches on `error.name`, not `instanceof`. `toolcraft` publishes its
+own `UserError` (`packages/toolcraft/src/user-error.ts`) as a separately released
+framework, and an instance crossing a bundle boundary fails `instanceof` against
+this package's class. Name matching recognises both, and mirrors the existing
+`isSilentError()` precedent in `src/cli/errors.ts`. toolcraft deliberately does
+not depend on this package — the coupling would run the wrong way.
+
+## Config Options
+
+This package reads no configuration.
+
+## Environment Variables
+
+This package reads no environment variables.

package/node_modules/toolcraft/node_modules/@poe-code/user-error/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * An expected user mistake: bad input, a missing file, an unknown id, absent
+ * credentials. Thrown where the condition is detected so the CLI can render the
+ * message as guidance instead of dressing it in system-failure chrome.
+ */
+export declare class UserError extends Error {
+    readonly hint?: string;
+    constructor(message: string, options?: ErrorOptions & {
+        hint?: string;
+    });
+}
+/**
+ * Detects user errors by name as well as identity, so an instance created in
+ * another bundle (toolcraft publishes its own `UserError`) is still recognised
+ * where `instanceof` would fail.
+ */
+export declare function isUserError(error: unknown): boolean;

package/node_modules/toolcraft/node_modules/@poe-code/user-error/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * An expected user mistake: bad input, a missing file, an unknown id, absent
+ * credentials. Thrown where the condition is detected so the CLI can render the
+ * message as guidance instead of dressing it in system-failure chrome.
+ */
+export class UserError extends Error {
+    hint;
+    constructor(message, options) {
+        super(message, options);
+        this.name = "UserError";
+        this.hint = options?.hint;
+    }
+}
+/**
+ * Detects user errors by name as well as identity, so an instance created in
+ * another bundle (toolcraft publishes its own `UserError`) is still recognised
+ * where `instanceof` would fail.
+ */
+export function isUserError(error) {
+    return error instanceof Error && error.name === "UserError";
+}

package/node_modules/toolcraft/node_modules/{mcp-oauth → @poe-code/user-error}/package.json

@@ -1,7 +1,6 @@
 {
-  "name": "mcp-oauth",
-  "version": "0.0.1",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,13 +11,8 @@
     }
   },
   "scripts": {
-    "build": "tsc"
-  },
-  "dependencies": {
-    "jose": "^6.1.2"
-  },
-  "devDependencies": {
-    "tiny-oauth-test-server": "*"
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
+    "test:unit": "cd ../.. && vitest run packages/user-error/src"
   },
   "files": [
     "dist"
@@ -26,6 +20,6 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/poe-platform/poe-code.git",
-    "directory": "packages/mcp-oauth"
+    "directory": "packages/user-error"
   }
 }

package/node_modules/toolcraft/node_modules/@poe-code/xml-ast/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,139 @@
+# XML AST
+
+Read XML as namespace-aware elements, attributes, text, CDATA, comments, and processing instructions in Node.js, browsers, and Workers. The parser has no filesystem, network, or Node.js dependencies.
+
+```ts
+import { parseXml, XmlLimitError } from "@poe-code/xml-ast";
+
+const document = parseXml(
+  '<doc xmlns="urn:example"><name>A &amp; B</name></doc>',
+  { maxDepth: 16, maxNodes: 1000, maxTextLength: 100_000 }
+);
+console.log(document.namespace);        // urn:example
+console.log(document.children[0].text); // A & B
+```
+
+| API | Use |
+| --- | --- |
+| `parseXml(source, limits?)` | Parse a string into an `XmlElement`. |
+| `parseXmlStream(chunks, limits?, checkpoint?)` | Consume synchronous or asynchronous string chunks into an `XmlElement`. |
+| `parseXmlSteps(source, limits?)` | Advance a parser through work checkpoints; the generator returns the completed element. |
+| `XmlLimitError` | Inspect which configured resource limit was exceeded through its `limit` property. |
+| `XmlElement`, `XmlContent`, `XmlAttribute`, `XmlName`, `XmlLimits`, `XmlStreamLimits` | Describe and consume the XML tree without Node.js types. |
+
+Pass positive integer limits for depth, element and content counts, attributes, namespaces, and text. Omitted limits are unlimited. `retainContent` preserves ordered mixed content; `onElement` observes element names, parents, and depths during parsing. `expectedEncoding` checks an XML declaration against the caller's decoded input.
+
+`parseXmlSteps` yields work counts so a host can account for parsing and yield between checkpoints. Syntax errors and resource limits remain errors by default; parsing never fetches external entities.
+Pass `recover: message => report(message)` to repair truncated elements,
+mismatched closing tags, and undeclared entities. Each repair calls the callback.
+Resource limits and the prohibition on DTDs remain in force. With `retainTree: false`,
+`parseXmlSteps` discards completed nodes and can emit synchronous `events`, including
+repaired closing events. Drain events between generator checkpoints to await
+external storage; the source string and open parser frames remain resident.
+
+`parseXmlStream` consumes each chunk before requesting the next and calls the optional asynchronous checkpoint with at most 512 UTF-16 units. It preserves the buffered parser’s tree shape, namespaces and retained content. The source is closed on parsing or checkpoint failure. Decode byte sources incrementally before passing their strings. This avoids a full source string; the resulting tree and individual XML tokens still reside in memory. Recovery is available through `parseXmlSteps` or the externally backed source API.
+
+For validation or root-name detection, pass `retainTree: false` to `parseXmlStream`. It validates the complete document and enforces the same limits, but returns a root element with empty data fields. Only open element frames, namespace scopes and current parser tokens remain resident; completed descendants, text, attributes and document content are not retained. `onElement` still observes each element.
+
+Use `streamElements: { matches, consume }` to process selected complete subtrees asynchronously. Matching non-root elements are detached from their parent; nested matches remain inside the selected ancestor. `consume(element, parent, before?)` runs in source order and is awaited before the next 512-unit parse window. The producer closes on consumer failure. This mode requires normal tree/content retention and retains each selected subtree until consumption; individual large subtrees and XML tokens still need their own storage strategy.
+
+Set `streamElements.captureBefore: true` to detach preceding sibling content when each subtree is selected and receive it as `before`. This preserves text, CDATA, comments and sibling order even when multiple subtrees share one parse window. The remaining trailing content stays in the parent. Store both `before` and the subtree when you need to reconstruct the original mixed content.
+
+`parseXmlStream` also accepts `events` with `retainTree: false` to consume ordered
+open, content and close events without constructing a document tree. Each parser
+window awaits the consumer before advancing. Event elements contain names,
+attributes and namespace metadata; individual XML tokens and open ancestry still
+remain resident. This mode lets a caller own document storage independently of
+the codec. Consumer failures propagate unchanged and close the input iterator.
+
+`normalizeXmlChunks(chunks)` validates XML characters and normalizes BOM/line endings
+in windows of at most 513 UTF-16 units, preserving surrogate pairs across chunks.
+Store those windows in caller-owned backing and drive `parseXmlSourceSteps(length,
+limits)`: numbers are work checkpoints; read requests specify UTF-16 `offset` and
+`length` (at most 4096 units). Fill each request's `value` before advancing the
+iterator. The source must already be validated and normalized. This supports the
+same repairs and events without a complete source string; tokens and open ancestry
+still remain resident. Close the iterator and backing on errors or cancellation.
+
+For tree-free external parsing, set `storeFrames: true` alongside `retainTree: false`.
+The iterator also yields `frameOperation` requests: `push` saves the supplied frame,
+`pop` removes the latest frame, and `peek` needs its `frame` filled with the saved
+metadata. Keep the host stack in bounded backing storage. The parser caches one
+current frame; individual frame metadata and namespace scopes still have their own
+size cost. The default string and stream APIs retain their existing ancestry behavior.
+
+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 `"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. 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. 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 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`. 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
+prefix available without pulling more input; set `complete: true` only when that
+read reaches EOF (an empty EOF read is valid). Earlier offsets may be requested
+again, so retain source spans in caller-backed storage. With `normalizeXmlChunks`,
+pass `true` as the second argument to flush at input-chunk boundaries and preserve
+early parser failures. The string parser and known-length protocol are unchanged.
+
+With `retainTree: false`, `parseXmlSourceSteps` accepts `fragmentContent: true`
+to emit text, CDATA, comment and processing-instruction bodies in at most 512 UTF-16 units without splitting surrogate
+pairs. Content events with `continuation: true` belong to the preceding logical
+node; store their bodies separately and retain one node identity. Yielded steps
+let the host await each fragment before parsing more. Text validation and entity
+decoding replay bounded source windows before publishing a logical node, retaining
+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.
+
+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/toolcraft/node_modules/@poe-code/xml-ast/dist/attributes.d.ts

@@ -0,0 +1,69 @@
+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;
+    };
+}
+export interface XmlAttributeState {
+    reference: number;
+    first: number;
+    length: number;
+    size: number;
+}
+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;
+    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, nameSource?: XmlSourceSpan): Generator<XmlAttributeRequest, boolean, void>;
+    append(name: string, prefix: string, localName: string, value: string, source?: {
+        start: number;
+        end: number;
+    }, 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;
+        prefixSource?: XmlSourceSpan;
+    }, nameSource?: XmlSourceSpan): Generator<XmlAttributeRequest, boolean, void>;
+}

package/node_modules/toolcraft/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, nameSource) {
+        if (!this.length)
+            return false;
+        if (!this.external)
+            return this.names.has(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, 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 } : {}), ...(nameSource ? { nameSource } : {}), ...(localNameSource ? { localNameSource } : {}), ...(prefixSource ? { prefixSource } : {}) } };
+        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, 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 } : {}), ...(nameSource ? { nameSource } : {}) };
+        yield request;
+        if (request.found === undefined)
+            throw new TypeError('Incomplete XML expanded attribute lookup');
+        return request.found;
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare function validCharacter(point: number): boolean;
+/** Validate scalar values and normalize XML line endings in fixed windows. */
+export declare function normalizeXmlChunks(source: AsyncIterable<string> | Iterable<string>, flushChunks?: boolean): AsyncGenerator<string>;

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

@@ -0,0 +1,53 @@
+export function validCharacter(point) {
+    return point === 9 || point === 10 || point === 13
+        || (point >= 0x20 && point <= 0xd7ff)
+        || (point >= 0xe000 && point <= 0xfffd)
+        || (point >= 0x10000 && point <= 0x10ffff);
+}
+/** Validate scalar values and normalize XML line endings in fixed windows. */
+export async function* normalizeXmlChunks(source, flushChunks = false) {
+    let first = true, afterCR = false, high = 0, output = '';
+    for await (const chunk of source) {
+        for (let index = 0; index < chunk.length; index++) {
+            const code = chunk.charCodeAt(index);
+            if (first) {
+                first = false;
+                if (code === 0xfeff)
+                    continue;
+            }
+            if (high) {
+                if (code < 0xdc00 || code > 0xdfff)
+                    throw new SyntaxError('Invalid XML: invalid character');
+                output += String.fromCharCode(high, code);
+                high = 0;
+            }
+            else {
+                if (afterCR) {
+                    afterCR = false;
+                    if (code === 10)
+                        continue;
+                }
+                if (code >= 0xd800 && code <= 0xdbff) {
+                    high = code;
+                    continue;
+                }
+                if (!validCharacter(code))
+                    throw new SyntaxError('Invalid XML: invalid character');
+                afterCR = code === 13;
+                output += code === 13 ? '\n' : chunk[index];
+            }
+            if (output.length >= 512) {
+                yield output;
+                output = '';
+            }
+        }
+        if (flushChunks && output) {
+            yield output;
+            output = '';
+        }
+    }
+    if (high)
+        throw new SyntaxError('Invalid XML: invalid character');
+    if (output)
+        yield output;
+}

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

@@ -0,0 +1,4 @@
+export declare class XmlLimitError extends SyntaxError {
+    readonly limit: string;
+    constructor(limit: string, message: string);
+}

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

@@ -0,0 +1,7 @@
+export class XmlLimitError extends SyntaxError {
+    limit;
+    constructor(limit, message) {
+        super(message);
+        this.limit = limit;
+    }
+}

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

@@ -0,0 +1,67 @@
+import type { XmlSourceStep, XmlSourceSpan } from './source.js';
+import type { XmlContent, XmlElement, XmlName } from './index.js';
+export interface XmlParserFrame {
+    element: XmlElement;
+    content: XmlContent[] | undefined;
+    name: string;
+    namespaces: Map<string, string>;
+    namespaceScope?: XmlNamespaceScope;
+}
+export type XmlFrameRequest = {
+    readonly frameOperation: 'push';
+    readonly frame: XmlParserFrame;
+} | {
+    readonly frameOperation: 'pop';
+} | {
+    readonly frameOperation: 'peek';
+    frame?: XmlParserFrame;
+};
+/** External mode caches only the current frame. The host owns the linked stack. */
+export declare class XmlFrames {
+    private readonly external;
+    private readonly frames;
+    private depth;
+    private current;
+    constructor(external: boolean);
+    get length(): number;
+    peek(): Generator<XmlFrameRequest, XmlParserFrame | undefined, void>;
+    push(frame: XmlParserFrame): Generator<XmlFrameRequest, void, void>;
+    pop(): Generator<XmlFrameRequest, XmlParserFrame | undefined, void>;
+}
+/** A host-owned immutable namespace scope; count includes the built-in xml prefix. */
+export interface XmlNamespaceScope {
+    readonly reference: number;
+    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 prefixSource?: XmlSourceSpan;
+    readonly value: string | Generator<XmlSourceStep | string, void, void>;
+    result?: XmlNamespaceScope;
+};
+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/toolcraft/node_modules/@poe-code/xml-ast/dist/frames.js

@@ -0,0 +1,87 @@
+/** External mode caches only the current frame. The host owns the linked stack. */
+export class XmlFrames {
+    external;
+    frames = [];
+    depth = 0;
+    current;
+    constructor(external) {
+        this.external = external;
+    }
+    get length() { return this.external ? this.depth : this.frames.length; }
+    *peek() {
+        if (!this.external)
+            return this.frames.at(-1);
+        if (!this.depth)
+            return undefined;
+        if (!this.current) {
+            const request = { frameOperation: 'peek' };
+            yield request;
+            if (!request.frame)
+                throw new TypeError('Incomplete XML frame read');
+            this.current = request.frame;
+        }
+        return this.current;
+    }
+    *push(frame) {
+        if (!this.external) {
+            this.frames.push(frame);
+            return;
+        }
+        yield { frameOperation: 'push', frame };
+        this.current = frame;
+        this.depth++;
+    }
+    *pop() {
+        if (!this.external)
+            return this.frames.pop();
+        if (!this.depth)
+            return undefined;
+        const frame = yield* this.peek();
+        yield { frameOperation: 'pop' };
+        this.depth--;
+        this.current = undefined;
+        return frame;
+    }
+}
+export function* namespaceValue(scope, prefix, prefixSource) {
+    if (scope instanceof Map)
+        return scope.get(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, 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, ...(prefixSource ? { prefixSource } : {}) };
+    yield request;
+    if (!request.result)
+        throw new TypeError('Incomplete XML namespace update');
+    return request.result;
+}