@ceralive/modem-control 1.0.0 → 1.2.0

package/dist/transport/calls.js

@@ -0,0 +1,88 @@
+// Method-call dispatch and reply correlation for the D-Bus transport seam.
+//
+// A call marshals its body through the codec, registers a pending record so a bus drop can
+// reject it, and installs a per-call reply callback guarded by a `done` flag — so a reply
+// that arrives after the call already timed out or the connection dropped is silently
+// ignored rather than mis-correlated onto a stale promise. `rejectAll` mass-rejects every
+// in-flight call when the connection drops.
+import { decodeBody, encodeBody } from './codec.js';
+import { messageType } from './dbus-native.js';
+import { DisconnectedError, TransportError } from './errors.js';
+export const DEFAULT_CALL_TIMEOUT_MS = 30_000;
+export class CallDispatcher {
+    #pending = new Set();
+    #callTimeoutMs;
+    constructor(callTimeoutMs) {
+        this.#callTimeoutMs = callTimeoutMs;
+    }
+    async call(bus, connected, call) {
+        if (!connected || bus === null) {
+            throw new DisconnectedError('cannot call method: transport not connected');
+        }
+        const signature = call.signature ?? '';
+        const args = call.args ?? [];
+        const message = {
+            type: messageType.methodCall,
+            destination: call.destination,
+            path: call.path,
+            interface: call.interface,
+            member: call.member,
+        };
+        if (signature.length > 0) {
+            // Throws UnsupportedSignatureError / BigIntRequiredError before anything hits
+            // the wire.
+            message.signature = signature;
+            message.body = encodeBody(signature, args);
+        }
+        const timeoutMs = call.timeoutMs ?? this.#callTimeoutMs;
+        const pendingSet = this.#pending;
+        return new Promise((resolve, reject) => {
+            let done = false;
+            const pending = {
+                settle: finish,
+                reject: (error) => {
+                    finish();
+                    reject(error);
+                },
+            };
+            function finish() {
+                if (done) {
+                    return;
+                }
+                done = true;
+                clearTimeout(timer);
+                pendingSet.delete(pending);
+            }
+            const timer = setTimeout(() => {
+                finish();
+                reject(new TransportError(`Method call ${call.interface}.${call.member} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            pendingSet.add(pending);
+            bus.invoke(message, function reply(error, ...body) {
+                if (done) {
+                    // Reply arrived after timeout/disconnect already settled the promise — ignore.
+                    return;
+                }
+                finish();
+                if (error) {
+                    reject(error instanceof Error ? error : new TransportError(String(error)));
+                    return;
+                }
+                try {
+                    const replySignature = this.signature ?? '';
+                    const decoded = replySignature.length > 0 ? decodeBody(replySignature, body) : [];
+                    resolve({ signature: replySignature, body: decoded });
+                }
+                catch (decodeError) {
+                    reject(decodeError);
+                }
+            });
+        });
+    }
+    rejectAll(cause) {
+        for (const pending of this.#pending) {
+            pending.reject(cause);
+        }
+        this.#pending.clear();
+    }
+}

package/dist/transport/codec.d.ts

@@ -0,0 +1,3 @@
+import type { DbusValue } from './types.js';
+export declare function encodeBody(signature: string, args: readonly DbusValue[]): unknown[];
+export declare function decodeBody(signature: string, body: readonly unknown[]): DbusValue[];

package/dist/transport/codec.js

@@ -0,0 +1,207 @@
+// Signature-aware encode / decode between the transport's public value vocabulary
+// (`DbusValue`, `bigint` for 64-bit, `DbusVariant`) and the shape the underlying
+// `@httptoolkit/dbus-native` marshaller consumes and produces.
+//
+// Two invariants this layer enforces that the library does not:
+//   * 64-bit `x`/`t` are `bigint` end-to-end. On decode the library returns Long.js
+//     objects (only under `ReturnLongjs: true`); we convert them to `bigint` losslessly
+//     via their exact decimal `toString()`. On encode the library accepts a decimal
+//     string for the full 64-bit range but silently truncates a `number` above 2^53 —
+//     so we require a `bigint` and convert it to a decimal string ourselves.
+//   * `h` (UNIX_FD) is rejected up front with a typed error rather than reaching the
+//     library, which would throw a generic "Unknown/Unsupported type" instead.
+import { BigIntRequiredError, SixtyFourBitRangeError, UnsupportedSignatureError } from './errors.js';
+import { parseSignature, signatureFromNode } from './signature.js';
+const INT64_MIN = -(2n ** 63n);
+const INT64_MAX = 2n ** 63n - 1n;
+const UINT64_MAX = 2n ** 64n - 1n;
+function isLongLike(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.low === 'number' &&
+        typeof value.high === 'number' &&
+        typeof value.unsigned === 'boolean');
+}
+function longToBigInt(value) {
+    return BigInt(value.toString());
+}
+// ── Encode ─────────────────────────────────────────────────────────────────────────
+// Public values → library-native body. `assertSupportedSignature` is applied to the
+// whole signature first, so no `h` reaches the recursion.
+export function encodeBody(signature, args) {
+    if (signature.includes('h')) {
+        throw new UnsupportedSignatureError(signature, 'h');
+    }
+    const nodes = parseSignature(signature);
+    if (nodes.length !== args.length) {
+        throw new Error(`Body arity ${args.length} does not match signature "${signature}" (${nodes.length} types)`);
+    }
+    return nodes.map((node, i) => encodeNode(node, args[i]));
+}
+function encodeNode(node, value) {
+    switch (node.type) {
+        case 'x':
+            return encode64(node.type, value, INT64_MIN, INT64_MAX);
+        case 't':
+            return encode64(node.type, value, 0n, UINT64_MAX);
+        case 'a':
+            return encodeArray(node, value);
+        case '(':
+            return encodeStruct(node, value);
+        case '{':
+            return encodeDictEntry(node, value);
+        case 'v':
+            return encodeVariant(value);
+        default:
+            // y b n q i u d s o g — the library validates range/type on marshal.
+            return value;
+    }
+}
+function encode64(type, value, min, max) {
+    if (typeof value !== 'bigint') {
+        throw new BigIntRequiredError(type, value);
+    }
+    if (value < min || value > max) {
+        throw new SixtyFourBitRangeError(type, value);
+    }
+    // Decimal string: the library parses this across the full 64-bit range losslessly.
+    return value.toString();
+}
+function encodeArray(node, value) {
+    const element = node.child[0];
+    // `ay` byte arrays pass straight through as a Uint8Array / Buffer (index-addressable).
+    if (element.type === 'y' && value instanceof Uint8Array) {
+        return value;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Expected array for signature "a${element.type}"`);
+    }
+    return value.map((item) => encodeNode(element, item));
+}
+function encodeStruct(node, value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Expected array for struct value');
+    }
+    if (value.length !== node.child.length) {
+        throw new Error(`Struct arity ${value.length} does not match ${node.child.length} field types`);
+    }
+    return node.child.map((child, i) => encodeNode(child, value[i]));
+}
+function encodeDictEntry(node, value) {
+    if (!Array.isArray(value) || value.length !== 2) {
+        throw new Error('Expected [key, value] pair for dict entry');
+    }
+    const keyNode = node.child[0];
+    const valueNode = node.child[1];
+    return [encodeNode(keyNode, value[0]), encodeNode(valueNode, value[1])];
+}
+function encodeVariant(value) {
+    const asVariant = value;
+    if (typeof asVariant?.signature !== 'string' || !('value' in asVariant)) {
+        throw new Error('Expected a DbusVariant ({ signature, value }) for variant field');
+    }
+    if (asVariant.signature.includes('h')) {
+        throw new UnsupportedSignatureError(asVariant.signature, 'h');
+    }
+    const inner = parseSignature(asVariant.signature);
+    if (inner.length !== 1) {
+        throw new Error(`Variant signature "${asVariant.signature}" must be exactly one complete type`);
+    }
+    return [asVariant.signature, encodeNode(inner[0], asVariant.value)];
+}
+// ── Decode ─────────────────────────────────────────────────────────────────────────
+// Library-native body → public values. The library must have been created with
+// `ReturnLongjs: true` so `x`/`t` arrive as Long objects (this transport does exactly
+// that); a raw `number` in a 64-bit slot means that flag was lost and is treated as a
+// bug, not silently accepted.
+export function decodeBody(signature, body) {
+    if (signature.includes('h')) {
+        throw new UnsupportedSignatureError(signature, 'h');
+    }
+    const nodes = parseSignature(signature);
+    return nodes.map((node, i) => decodeNode(node, body[i]));
+}
+function decodeNode(node, value) {
+    switch (node.type) {
+        case 'x':
+        case 't':
+            return decode64(node.type, value);
+        case 'a':
+            return decodeArray(node, value);
+        case '(':
+            return decodeStruct(node, value);
+        case '{':
+            return decodeDictEntry(node, value);
+        case 'v':
+            return decodeVariant(value);
+        case 'y':
+        case 'b':
+        case 'n':
+        case 'q':
+        case 'i':
+        case 'u':
+        case 'd':
+        case 's':
+        case 'o':
+        case 'g':
+            return value;
+        default:
+            throw new UnsupportedSignatureError(node.type, node.type);
+    }
+}
+function decode64(type, value) {
+    if (isLongLike(value)) {
+        return longToBigInt(value);
+    }
+    if (typeof value === 'bigint') {
+        return value;
+    }
+    // A plain number reaching here means ReturnLongjs was not applied — refuse it rather
+    // than risk having already lost precision above 2^53.
+    throw new BigIntRequiredError(type, value);
+}
+function decodeArray(node, value) {
+    const element = node.child[0];
+    if (element.type === 'y') {
+        // `ay`: the library returns a Buffer; normalise to a plain Uint8Array.
+        if (value instanceof Uint8Array) {
+            return new Uint8Array(value);
+        }
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Expected array while decoding "a${element.type}"`);
+    }
+    return value.map((item) => decodeNode(element, item));
+}
+function decodeStruct(node, value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Expected array while decoding struct');
+    }
+    return node.child.map((child, i) => decodeNode(child, value[i]));
+}
+function decodeDictEntry(node, value) {
+    if (!Array.isArray(value) || value.length !== 2) {
+        throw new Error('Expected [key, value] pair while decoding dict entry');
+    }
+    const keyNode = node.child[0];
+    const valueNode = node.child[1];
+    return [decodeNode(keyNode, value[0]), decodeNode(valueNode, value[1])];
+}
+// The library decodes a variant to `[parseTree, [innerValue]]`. We recover the inner
+// signature from the tree and decode the contained value recursively, preserving both.
+function decodeVariant(value) {
+    if (!Array.isArray(value) || value.length !== 2) {
+        throw new Error('Malformed variant from library (expected [tree, [value]])');
+    }
+    const tree = value[0];
+    const inner = value[1];
+    if (!Array.isArray(tree) || tree.length !== 1 || !Array.isArray(inner)) {
+        throw new Error('Malformed variant tree from library');
+    }
+    const innerNode = tree[0];
+    const innerSignature = signatureFromNode(innerNode);
+    return {
+        signature: innerSignature,
+        value: decodeNode(innerNode, inner[0]),
+    };
+}

package/dist/transport/dbus-native.d.ts

@@ -0,0 +1,57 @@
+export interface RawMessage {
+    type?: number;
+    path?: string;
+    interface?: string;
+    member?: string;
+    destination?: string;
+    sender?: string;
+    signature?: string;
+    body?: unknown[];
+    errorName?: string;
+    serial?: number;
+    replySerial?: number;
+}
+export interface ReplyContext {
+    signature?: string;
+    message?: RawMessage;
+}
+export type ReplyCallback = (this: ReplyContext, error: unknown, ...body: unknown[]) => void;
+export interface RawConnection {
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    once(event: string, handler: (...args: unknown[]) => void): void;
+    removeListener(event: string, handler: (...args: unknown[]) => void): void;
+    removeAllListeners(event?: string): void;
+    listenerCount(event: string): number;
+    end(): void;
+}
+export interface RawBus {
+    connection: RawConnection;
+    invoke(message: RawMessage, callback: ReplyCallback): void;
+    addMatch(rule: string): Promise<unknown>;
+    removeMatch(rule: string): Promise<unknown>;
+    disconnect(): Promise<void>;
+}
+export interface CreateClientOptions {
+    busAddress?: string;
+    socket?: string;
+    ReturnLongjs?: boolean;
+    direct?: boolean;
+}
+export interface DbusNativeModule {
+    createClient(options: CreateClientOptions): RawBus;
+    messageType: {
+        invalid: number;
+        methodCall: number;
+        methodReturn: number;
+        error: number;
+        signal: number;
+    };
+}
+export declare const messageType: {
+    invalid: number;
+    methodCall: number;
+    methodReturn: number;
+    error: number;
+    signal: number;
+};
+export declare function createClient(options: CreateClientOptions): RawBus;

package/dist/transport/dbus-native.js

@@ -0,0 +1,17 @@
+// Internal typed facade over the `@httptoolkit/dbus-native` CommonJS module.
+//
+// The library ships a `types.d.ts` that covers only a fraction of the surface we use
+// (no `invoke`, `addMatch`, `connection`, or `messageType`), so we describe the exact
+// parts we depend on here and cast once, at this single boundary. NOTHING in this file
+// is re-exported from the package's public entry (`../index.ts`): the raw library types
+// stay quarantined behind the transport seam. See `./README.md` for why this library
+// was chosen and the documented fallback (`@particle/dbus-next`).
+import * as dbusNativeModule from '@httptoolkit/dbus-native';
+// Bun/Node CJS interop: `import *` yields the module namespace whose `default` (when
+// present) is `module.exports`. One cast confines the untyped surface to this line.
+const resolved = (dbusNativeModule.default ??
+    dbusNativeModule);
+export const messageType = resolved.messageType;
+export function createClient(options) {
+    return resolved.createClient(options);
+}

package/dist/transport/errors.d.ts

@@ -0,0 +1,21 @@
+export declare class TransportError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class UnsupportedSignatureError extends TransportError {
+    readonly signature: string;
+    readonly unsupportedType: string;
+    constructor(signature: string, unsupportedType: string);
+}
+export declare class BigIntRequiredError extends TransportError {
+    readonly signature: string;
+    readonly received: string;
+    constructor(signature: string, received: unknown);
+}
+export declare class SixtyFourBitRangeError extends TransportError {
+    readonly signature: string;
+    readonly value: bigint;
+    constructor(signature: string, value: bigint);
+}
+export declare class DisconnectedError extends TransportError {
+    constructor(message?: string);
+}

package/{src/transport/errors.ts → dist/transport/errors.js}

@@ -3,72 +3,60 @@
 // Wire data crossing the transport boundary is never compile-time checked, so every
 // failure mode that a caller (or the A3.x D-Bus backend) must branch on is a real,
 // exported class — never a bare thrown string or a generic Error.
-
 export class TransportError extends Error {
-	constructor(message: string, options?: ErrorOptions) {
-		super(message, options);
-		this.name = 'TransportError';
-	}
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'TransportError';
+    }
 }
-
 // A D-Bus signature contained a type this transport refuses to handle. The only such
 // type today is `h` (UNIX_FD / file-descriptor passing): the transport never marshals
 // or unmarshals a file descriptor, so encountering `h` in an outgoing call signature,
 // a reply signature, a signal signature, or nested inside a variant throws this rather
 // than silently dropping or coercing the descriptor.
 export class UnsupportedSignatureError extends TransportError {
-	readonly signature: string;
-	readonly unsupportedType: string;
-
-	constructor(signature: string, unsupportedType: string) {
-		super(
-			`D-Bus signature "${signature}" contains unsupported type "${unsupportedType}": ` +
-				'UNIX_FD / file-descriptor passing is not supported by this transport',
-		);
-		this.name = 'UnsupportedSignatureError';
-		this.signature = signature;
-		this.unsupportedType = unsupportedType;
-	}
+    signature;
+    unsupportedType;
+    constructor(signature, unsupportedType) {
+        super(`D-Bus signature "${signature}" contains unsupported type "${unsupportedType}": ` +
+            'UNIX_FD / file-descriptor passing is not supported by this transport');
+        this.name = 'UnsupportedSignatureError';
+        this.signature = signature;
+        this.unsupportedType = unsupportedType;
+    }
 }
-
 // A 64-bit field (`x` INT64 / `t` UINT64) was handed a JavaScript `number` on encode.
 // A `number` cannot carry the full 64-bit range without silent precision loss above
 // 2^53, so the transport requires a `bigint` for these fields and refuses `number`
 // loudly instead of corrupting the value on the wire.
 export class BigIntRequiredError extends TransportError {
-	readonly signature: string;
-	readonly received: string;
-
-	constructor(signature: string, received: unknown) {
-		super(
-			`D-Bus 64-bit field "${signature}" requires a bigint, received ${typeof received} ` +
-				`(${String(received)}): a JS number silently loses precision above 2^53`,
-		);
-		this.name = 'BigIntRequiredError';
-		this.signature = signature;
-		this.received = typeof received;
-	}
+    signature;
+    received;
+    constructor(signature, received) {
+        super(`D-Bus 64-bit field "${signature}" requires a bigint, received ${typeof received} ` +
+            `(${String(received)}): a JS number silently loses precision above 2^53`);
+        this.name = 'BigIntRequiredError';
+        this.signature = signature;
+        this.received = typeof received;
+    }
 }
-
 // A 64-bit value was outside the range representable by its signed/unsigned field.
 export class SixtyFourBitRangeError extends TransportError {
-	readonly signature: string;
-	readonly value: bigint;
-
-	constructor(signature: string, value: bigint) {
-		super(`Value ${value} is out of range for 64-bit D-Bus field "${signature}"`);
-		this.name = 'SixtyFourBitRangeError';
-		this.signature = signature;
-		this.value = value;
-	}
+    signature;
+    value;
+    constructor(signature, value) {
+        super(`Value ${value} is out of range for 64-bit D-Bus field "${signature}"`);
+        this.name = 'SixtyFourBitRangeError';
+        this.signature = signature;
+        this.value = value;
+    }
 }
-
 // The bus connection dropped (or was never established) while a method call was
 // in-flight or pending. The call rejects with this instead of hanging forever; the
 // transport's own reconnect loop keeps running independently.
 export class DisconnectedError extends TransportError {
-	constructor(message = 'D-Bus connection is not established') {
-		super(message);
-		this.name = 'DisconnectedError';
-	}
+    constructor(message = 'D-Bus connection is not established') {
+        super(message);
+        this.name = 'DisconnectedError';
+    }
 }

package/dist/transport/index.d.ts

@@ -0,0 +1,4 @@
+export { BigIntRequiredError, DisconnectedError, SixtyFourBitRangeError, TransportError, UnsupportedSignatureError, } from './errors.js';
+export { createDbusTransport } from './transport.js';
+export type { DbusTransport, DbusTransportOptions, DbusValue, DbusVariant, MethodCall, MethodReply, ReconnectOptions, SignalEvent, SignalListener, SignalSpec, Subscription, TransportEvent, } from './types.js';
+export { isVariant, variant } from './types.js';

package/dist/transport/index.js

@@ -0,0 +1,9 @@
+// Public surface of the D-Bus transport seam.
+//
+// This is the ONLY module the rest of `@ceralive/modem-control` (and the A3.x D-Bus
+// backend) imports from `./transport`. Every type here is the transport's own — no
+// `@httptoolkit/dbus-native` type is re-exported, so swapping the underlying library
+// (documented fallback: `@particle/dbus-next`) is invisible to callers. See README.md.
+export { BigIntRequiredError, DisconnectedError, SixtyFourBitRangeError, TransportError, UnsupportedSignatureError, } from './errors.js';
+export { createDbusTransport } from './transport.js';
+export { isVariant, variant } from './types.js';

package/dist/transport/signals.d.ts

@@ -0,0 +1,15 @@
+import { type RawBus, type RawMessage } from './dbus-native.js';
+import type { SignalListener, SignalSpec, Subscription } from './types.js';
+export interface SignalHost {
+    currentBus(): RawBus | null;
+    isConnected(): boolean;
+    emitError(error: unknown): void;
+}
+export declare class SignalRegistry {
+    #private;
+    constructor(host: SignalHost);
+    subscribe(spec: SignalSpec, listener: SignalListener): Promise<Subscription>;
+    count(): number;
+    reissueRules(bus: RawBus): Promise<void>;
+    dispatch(message: RawMessage): void;
+}

package/dist/transport/signals.js

@@ -0,0 +1,123 @@
+// Signal subscription and match-rule tracking for the D-Bus transport seam.
+//
+// The transport's single persistent `message` listener fans out here: `dispatch` walks the
+// live subscription registry and delivers each decoded signal to every matching listener.
+// Match rules are refcounted so N subscriptions sharing a rule add/remove it on the bus
+// exactly once, and `reissueRules` re-adds every live rule after a reconnect — so
+// subscribing/unsubscribing never grows the connection's listener count (the 100-cycle
+// leak check depends on this).
+import { decodeBody } from './codec.js';
+import { messageType } from './dbus-native.js';
+function buildMatchRule(spec) {
+    const parts = [`type='signal'`, `interface='${spec.interface}'`, `member='${spec.member}'`];
+    if (spec.path !== undefined) {
+        parts.push(`path='${spec.path}'`);
+    }
+    if (spec.sender !== undefined) {
+        parts.push(`sender='${spec.sender}'`);
+    }
+    return parts.join(',');
+}
+function signalMatches(spec, message) {
+    if (message.interface !== spec.interface || message.member !== spec.member) {
+        return false;
+    }
+    if (spec.path !== undefined && message.path !== spec.path) {
+        return false;
+    }
+    if (spec.sender !== undefined && message.sender !== spec.sender) {
+        return false;
+    }
+    return true;
+}
+export class SignalRegistry {
+    #host;
+    #subscriptions = new Map();
+    #matchRuleRefcount = new Map();
+    #nextSubId = 1;
+    constructor(host) {
+        this.#host = host;
+    }
+    async subscribe(spec, listener) {
+        const rule = buildMatchRule(spec);
+        const id = this.#nextSubId++;
+        this.#subscriptions.set(id, { id, spec, listener, rule });
+        await this.#addMatchRule(rule);
+        let removed = false;
+        return {
+            unsubscribe: async () => {
+                if (removed) {
+                    return;
+                }
+                removed = true;
+                this.#subscriptions.delete(id);
+                await this.#removeMatchRule(rule);
+            },
+        };
+    }
+    count() {
+        return this.#subscriptions.size;
+    }
+    // Re-issue every live match rule against a freshly established bus so a reconnect
+    // resubscribes transparently. Called by `#establish` before it swaps in the new bus, so
+    // the fresh bus is passed in explicitly rather than read from the host.
+    async reissueRules(bus) {
+        for (const rule of this.#matchRuleRefcount.keys()) {
+            await bus.addMatch(rule);
+        }
+    }
+    dispatch(message) {
+        if (message.type !== messageType.signal) {
+            return;
+        }
+        for (const record of this.#subscriptions.values()) {
+            if (!signalMatches(record.spec, message)) {
+                continue;
+            }
+            let body;
+            try {
+                const signature = message.signature ?? '';
+                body = signature.length > 0 ? decodeBody(signature, message.body ?? []) : [];
+            }
+            catch (error) {
+                this.#host.emitError(error);
+                continue;
+            }
+            const event = {
+                path: message.path ?? '',
+                interface: message.interface ?? '',
+                member: message.member ?? '',
+                sender: message.sender,
+                signature: message.signature ?? '',
+                body,
+            };
+            try {
+                record.listener(event);
+            }
+            catch (error) {
+                this.#host.emitError(error);
+            }
+        }
+    }
+    async #addMatchRule(rule) {
+        const current = this.#matchRuleRefcount.get(rule) ?? 0;
+        this.#matchRuleRefcount.set(rule, current + 1);
+        const bus = this.#host.currentBus();
+        if (current === 0 && this.#host.isConnected() && bus) {
+            await bus.addMatch(rule);
+        }
+    }
+    async #removeMatchRule(rule) {
+        const current = this.#matchRuleRefcount.get(rule) ?? 0;
+        if (current <= 1) {
+            this.#matchRuleRefcount.delete(rule);
+            const bus = this.#host.currentBus();
+            if (current === 1 && this.#host.isConnected() && bus) {
+                await bus.removeMatch(rule).catch(() => undefined);
+            }
+        }
+        else {
+            this.#matchRuleRefcount.set(rule, current - 1);
+        }
+    }
+}

package/dist/transport/signature.d.ts

@@ -0,0 +1,7 @@
+export interface SignatureNode {
+    readonly type: string;
+    readonly child: readonly SignatureNode[];
+}
+export declare function assertSupportedSignature(signature: string): void;
+export declare function parseSignature(signature: string): SignatureNode[];
+export declare function signatureFromNode(node: SignatureNode): string;