@wirebench/engine 2.2.1 → 3.1.0-rc.1

package/dist/wss/apply.js

@@ -12,7 +12,7 @@ import { buildTimestamp } from './outgoing/timestamp.js';
 import { buildUsernameToken } from './outgoing/username-token.js';
 import { signEnvelope } from './outgoing/signature.js';
 import { encryptEnvelope } from './outgoing/encryption.js';
-import { selectAlias } from './keystore/index.js';
+import { selectAlias } from '../keystore/index.js';
 import { actorAttribute, childElement, mustUnderstandValue, securityHeaders, securityActor, } from './security-header.js';
 /** The namespace `xmlns:*` declarations themselves live in. */
 const XMLNS = 'http://www.w3.org/2000/xmlns/';

package/dist/{project/wss-configs.d.ts → wss/configs.d.ts}

@@ -4,8 +4,8 @@
  * survives) and the typed configurations the WS-Security code takes — the same shape as
  * `project/keystores.ts` does for the keystore registry.
  */
-import type { WssRef } from './model.js';
-import type { WssIncomingConfig, WssOutgoingConfig } from '../wss/model.js';
+import type { WssRef } from '../project/model.js';
+import type { WssIncomingConfig, WssOutgoingConfig } from './model.js';
 /**
  * Reads one outgoing configuration out of its `WssRef`.
  *

package/dist/{project/wss-configs.js → wss/configs.js}

@@ -5,8 +5,8 @@
  * `project/keystores.ts` does for the keystore registry.
  */
 import { ProjectError } from '../errors.js';
-import { wssEntrySchema, wssIncomingFileSchema, wssOutgoingFileSchema } from './schema.js';
-import { DEFAULT_WSS_TIMESTAMP_SKEW_SECONDS } from '../wss/model.js';
+import { wssEntrySchema, wssIncomingFileSchema, wssOutgoingFileSchema } from '../project/schema.js';
+import { DEFAULT_WSS_TIMESTAMP_SKEW_SECONDS } from './model.js';
 /**
  * One stored entry as a typed {@link WssEntry}. An entry this build does not understand (a
  * signature written by a later build, say) is carried through verbatim rather than dropped;

package/dist/wss/incoming/decrypt.d.ts

@@ -7,7 +7,7 @@
  * that was not encrypted — so the caller gets the document back unchanged rather than a
  * `wss-decrypt-failed` it would have to special-case.
  */
-import type { Keystore, KeystoreAlias } from '../keystore/model.js';
+import type { Keystore, KeystoreAlias } from '../../keystore/model.js';
 /** The keystore material {@link decryptIncoming} opens an `xenc:EncryptedKey` with. */
 export interface ResolvedDecryptionKey {
     readonly keystore: Keystore;

package/dist/wss/incoming/index.js

@@ -8,7 +8,7 @@
  * the server sent, not to hide it. The caller decides what to make of that.
  */
 import { isWirebenchError } from '../../errors.js';
-import { selectAlias } from '../keystore/index.js';
+import { selectAlias } from '../../keystore/index.js';
 import { decryptIncoming } from './decrypt.js';
 import { verifyIncoming } from './verify.js';
 /** The message of a thrown value, without the stack or any `details` a secret could hide in. */

package/dist/wss/incoming/verify.d.ts

@@ -15,7 +15,7 @@
  *
  * `KeyInfo` is therefore a *hint* about which key to look up, never a source of trust.
  */
-import type { Keystore } from '../keystore/model.js';
+import type { Keystore } from '../../keystore/model.js';
 /** One `ds:Signature` as {@link verifyIncoming} judged it. */
 export interface IncomingSignatureResult {
     /** The signature held over the bytes that arrived. */

package/dist/wss/incoming/verify.js

@@ -19,7 +19,7 @@ import forge from 'node-forge';
 import { NS } from '../../xml/namespaces.js';
 import { parseXml } from '../../xml/parse.js';
 import { serializeXml } from '../../xml/serialize.js';
-import { renderDn, renderDnRfc2253 } from '../keystore/certificate.js';
+import { renderDn, renderDnRfc2253 } from '../../keystore/certificate.js';
 import { certificateBase64, subjectKeyIdentifierBase64, thumbprintSha1Base64, WSS_TOKEN_TYPES, } from '../key-identifiers.js';
 import { childElement, findElement } from '../security-header.js';
 import { verifySignature } from '../outgoing/signature.js';

package/dist/wss/key-identifiers.js

@@ -11,7 +11,7 @@ import { createHash } from 'node:crypto';
 import forge from 'node-forge';
 import { WssError } from '../errors.js';
 import { NS } from '../xml/namespaces.js';
-import { renderDnRfc2253 } from './keystore/certificate.js';
+import { renderDnRfc2253 } from '../keystore/certificate.js';
 /** `ValueType`/`EncodingType` URIs from the WS-Security X.509 token profile. */
 export const WSS_TOKEN_TYPES = {
     /** A single DER-encoded certificate. */

package/dist/wss/model.d.ts

@@ -4,7 +4,7 @@
  * every builder takes (so nothing here reads a keystore, a secret, the clock or the entropy
  * pool on its own — the host supplies all four, and tests supply deterministic ones).
  */
-import type { Keystore } from './keystore/model.js';
+import type { Keystore } from '../keystore/model.js';
 /** How a `wsse:UsernameToken` carries (or does not carry) its password. */
 export type WssPasswordType = 'text' | 'digest' | 'none';
 /** A `wsu:Timestamp` header element. */

package/dist/wss/outgoing/encryption.d.ts

@@ -20,7 +20,7 @@
  * *signature* entry earlier in the same configuration may already have swapped the document.
  */
 import type { Document } from '@xmldom/xmldom';
-import type { Keystore, KeystoreAlias } from '../keystore/model.js';
+import type { Keystore, KeystoreAlias } from '../../keystore/model.js';
 import type { WssContext, WssEncryptionEntry } from '../model.js';
 /** The keystore material {@link encryptEnvelope} encrypts *to*; only the certificate is used. */
 export interface ResolvedEncryptionKey {

package/dist/wss/outgoing/signature.d.ts

@@ -9,7 +9,7 @@
  * after each signature entry for exactly that reason.
  */
 import type { Document } from '@xmldom/xmldom';
-import type { Keystore, KeystoreAlias } from '../keystore/model.js';
+import type { Keystore, KeystoreAlias } from '../../keystore/model.js';
 import type { WssContext, WssSignatureEntry } from '../model.js';
 /** The keystore material {@link signEnvelope} signs with, resolved by the caller. */
 export interface ResolvedSigningKey {

package/dist/xml/decode.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Reading the bytes of an XML document as text.
+ *
+ * In `xml/` because every definition fetcher decodes what it fetched, whatever the protocol, and
+ * core imports no protocol folder (protocol modules spec §7.2).
+ */
+/**
+ * Decodes bytes as UTF-8, honouring an `<?xml ... encoding="iso-8859-1" ?>`
+ * declaration when present (single-byte, so it is safely sniffable by
+ * decoding the head as UTF-8 first). A `utf-16` declaration would require a
+ * BOM/byte-order sniff before the declaration itself is even legible, which
+ * does not fit a small helper like this — such documents fall back to (and
+ * garble under) UTF-8; use a pre-fetched `text` in that case instead.
+ */
+export declare function decodeXmlBytes(bytes: Uint8Array): string;

package/dist/xml/decode.js

@@ -0,0 +1,22 @@
+/**
+ * Reading the bytes of an XML document as text.
+ *
+ * In `xml/` because every definition fetcher decodes what it fetched, whatever the protocol, and
+ * core imports no protocol folder (protocol modules spec §7.2).
+ */
+/**
+ * Decodes bytes as UTF-8, honouring an `<?xml ... encoding="iso-8859-1" ?>`
+ * declaration when present (single-byte, so it is safely sniffable by
+ * decoding the head as UTF-8 first). A `utf-16` declaration would require a
+ * BOM/byte-order sniff before the declaration itself is even legible, which
+ * does not fit a small helper like this — such documents fall back to (and
+ * garble under) UTF-8; use a pre-fetched `text` in that case instead.
+ */
+export function decodeXmlBytes(bytes) {
+    const head = new TextDecoder('utf-8').decode(bytes.subarray(0, 200));
+    const match = /^\s*<\?xml[^>]*\bencoding=["']([^"']+)["']/i.exec(head);
+    if (match?.[1]?.toLowerCase() === 'iso-8859-1') {
+        return new TextDecoder('iso-8859-1').decode(bytes);
+    }
+    return new TextDecoder('utf-8').decode(bytes);
+}

package/dist/xml/entitize.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Escaping a value that lands inside XML text.
+ *
+ * In `xml/` because property expansion (`project/properties.ts`) applies it for every protocol,
+ * and core imports no protocol folder (protocol modules spec §7.2). `soap/transforms.ts` re-exports
+ * it beside the envelope transforms it has always sat with.
+ */
+/**
+ * "Entitize Properties", applied to one substituted property value: escapes the three
+ * characters that would otherwise be read as markup once the value lands inside an envelope.
+ *
+ * `"` and `'` are deliberately left alone: expansion targets element content far more often
+ * than an attribute value, and escaping quotes there would show up as `"` in the payload.
+ *
+ * @param value the expanded property value
+ */
+export declare function entitizeValue(value: string): string;

package/dist/xml/entitize.js

@@ -0,0 +1,19 @@
+/**
+ * Escaping a value that lands inside XML text.
+ *
+ * In `xml/` because property expansion (`project/properties.ts`) applies it for every protocol,
+ * and core imports no protocol folder (protocol modules spec §7.2). `soap/transforms.ts` re-exports
+ * it beside the envelope transforms it has always sat with.
+ */
+/**
+ * "Entitize Properties", applied to one substituted property value: escapes the three
+ * characters that would otherwise be read as markup once the value lands inside an envelope.
+ *
+ * `"` and `'` are deliberately left alone: expansion targets element content far more often
+ * than an attribute value, and escaping quotes there would show up as `"` in the payload.
+ *
+ * @param value the expanded property value
+ */
+export function entitizeValue(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}

package/dist/xml/index.d.ts

@@ -4,4 +4,4 @@
  * into the Electron renderer.
  */
 export { formatXml, type FormatXmlOptions, type FormatXmlResult } from './pretty.js';
-export { elementPathAt, completionContextAt, type CompletionContext, type TextRange } from '../xsd/locate.js';
+export { elementPathAt, completionContextAt, type CompletionContext, type TextRange } from './locate.js';

package/dist/xml/index.js

@@ -4,4 +4,4 @@
  * into the Electron renderer.
  */
 export { formatXml } from './pretty.js';
-export { elementPathAt, completionContextAt } from '../xsd/locate.js';
+export { elementPathAt, completionContextAt } from './locate.js';

package/dist/xml/locate.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Where a cursor is in an XML text: the element path at an offset, and what a completion would
+ * replace. Pure text, no DOM and no schema, so it is safe in the browser subpath (`xml/index.ts`).
+ *
+ * In `xml/` because core's XML and XPath helpers use it and core imports no protocol folder
+ * (protocol modules spec §7.2). `xsd/locate.ts` keeps the half that reads a schema set, and
+ * re-exports these names.
+ */
+import type { QName } from './qname.js';
+/** A half-open character range in a text document. */
+export interface TextRange {
+    readonly start: number;
+    readonly end: number;
+}
+/** What the completion provider needs to offer children of the element the cursor is in. */
+export interface CompletionContext {
+    /** Ancestor chain of the element that would contain the completed child, outermost first. */
+    readonly path: readonly QName[];
+    /** The (possibly empty) element name typed so far after `<`, including any prefix. */
+    readonly partial: string;
+    /** Namespace prefixes in scope at the cursor. */
+    readonly prefixes: Readonly<Record<string, string>>;
+    /** The range of `partial` in the document, to replace with the accepted completion. */
+    readonly replaceRange: TextRange;
+}
+/**
+ * Ancestor chain (outermost first) of the element containing `offset`,
+ * resolved to expanded QNames via the `xmlns` declarations in scope at that
+ * point in the text.
+ */
+export declare function elementPathAt(text: string, offset: number): QName[];
+/**
+ * Pure text analysis for the completion provider: detects an in-progress
+ * `<partial` element-name token ending at `offset` and reports the ancestor
+ * path, in-scope prefixes and the range to replace with the accepted item.
+ * Returns `undefined` when the cursor is not positioned right after an open
+ * `<` (e.g. mid-attribute, or not inside a tag at all).
+ */
+export declare function completionContextAt(text: string, offset: number): CompletionContext | undefined;

package/dist/xml/locate.js

@@ -0,0 +1,117 @@
+/**
+ * Where a cursor is in an XML text: the element path at an offset, and what a completion would
+ * replace. Pure text, no DOM and no schema, so it is safe in the browser subpath (`xml/index.ts`).
+ *
+ * In `xml/` because core's XML and XPath helpers use it and core imports no protocol folder
+ * (protocol modules spec §7.2). `xsd/locate.ts` keeps the half that reads a schema set, and
+ * re-exports these names.
+ */
+const OPEN_TAG_RE = /<([^\s/!?>][^\s/>]*)((?:\s+[^<>]*)?)\s*(\/?)>/g;
+const ATTR_RE = /([:\w.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+const XML_PREFIX = 'xml';
+const XML_NS = 'http://www.w3.org/XML/1998/namespace';
+/** Extracts `xmlns`/`xmlns:prefix` declarations from a tag's raw attribute text. */
+function xmlnsDeclarations(rawAttrs) {
+    const decls = {};
+    const re = new RegExp(ATTR_RE);
+    let m;
+    while ((m = re.exec(rawAttrs)) !== null) {
+        const attrName = m[1];
+        const value = m[2] ?? m[3] ?? '';
+        if (attrName === 'xmlns') {
+            decls[''] = value;
+        }
+        else if (attrName.startsWith('xmlns:')) {
+            decls[attrName.slice('xmlns:'.length)] = value;
+        }
+    }
+    return decls;
+}
+function resolvePrefixed(name, prefixes) {
+    const colon = name.indexOf(':');
+    if (colon === -1) {
+        return { namespaceUri: prefixes[''] ?? '', localName: name };
+    }
+    const prefix = name.slice(0, colon);
+    const localName = name.slice(colon + 1);
+    if (prefix === XML_PREFIX) {
+        return { namespaceUri: XML_NS, localName };
+    }
+    return { namespaceUri: prefixes[prefix] ?? '', localName };
+}
+/**
+ * Walks open/close tags textually (never a DOM parse) to find the in-scope
+ * ancestor stack ending just before `offset`. Tolerant of an unfinished tag
+ * at the cursor: a `<…` with no closing `>` yet in the text simply does not
+ * match and is ignored.
+ */
+function scopeStackAt(text, offset) {
+    const stack = [];
+    const re = new RegExp(OPEN_TAG_RE);
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const matchEnd = m.index + m[0].length;
+        if (matchEnd > offset) {
+            break;
+        }
+        const raw = m[0];
+        if (raw.startsWith('</')) {
+            // Tolerant of stray/mismatched close tags: just pop, since the source text
+            // up to the cursor is assumed well-formed for the purpose of this walk.
+            if (stack.length > 0) {
+                stack.pop();
+            }
+            continue;
+        }
+        const name = m[1].replace(/^\//, '');
+        const rawAttrs = m[2] ?? '';
+        const selfClosing = m[3] === '/';
+        const parentPrefixes = stack.length > 0 ? stack[stack.length - 1].prefixes : {};
+        const ownDecls = xmlnsDeclarations(rawAttrs);
+        const prefixes = Object.keys(ownDecls).length > 0 ? { ...parentPrefixes, ...ownDecls } : parentPrefixes;
+        const qname = resolvePrefixed(name, prefixes);
+        if (!selfClosing) {
+            stack.push({ qname, prefixes });
+        }
+    }
+    return stack;
+}
+/**
+ * Ancestor chain (outermost first) of the element containing `offset`,
+ * resolved to expanded QNames via the `xmlns` declarations in scope at that
+ * point in the text.
+ */
+export function elementPathAt(text, offset) {
+    return scopeStackAt(text, offset).map((s) => s.qname);
+}
+/**
+ * Pure text analysis for the completion provider: detects an in-progress
+ * `<partial` element-name token ending at `offset` and reports the ancestor
+ * path, in-scope prefixes and the range to replace with the accepted item.
+ * Returns `undefined` when the cursor is not positioned right after an open
+ * `<` (e.g. mid-attribute, or not inside a tag at all).
+ */
+export function completionContextAt(text, offset) {
+    const before = text.slice(0, offset);
+    const ltIndex = before.lastIndexOf('<');
+    if (ltIndex === -1) {
+        return undefined;
+    }
+    const between = text.slice(ltIndex + 1, offset);
+    if (/[\s>/]/.test(between) || between.startsWith('/')) {
+        return undefined;
+    }
+    let end = offset;
+    while (end < text.length && /[\w:.-]/.test(text[end])) {
+        end += 1;
+    }
+    const path = elementPathAt(text, ltIndex);
+    const scope = scopeStackAt(text, ltIndex);
+    const prefixes = scope.length > 0 ? scope[scope.length - 1].prefixes : {};
+    return {
+        path,
+        partial: between,
+        prefixes,
+        replaceRange: { start: ltIndex + 1, end },
+    };
+}

package/dist/xml/qname.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A namespace-qualified name.
+ *
+ * In `xml/` because the text helpers beside it (`locate.ts`) speak of element names without
+ * knowing WSDL or XSD, and core imports no protocol folder (protocol modules spec §7.2).
+ * `wsdl/qname.ts` re-exports the type and keeps everything that resolves or compares one.
+ */
+/** A namespace-qualified name: an expanded `{namespaceUri}localName` pair. */
+export interface QName {
+    readonly namespaceUri: string;
+    readonly localName: string;
+}

package/dist/xml/qname.js

@@ -0,0 +1,8 @@
+/**
+ * A namespace-qualified name.
+ *
+ * In `xml/` because the text helpers beside it (`locate.ts`) speak of element names without
+ * knowing WSDL or XSD, and core imports no protocol folder (protocol modules spec §7.2).
+ * `wsdl/qname.ts` re-exports the type and keeps everything that resolves or compares one.
+ */
+export {};

package/dist/xpath/evaluate-async.d.ts

@@ -29,3 +29,22 @@ export interface EvaluateWithTimeoutOptions {
  * @param timeoutOptions `{timeoutMs}`, default 5000
  */
 export declare function evaluateWithTimeout(text: string, expression: string, options: EvaluateOptions, timeoutOptions?: EvaluateWithTimeoutOptions): Promise<QueryResult>;
+/** The outcome of {@link matchRegexWithTimeout}. */
+export type RegexMatchResult = {
+    readonly kind: 'matched';
+    readonly matched: boolean;
+} | {
+    readonly kind: 'error';
+    readonly code: 'regex-timeout' | 'regex-invalid';
+    readonly message: string;
+};
+/**
+ * Tests `pattern` against `text` on the same worker thread and time budget as
+ * {@link evaluateWithTimeout}.
+ *
+ * A pattern can come from a file someone else wrote (a request's or a sequence's `matches:`), and a
+ * backtracking pattern such as `(a+)+$` against a long near-miss runs for minutes. JavaScript cannot
+ * interrupt a running `RegExp`, so the only bound is a thread that can be terminated. Never throws
+ * or rejects: an invalid pattern, a timeout and a worker crash are all `{kind: 'error'}`.
+ */
+export declare function matchRegexWithTimeout(pattern: string, text: string, timeoutOptions?: Pick<EvaluateWithTimeoutOptions, 'timeoutMs'>): Promise<RegexMatchResult>;

package/dist/xpath/evaluate-async.js

@@ -48,9 +48,35 @@ function workerUrl() {
 export function evaluateWithTimeout(text, expression, options, timeoutOptions) {
     const timeoutMs = timeoutOptions?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const kind = timeoutOptions?.kind ?? 'xml';
+    return runOnWorker({ job: 'query', text, kind, expression, options }, timeoutMs, (failure) => failure.kind === 'timeout'
+        ? { kind: 'error', code: 'xpath-timeout', message: `Query timed out after ${timeoutMs}ms` }
+        : { kind: 'error', message: failure.message });
+}
+/**
+ * Tests `pattern` against `text` on the same worker thread and time budget as
+ * {@link evaluateWithTimeout}.
+ *
+ * A pattern can come from a file someone else wrote (a request's or a sequence's `matches:`), and a
+ * backtracking pattern such as `(a+)+$` against a long near-miss runs for minutes. JavaScript cannot
+ * interrupt a running `RegExp`, so the only bound is a thread that can be terminated. Never throws
+ * or rejects: an invalid pattern, a timeout and a worker crash are all `{kind: 'error'}`.
+ */
+export function matchRegexWithTimeout(pattern, text, timeoutOptions) {
+    const timeoutMs = timeoutOptions?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return runOnWorker({ job: 'regex', pattern, text }, timeoutMs, (failure) => failure.kind === 'timeout'
+        ? { kind: 'error', code: 'regex-timeout', message: `Regular expression timed out after ${timeoutMs}ms` }
+        : { kind: 'error', code: 'regex-invalid', message: failure.message }, (posted) => 'error' in posted
+        ? { kind: 'error', code: 'regex-invalid', message: posted.error }
+        : { kind: 'matched', matched: posted.matched });
+}
+/**
+ * Runs one job on a fresh worker, terminating it after `timeoutMs`. `onFailure` shapes a timeout or
+ * crash into the caller's result type; `map` shapes what the worker posted (identity by default).
+ */
+function runOnWorker(workerData, timeoutMs, onFailure, map = (posted) => posted) {
     return new Promise((resolve) => {
         let settled = false;
-        const worker = new Worker(workerUrl(), { workerData: { text, kind, expression, options } });
+        const worker = new Worker(workerUrl(), { workerData });
         const finish = (result) => {
             if (settled) {
                 return;
@@ -61,20 +87,14 @@ export function evaluateWithTimeout(text, expression, options, timeoutOptions) {
             void worker.terminate();
             resolve(result);
         };
-        const timer = setTimeout(() => {
-            finish({
-                kind: 'error',
-                code: 'xpath-timeout',
-                message: `Query timed out after ${timeoutMs}ms`,
-            });
-        }, timeoutMs);
+        const timer = setTimeout(() => finish(onFailure({ kind: 'timeout' })), timeoutMs);
         timer.unref?.();
-        worker.once('message', (result) => finish(result));
-        worker.once('error', (error) => finish({ kind: 'error', message: error instanceof Error ? error.message : String(error) }));
+        worker.once('message', (posted) => finish(map(posted)));
+        worker.once('error', (error) => finish(onFailure({ kind: 'crash', message: error instanceof Error ? error.message : String(error) })));
         worker.once('exit', (code) => {
             /* v8 ignore next 3 -- normal completion always finishes via the 'message' listener first */
             if (!settled) {
-                finish({ kind: 'error', message: `xpath worker exited unexpectedly (code ${code})` });
+                finish(onFailure({ kind: 'crash', message: `xpath worker exited unexpectedly (code ${code})` }));
             }
         });
     });

package/dist/xpath/evaluate.d.ts

@@ -9,7 +9,7 @@
  * the parsed document itself.
  */
 import type { LinePosition } from '../xml/positions.js';
-import type { TextRange } from '../xsd/locate.js';
+import type { TextRange } from '../xml/locate.js';
 /** One node-shaped query result. */
 export interface QueryNodeItem {
     /** The node serialised back to text (an element/comment/PI/document), or an attribute's value. */

package/dist/xpath/namespaces.js

@@ -3,7 +3,7 @@
  * response document, and what the engine would suggest for the ones that aren't.
  */
 import { parseXml } from '../xml/parse.js';
-import { prefixForNamespace } from '../soap/prefixes.js';
+import { prefixForNamespace } from '../xml/prefixes.js';
 /** True for element nodes (xmldom `nodeType` 1) — the only nodes that carry `xmlns:*` attributes. */
 function isElement(node) {
     return node.nodeType === 1;

package/dist/xpath/worker.d.ts

@@ -1,7 +1,13 @@
 /**
- * Entry point run inside a `node:worker_threads` Worker by {@link evaluateWithTimeout}. Receives
- * `{text, kind, expression, options}` as `workerData`, runs the synchronous evaluator once, and
- * posts the {@link QueryResult} back — this file never imports anything Electron/DOM-specific,
- * only what the evaluators themselves need, so it can run unmodified in a bare worker thread.
+ * Entry point run inside a `node:worker_threads` Worker by {@link evaluateWithTimeout} and
+ * {@link matchRegexWithTimeout}. Receives either a query (`{text, kind, expression, options}`) or a
+ * regular-expression job (`{job: 'regex', pattern, text}`) as `workerData`, runs it once, and posts
+ * the result back — this file never imports anything Electron/DOM-specific, only what the
+ * evaluators themselves need, so it can run unmodified in a bare worker thread.
  */
-export {};
+/** What a regex job posts back: whether it matched, or why the pattern could not be compiled. */
+export type RegexWorkerResult = {
+    readonly matched: boolean;
+} | {
+    readonly error: string;
+};

package/dist/xpath/worker.js

@@ -1,16 +1,24 @@
 /**
- * Entry point run inside a `node:worker_threads` Worker by {@link evaluateWithTimeout}. Receives
- * `{text, kind, expression, options}` as `workerData`, runs the synchronous evaluator once, and
- * posts the {@link QueryResult} back — this file never imports anything Electron/DOM-specific,
- * only what the evaluators themselves need, so it can run unmodified in a bare worker thread.
+ * Entry point run inside a `node:worker_threads` Worker by {@link evaluateWithTimeout} and
+ * {@link matchRegexWithTimeout}. Receives either a query (`{text, kind, expression, options}`) or a
+ * regular-expression job (`{job: 'regex', pattern, text}`) as `workerData`, runs it once, and posts
+ * the result back — this file never imports anything Electron/DOM-specific, only what the
+ * evaluators themselves need, so it can run unmodified in a bare worker thread.
  */
 import { parentPort, workerData } from 'node:worker_threads';
 import { evaluate, evaluateJson } from './evaluate.js';
 /* v8 ignore start -- exercised only inside a real worker thread; covered by evaluate-async.test.ts
    end-to-end (a query actually running to completion, or timing out), not by unit-level coverage
    instrumentation, which does not attach across the thread boundary. */
-if (parentPort !== null) {
-    const request = workerData;
+function runRegex(request) {
+    try {
+        return { matched: new RegExp(request.pattern).test(request.text) };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function runQuery(request) {
     let result;
     try {
         result =
@@ -21,6 +29,15 @@ if (parentPort !== null) {
     catch (error) {
         result = { kind: 'error', message: error instanceof Error ? error.message : String(error) };
     }
-    parentPort.postMessage(result);
+    return result;
+}
+if (parentPort !== null) {
+    const request = workerData;
+    if (request.job === 'regex') {
+        parentPort.postMessage(runRegex(request));
+    }
+    else {
+        parentPort.postMessage(runQuery(request));
+    }
 }
 /* v8 ignore stop */

package/dist/xsd/form-model.d.ts

@@ -21,9 +21,9 @@
  * the IPC boundary to the renderer as-is.
  */
 import type { QName } from '../wsdl/qname.js';
-import type { Occurs } from './model.js';
+import type { ElementDecl, Occurs } from './model.js';
 import type { SchemaSet } from './schema-set.js';
-import type { TextRange } from './xml-scan.js';
+import type { ScannedElement, TextRange } from './xml-scan.js';
 export type { TextRange } from './xml-scan.js';
 /** How a leaf's value should be edited. `other` means "no useful editor; plain text". */
 export type FormValueBase = 'string' | 'number' | 'integer' | 'boolean' | 'date' | 'time' | 'dateTime' | 'binary' | 'other';
@@ -123,6 +123,18 @@ export interface BuildFormOptions {
      */
     readonly inScope?: Readonly<Record<string, string>>;
 }
+/** The unconsumed source children of one element, claimed by name as particles are walked (the JSON bridge reads with it too). */
+export declare class Pool {
+    readonly children: readonly ScannedElement[];
+    private readonly used;
+    constructor(children: readonly ScannedElement[]);
+    /** Claims the next unused child whose expanded name is in `names`. */
+    take(names: readonly QName[]): ScannedElement | undefined;
+    /** True when any unused child matches one of `names` — used to size a repeating compositor. */
+    has(names: readonly QName[]): boolean;
+    /** Every child no particle claimed, in source order. */
+    leftovers(): readonly ScannedElement[];
+}
 /**
  * Builds the form tree for one global element declaration.
  *
@@ -139,6 +151,11 @@ export declare function buildForm(schemaSet: SchemaSet, element: QName, xml?: st
  * part takes.
  */
 export declare function buildFormForType(schemaSet: SchemaSet, elementName: QName, type: QName, xml?: string, options?: BuildFormOptions): FormNode;
+/**
+ * Builds the form tree for any element declaration, a local one included: what
+ * the JSON bridge expands where a form was cut at its depth limit.
+ */
+export declare function buildFormForDecl(schemaSet: SchemaSet, decl: ElementDecl, xml?: string, options?: BuildFormOptions): FormNode;
 /** Knobs {@link applyForm} accepts. */
 export interface ApplyFormOptions {
     /** Indent per level; three spaces by default, matching the sample generator. */