@ceralive/modem-control 0.2.0 → 1.1.0

package/dist/testing/index.js

@@ -0,0 +1,17 @@
+// `@ceralive/modem-control/testing` — the PUBLIC contract-fakes surface.
+//
+// A consumer testing against this package needs valid instances of the frozen v1.1
+// domain and provider contracts (`../domain`, `../providers`). Hand-rolling them is
+// how a consumer's fixtures come to disagree with the package: a hand-written
+// `OperationResult` literal quietly stops matching what `classifyOperationCompletion`
+// actually returns, and a hand-written envelope invents a value for an unavailable
+// read. Every fake here is built through the package's own constructors and
+// classifiers, so it cannot express a shape the domain refuses.
+//
+// This is NOT `control/test-support/`. That directory holds this repo's own heavy
+// internals — an MM-faithful fake D-Bus service on a private session bus and a
+// stateful `nmcli` harness. It lives outside `src`, is not published, and is not a
+// reusable public surface. This entry is pure data and functions: no bus, no daemon,
+// no process, no filesystem.
+export * from './domain-fakes.js';
+export * from './provider-fakes.js';

package/dist/testing/provider-fakes.d.ts

@@ -0,0 +1,45 @@
+import type { DeviceGeneration } from '../domain/index.js';
+import type { FingerprintResult, PassiveFact, ProviderDefinition, ProviderMatchRequest, ProviderOperationsSurface, ProviderTransport, UnauthenticatedProbe } from '../providers/index.js';
+/** The model string every provider fake matches on unless one is named. */
+export declare const FAKE_PROVIDER_MODEL = "contract-fake-model";
+export type FakeMatchRequestOptions = {
+    readonly generation?: DeviceGeneration;
+    readonly transport?: ProviderTransport;
+    readonly model?: string;
+    readonly composition?: string;
+    readonly firmware?: string;
+    readonly passiveFacts?: readonly PassiveFact[];
+};
+/** A well-formed `ProviderMatchRequest` whose passive facts name exactly one model. */
+export declare function fakeProviderMatchRequest(options?: FakeMatchRequestOptions): ProviderMatchRequest;
+export type FakeProviderOptions<TObservation> = {
+    readonly id?: string;
+    readonly profile?: string;
+    readonly profileVersion?: string;
+    readonly model?: string;
+    readonly eligibleTransports?: readonly ProviderTransport[];
+    readonly access?: ProviderOperationsSurface['access'];
+    readonly observation?: TObservation;
+    readonly probes?: readonly UnauthenticatedProbe[];
+};
+/**
+ * A minimal but COMPLETE `ProviderDefinition` — one strong required passive matcher on
+ * the model fact, no authenticated profile, no capability readers.
+ *
+ * It registers nothing and reaches no device: `observe` answers a fresh envelope built
+ * from the supplied observation, and `operations` returns the access surface asked for.
+ * This is the shape a consumer writes its own registry/matcher tests against without
+ * inventing a parallel provider contract.
+ */
+export declare function fakeProviderDefinition<TObservation>(options: FakeProviderOptions<TObservation> & {
+    readonly observation: TObservation;
+}): ProviderDefinition<TObservation, ProviderOperationsSurface>;
+export type FakeProbeOptions = {
+    readonly id?: string;
+    readonly signal?: FingerprintResult['signal'];
+    readonly strength?: FingerprintResult['strength'];
+    readonly profiles?: readonly string[];
+    readonly detail?: string;
+};
+/** A harmless unauthenticated probe that answers a fixed fingerprint. */
+export declare function fakeUnauthenticatedProbe(options?: FakeProbeOptions): UnauthenticatedProbe;

package/dist/testing/provider-fakes.js

@@ -0,0 +1,64 @@
+import { FAKE_GENERATION, FAKE_PHYSICAL_MODEM_ID, fakeFreshObservation } from './domain-fakes.js';
+/** The model string every provider fake matches on unless one is named. */
+export const FAKE_PROVIDER_MODEL = 'contract-fake-model';
+/** A well-formed `ProviderMatchRequest` whose passive facts name exactly one model. */
+export function fakeProviderMatchRequest(options = {}) {
+    const model = options.model ?? FAKE_PROVIDER_MODEL;
+    return {
+        physicalModemId: FAKE_PHYSICAL_MODEM_ID,
+        generation: options.generation ?? FAKE_GENERATION,
+        transport: options.transport ?? 'network',
+        passiveFacts: options.passiveFacts ?? [{ kind: 'model', value: model }],
+        composition: options.composition ?? 'ethernet-router',
+        firmware: options.firmware ?? '1.0.0',
+    };
+}
+/**
+ * A minimal but COMPLETE `ProviderDefinition` — one strong required passive matcher on
+ * the model fact, no authenticated profile, no capability readers.
+ *
+ * It registers nothing and reaches no device: `observe` answers a fresh envelope built
+ * from the supplied observation, and `operations` returns the access surface asked for.
+ * This is the shape a consumer writes its own registry/matcher tests against without
+ * inventing a parallel provider contract.
+ */
+export function fakeProviderDefinition(options) {
+    const id = options.id ?? 'contract-fake-provider';
+    const profile = options.profile ?? 'contract-fake-profile';
+    const model = options.model ?? FAKE_PROVIDER_MODEL;
+    const access = options.access ?? 'read-only';
+    const observation = options.observation;
+    return {
+        id,
+        profileVersion: options.profileVersion ?? '1.0.0',
+        eligibleTransports: options.eligibleTransports ?? ['network'],
+        passiveMatchers: [
+            {
+                id: `${id}-model`,
+                fact: 'model',
+                expected: [model],
+                profiles: [profile],
+                strength: 'strong',
+                required: true,
+            },
+        ],
+        unauthenticatedProbes: options.probes ?? [],
+        capabilityReaders: [],
+        observe: (_context) => Promise.resolve([fakeFreshObservation(observation, { source: id })]),
+        operations: (_profile) => ({ access }),
+        contractFixtures: [],
+    };
+}
+/** A harmless unauthenticated probe that answers a fixed fingerprint. */
+export function fakeUnauthenticatedProbe(options = {}) {
+    const result = {
+        signal: options.signal ?? 'match',
+        strength: options.strength ?? 'moderate',
+        profiles: options.profiles ?? ['contract-fake-profile'],
+        detail: options.detail ?? 'contract-fake probe',
+    };
+    return {
+        id: options.id ?? 'contract-fake-probe',
+        run: (_context) => Promise.resolve(result),
+    };
+}

package/dist/transport/calls.d.ts

@@ -0,0 +1,9 @@
+import { type RawBus } from './dbus-native.js';
+import type { MethodCall, MethodReply } from './types.js';
+export declare const DEFAULT_CALL_TIMEOUT_MS = 30000;
+export declare class CallDispatcher {
+    #private;
+    constructor(callTimeoutMs: number);
+    call(bus: RawBus | null, connected: boolean, call: MethodCall): Promise<MethodReply>;
+    rejectAll(cause: unknown): void;
+}

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';