@wirebench/engine 2.1.1

package/dist/xsd/xml-scan.js

@@ -0,0 +1,286 @@
+/**
+ * A tolerant, dependency-free XML fragment scanner used by the form model.
+ *
+ * It walks the raw text once and produces an element tree in which every node,
+ * attribute value and text run carries the exact UTF-16 offset range it came
+ * from, so the form view can splice a single value back into the envelope
+ * without reformatting anything around it. Never throws: malformed input stops
+ * the scan and is reported, and elements still open at end-of-input are closed
+ * at the document end.
+ *
+ * Deliberately minimal — it exists to read a body fragment, not to validate
+ * one, so entities are decoded but DTDs, namespaces beyond `xmlns` bookkeeping
+ * and processing instructions are skipped.
+ */
+const ATTR_RE = /([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+const NAME_CHAR_RE = /[^\s/>]/;
+const XML_NS = 'http://www.w3.org/XML/1998/namespace';
+/** Decodes the five predefined XML entities plus numeric character references. */
+function decodeEntities(raw) {
+    return raw.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (match, body) => {
+        if (body === 'amp')
+            return '&';
+        if (body === 'lt')
+            return '<';
+        if (body === 'gt')
+            return '>';
+        if (body === 'quot')
+            return '"';
+        if (body === 'apos')
+            return "'";
+        if (body.startsWith('#x') || body.startsWith('#X')) {
+            const code = Number.parseInt(body.slice(2), 16);
+            return Number.isNaN(code) ? match : String.fromCodePoint(code);
+        }
+        if (body.startsWith('#')) {
+            const code = Number.parseInt(body.slice(1), 10);
+            return Number.isNaN(code) ? match : String.fromCodePoint(code);
+        }
+        return match;
+    });
+}
+function toElement(draft) {
+    return {
+        name: draft.name,
+        localName: draft.localName,
+        ...(draft.prefix !== undefined ? { prefix: draft.prefix } : {}),
+        namespaceUri: draft.namespaceUri,
+        declaredNamespaces: draft.declaredNamespaces,
+        attributes: draft.attributes,
+        range: draft.range,
+        ...(draft.text !== undefined ? { text: draft.text } : {}),
+        children: draft.children.map(toElement),
+        selfClosing: draft.selfClosing,
+        leadingComments: draft.leadingComments,
+        trailingComments: draft.trailingComments,
+    };
+}
+/** Parses `name="value"` pairs out of `text.slice(start, end)`, keeping offsets absolute. */
+function parseAttrs(text, start, end) {
+    const region = text.slice(start, end);
+    const out = [];
+    const re = new RegExp(ATTR_RE);
+    let m;
+    while ((m = re.exec(region)) !== null) {
+        const name = m[1];
+        const dq = m[2];
+        const raw = dq ?? m[3] ?? '';
+        const quoteChar = dq !== undefined ? '"' : "'";
+        const matchStart = start + m.index;
+        const eqIdx = m[0].indexOf('=');
+        const quoteIdx = m[0].indexOf(quoteChar, eqIdx === -1 ? 0 : eqIdx);
+        const valueStart = quoteIdx === -1 ? matchStart : matchStart + quoteIdx + 1;
+        out.push({
+            name,
+            value: decodeEntities(raw),
+            valueRange: { start: valueStart, end: valueStart + raw.length },
+        });
+    }
+    return out;
+}
+/** Scans one open (or self-closing) tag starting at `text[lt] === '<'`, respecting quoted values. */
+function parseOpenTag(text, lt) {
+    let i = lt + 1;
+    const nameStart = i;
+    while (i < text.length && NAME_CHAR_RE.test(text[i])) {
+        i += 1;
+    }
+    if (i === nameStart) {
+        return undefined;
+    }
+    const name = text.slice(nameStart, i);
+    let quote;
+    while (i < text.length) {
+        const ch = text[i];
+        if (quote !== undefined) {
+            if (ch === quote) {
+                quote = undefined;
+            }
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (ch === '>') {
+            break;
+        }
+        i += 1;
+    }
+    if (i >= text.length) {
+        return undefined;
+    }
+    const selfClosing = text[i - 1] === '/';
+    return {
+        tagEnd: i,
+        selfClosing,
+        name,
+        attrs: parseAttrs(text, nameStart + name.length, selfClosing ? i - 1 : i),
+    };
+}
+function splitName(name) {
+    const colon = name.indexOf(':');
+    return colon === -1 ? { localName: name } : { prefix: name.slice(0, colon), localName: name.slice(colon + 1) };
+}
+/** Merges any `xmlns`/`xmlns:*` declarations on `attrs` into `parent`, without mutating it. */
+function declarationsOf(attrs) {
+    const decls = {};
+    for (const attr of attrs) {
+        if (attr.name === 'xmlns') {
+            decls[''] = attr.value;
+        }
+        else if (attr.name.startsWith('xmlns:')) {
+            decls[attr.name.slice('xmlns:'.length)] = attr.value;
+        }
+    }
+    return decls;
+}
+/** Records a text-only element's content span, or an empty one when it has none. */
+function finalizeText(frame, contentStart) {
+    if (frame.sawChildElement) {
+        return;
+    }
+    if (frame.spans.length === 0) {
+        frame.draft.text = { value: '', range: { start: contentStart, end: contentStart } };
+        return;
+    }
+    const first = frame.spans[0];
+    const last = frame.spans[frame.spans.length - 1];
+    frame.draft.text = {
+        value: frame.spans.map((s) => s.value).join(''),
+        range: { start: first.start, end: last.end },
+    };
+}
+/**
+ * Scans an XML fragment into an element tree with exact ranges.
+ *
+ * @param text the raw fragment; may contain several top-level elements
+ * @param inScope prefix → URI bindings inherited from an enclosing document (a
+ *   body fragment sliced out of an envelope carries none of its own)
+ */
+export function scanXml(text, inScope = {}) {
+    const problems = [];
+    const len = text.length;
+    const stack = [];
+    const roots = [];
+    let rootComments = [];
+    let i = 0;
+    const frame = () => stack[stack.length - 1];
+    while (i < len) {
+        const lt = text.indexOf('<', i);
+        if (lt === -1) {
+            break;
+        }
+        if (lt > i) {
+            const current = frame();
+            if (current !== undefined) {
+                current.spans.push({ start: i, end: lt, value: decodeEntities(text.slice(i, lt)) });
+            }
+        }
+        if (text.startsWith('<!--', lt)) {
+            const end = text.indexOf('-->', lt + 4);
+            if (end === -1) {
+                problems.push(`Unterminated comment at offset ${lt}`);
+                break;
+            }
+            const body = text.slice(lt + 4, end);
+            const current = frame();
+            if (current === undefined) {
+                rootComments.push(body);
+            }
+            else {
+                current.pendingComments.push(body);
+            }
+            i = end + 3;
+            continue;
+        }
+        if (text.startsWith('<![CDATA[', lt)) {
+            const payloadStart = lt + 9;
+            const end = text.indexOf(']]>', payloadStart);
+            if (end === -1) {
+                problems.push(`Unterminated CDATA section at offset ${lt}`);
+                break;
+            }
+            frame()?.spans.push({ start: payloadStart, end, value: text.slice(payloadStart, end) });
+            i = end + 3;
+            continue;
+        }
+        if (text.startsWith('<?', lt) || text.startsWith('<!', lt)) {
+            const closer = text.startsWith('<?', lt) ? '?>' : '>';
+            const end = text.indexOf(closer, lt + 2);
+            if (end === -1) {
+                problems.push(`Unterminated declaration at offset ${lt}`);
+                break;
+            }
+            i = end + closer.length;
+            continue;
+        }
+        if (text.startsWith('</', lt)) {
+            const end = text.indexOf('>', lt + 2);
+            if (end === -1) {
+                problems.push(`Unterminated closing tag at offset ${lt}`);
+                break;
+            }
+            const closing = stack.pop();
+            if (closing === undefined) {
+                problems.push(`Unexpected closing tag at offset ${lt} with no open element`);
+            }
+            else {
+                finalizeText(closing, closing.draft.range.end);
+                closing.draft.trailingComments = closing.pendingComments;
+                closing.draft.range = { start: closing.draft.range.start, end: end + 1 };
+            }
+            i = end + 1;
+            continue;
+        }
+        const parsed = parseOpenTag(text, lt);
+        if (parsed === undefined) {
+            problems.push(`Malformed tag at offset ${lt}`);
+            i = lt + 1;
+            continue;
+        }
+        const parent = frame();
+        const declared = declarationsOf(parsed.attrs);
+        const prefixes = Object.keys(declared).length > 0
+            ? { ...(parent?.prefixes ?? inScope), ...declared }
+            : (parent?.prefixes ?? inScope);
+        const { localName, prefix } = splitName(parsed.name);
+        const namespaceUri = prefix === 'xml' ? XML_NS : (prefixes[prefix ?? ''] ?? '');
+        const leading = parent === undefined ? rootComments : parent.pendingComments;
+        const draft = {
+            name: parsed.name,
+            localName,
+            ...(prefix !== undefined ? { prefix } : {}),
+            namespaceUri,
+            declaredNamespaces: declared,
+            attributes: parsed.attrs,
+            range: { start: lt, end: parsed.tagEnd + 1 },
+            children: [],
+            selfClosing: parsed.selfClosing,
+            leadingComments: leading,
+            trailingComments: [],
+        };
+        if (parent === undefined) {
+            roots.push(draft);
+            rootComments = [];
+        }
+        else {
+            parent.draft.children.push(draft);
+            parent.sawChildElement = true;
+            parent.pendingComments = [];
+        }
+        // A self-closing element has no content range at all, so it never gets a
+        // `text` field — a value edit on it must go through a structural edit.
+        if (!parsed.selfClosing) {
+            stack.push({ draft, prefixes, sawChildElement: false, spans: [], pendingComments: [] });
+        }
+        i = parsed.tagEnd + 1;
+    }
+    if (stack.length > 0) {
+        problems.push('Fragment ended with unclosed element(s); closed at end of text');
+        while (stack.length > 0) {
+            const open = stack.pop();
+            finalizeText(open, open.draft.range.end);
+            open.draft.range = { start: open.draft.range.start, end: len };
+        }
+    }
+    return { elements: roots.map(toElement), problems };
+}

package/dist/xsd/xml-writer.d.ts

@@ -0,0 +1,56 @@
+/**
+ * A tiny, dependency-free XML fragment writer used by the sample generator.
+ *
+ * It builds an element tree in memory and renders it with a fixed indent, so
+ * namespace declarations discovered while walking a schema can still be added
+ * to the fragment's root element once the walk is finished.
+ */
+import type { QName } from '../wsdl/qname.js';
+/** A literal attribute on an emitted element. */
+export interface XmlAttribute {
+    readonly name: string;
+    readonly value: string;
+}
+/** An emitted element, comment, or nothing at all. */
+export type XmlNode = XmlElementNode | XmlCommentNode;
+/** An element node; either a leaf carrying `text` or a container with `children`. */
+export interface XmlElementNode {
+    readonly kind: 'element';
+    /** The already-prefixed tag name, e.g. `ns1:Add` or `intA`. */
+    readonly name: string;
+    attributes: XmlAttribute[];
+    readonly children: XmlNode[];
+    /** Simple content, rendered on the element's own line. */
+    text?: string;
+    /** A comment rendered immediately before {@link XmlElementNode.text}, inside the element. */
+    leadingComment?: string;
+}
+/** A standalone comment line. */
+export interface XmlCommentNode {
+    readonly kind: 'comment';
+    readonly text: string;
+}
+/** Creates an element node with no attributes and no children. */
+export declare function element(name: string): XmlElementNode;
+/** Creates a standalone comment node. */
+export declare function comment(text: string): XmlCommentNode;
+/** Escapes text content: `&`, `<` and `>` only, per XML's character-data rules. */
+export declare function escapeText(value: string): string;
+/** Escapes an attribute value, including the double quote it is delimited by. */
+export declare function escapeAttribute(value: string): string;
+/** Renders a node tree to a pretty-printed XML fragment (no XML declaration). */
+export declare function renderXml(root: XmlNode, indent: string): string;
+/** Assigns and remembers a stable prefix per namespace URI. */
+export declare class PrefixTable {
+    private readonly preferred;
+    private readonly byUri;
+    private readonly taken;
+    private counter;
+    constructor(preferred: Readonly<Record<string, string>>);
+    /** The prefix for `uri`, allocating one on first use. The empty namespace has no prefix. */
+    prefixFor(uri: string, hint?: string): string;
+    /** Renders `name` as a prefixed lexical QName. */
+    qualify(name: QName, hint?: string): string;
+    /** Prefix → URI for every namespace used so far, in first-use order. */
+    namespaces(): Record<string, string>;
+}

package/dist/xsd/xml-writer.js

@@ -0,0 +1,103 @@
+/**
+ * A tiny, dependency-free XML fragment writer used by the sample generator.
+ *
+ * It builds an element tree in memory and renders it with a fixed indent, so
+ * namespace declarations discovered while walking a schema can still be added
+ * to the fragment's root element once the walk is finished.
+ */
+/** Creates an element node with no attributes and no children. */
+export function element(name) {
+    return { kind: 'element', name, attributes: [], children: [] };
+}
+/** Creates a standalone comment node. */
+export function comment(text) {
+    return { kind: 'comment', text };
+}
+/** Escapes text content: `&`, `<` and `>` only, per XML's character-data rules. */
+export function escapeText(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/** Escapes an attribute value, including the double quote it is delimited by. */
+export function escapeAttribute(value) {
+    return escapeText(value).replace(/"/g, '&quot;');
+}
+/** Neutralises `--` so a generated comment can never terminate early. */
+function escapeComment(text) {
+    return text.replace(/--/g, '- -');
+}
+function renderAttributes(attributes) {
+    return attributes.map((a) => ` ${a.name}="${escapeAttribute(a.value)}"`).join('');
+}
+function renderNode(node, indent, depth, out) {
+    const pad = indent.repeat(depth);
+    if (node.kind === 'comment') {
+        out.push(`${pad}<!--${escapeComment(node.text)}-->`);
+        return;
+    }
+    const open = `<${node.name}${renderAttributes(node.attributes)}`;
+    if (node.children.length === 0 && node.text === undefined && node.leadingComment === undefined) {
+        out.push(`${pad}${open}/>`);
+        return;
+    }
+    if (node.children.length === 0) {
+        const inner = `${node.leadingComment !== undefined ? `<!--${escapeComment(node.leadingComment)}-->` : ''}${node.text !== undefined ? escapeText(node.text) : ''}`;
+        out.push(`${pad}${open}>${inner}</${node.name}>`);
+        return;
+    }
+    out.push(`${pad}${open}>`);
+    for (const child of node.children) {
+        renderNode(child, indent, depth + 1, out);
+    }
+    out.push(`${pad}</${node.name}>`);
+}
+/** Renders a node tree to a pretty-printed XML fragment (no XML declaration). */
+export function renderXml(root, indent) {
+    const out = [];
+    renderNode(root, indent, 0, out);
+    return out.join('\n');
+}
+/** Assigns and remembers a stable prefix per namespace URI. */
+export class PrefixTable {
+    preferred;
+    byUri = new Map();
+    taken = new Set();
+    counter = 0;
+    constructor(preferred) {
+        this.preferred = preferred;
+    }
+    /** The prefix for `uri`, allocating one on first use. The empty namespace has no prefix. */
+    prefixFor(uri, hint) {
+        if (uri === '') {
+            return '';
+        }
+        const existing = this.byUri.get(uri);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const wanted = this.preferred[uri] ?? hint;
+        let prefix = wanted !== undefined && !this.taken.has(wanted) ? wanted : '';
+        while (prefix === '') {
+            this.counter += 1;
+            const candidate = `ns${this.counter}`;
+            if (!this.taken.has(candidate)) {
+                prefix = candidate;
+            }
+        }
+        this.taken.add(prefix);
+        this.byUri.set(uri, prefix);
+        return prefix;
+    }
+    /** Renders `name` as a prefixed lexical QName. */
+    qualify(name, hint) {
+        const prefix = this.prefixFor(name.namespaceUri, hint);
+        return prefix === '' ? name.localName : `${prefix}:${name.localName}`;
+    }
+    /** Prefix → URI for every namespace used so far, in first-use order. */
+    namespaces() {
+        const result = {};
+        for (const [uri, prefix] of this.byUri) {
+            result[prefix] = uri;
+        }
+        return result;
+    }
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@wirebench/engine",
+  "version": "2.1.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wirebench/wirebench.git",
+    "directory": "packages/engine"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "prepack": "node -e \"require('fs').copyFileSync('../../LICENSE', 'LICENSE')\"",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./xml": {
+      "types": "./dist/xml/index.d.ts",
+      "default": "./dist/xml/index.js"
+    },
+    "./rest": {
+      "types": "./dist/rest/browser.d.ts",
+      "default": "./dist/rest/browser.js"
+    },
+    "./json": {
+      "types": "./dist/json/cursor.d.ts",
+      "default": "./dist/json/cursor.js"
+    },
+    "./grpc": {
+      "types": "./dist/grpc/browser.d.ts",
+      "default": "./dist/grpc/browser.js"
+    },
+    "./detect": {
+      "types": "./dist/import-detect.d.ts",
+      "default": "./dist/import-detect.js"
+    }
+  },
+  "dependencies": {
+    "@xmldom/xmldom": "^0.9.12",
+    "fontoxpath": "^3.34.0",
+    "jsonpath-plus": "^10.4.0",
+    "node-forge": "^1.3.1",
+    "protobufjs": "^8.8.0",
+    "ulidx": "^2.4.1",
+    "undici": "^8",
+    "xml-crypto": "^6.1.2",
+    "xmllint-wasm": "5.3.0",
+    "yaml": "^2.9",
+    "zod": "^4.6.1"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "vitest run --root ../.. --project engine-unit --project engine-integration",
+    "test:perf": "vitest run --root ../.. --project engine-perf",
+    "typecheck": "tsc -b"
+  }
+}