@ceralive/modem-control 1.0.0 → 1.1.0

package/dist/providers/huawei-hilink/session.js

@@ -0,0 +1,120 @@
+import { createHash } from 'node:crypto';
+import { parseHilinkSession, parseHilinkUserState, parseHilinkXmlValue, } from '../../hardware/router-parsers.js';
+import { HILINK_PATHS } from './provider.js';
+function base64(value) {
+    return Buffer.from(value).toString('base64');
+}
+function derivePassword(profile, username, password, token) {
+    if (profile.passwordType === 3)
+        return base64(password);
+    const passwordHash = base64(createHash('sha256').update(password).digest('hex'));
+    const loginHash = createHash('sha256').update(`${username}${passwordHash}${token}`).digest('hex');
+    return base64(loginHash);
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function loginDocument(profile, username, password, token) {
+    return `<?xml version="1.0" encoding="UTF-8"?><request><Username>${escapeXml(username)}</Username><Password>${derivePassword(profile, username, password, token)}</Password><password_type>${profile.passwordType}</password_type></request>`;
+}
+function responseHeader(response, name) {
+    const expected = name.toLowerCase();
+    return Object.entries(response.headers ?? {}).find(([key]) => key.toLowerCase() === expected)?.[1];
+}
+function loggedInSession(response, fallback) {
+    const cookie = responseHeader(response, 'set-cookie')?.split(';', 1)[0]?.trim() ?? fallback.cookie;
+    const tokenHeader = responseHeader(response, '__requestverificationtoken') ??
+        responseHeader(response, '__requestverificationtokenone');
+    const token = tokenHeader?.split('#', 1)[0]?.trim() ?? fallback.token;
+    return { cookie, token };
+}
+export class HilinkSessionRuntime {
+    options;
+    #authenticated = new Map();
+    #serial = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async withDevice(context, run) {
+        const key = String(context.physicalModemId);
+        const prior = this.#serial.get(key) ?? Promise.resolve();
+        let release = () => { };
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const chain = prior.then(() => current);
+        this.#serial.set(key, chain);
+        await prior;
+        try {
+            return await run();
+        }
+        finally {
+            release();
+            if (this.#serial.get(key) === chain)
+                this.#serial.delete(key);
+        }
+    }
+    sessionKey(context) {
+        return `${context.physicalModemId}:${context.generation}`;
+    }
+    cachedSession(context) {
+        return this.#authenticated.get(this.sessionKey(context));
+    }
+    async authenticate(context, profile, cache) {
+        const sessionResponse = await this.request('GET', HILINK_PATHS.session);
+        if (sessionResponse.status === 401 || sessionResponse.status === 403)
+            return { status: 'refused', reason: 'auth-expired' };
+        if (sessionResponse.status !== 200)
+            return { status: 'refused', reason: 'unreachable' };
+        const initial = parseHilinkSession(sessionResponse.body);
+        if (initial === undefined)
+            return { status: 'refused', reason: 'malformed' };
+        const stateResponse = await this.getResponse(HILINK_PATHS.loginState, initial);
+        if (this.authExpired(stateResponse))
+            return { status: 'refused', reason: 'auth-expired' };
+        const state = parseHilinkUserState(stateResponse.body);
+        if (state === undefined)
+            return { status: 'refused', reason: 'malformed' };
+        if (state.passwordType !== profile.passwordType)
+            return { status: 'refused', reason: 'profile-mismatch' };
+        const login = await this.postResponse(HILINK_PATHS.login, loginDocument(profile, this.options.credentials.username, this.options.credentials.password, initial.token), initial);
+        if (this.authExpired(login))
+            return { status: 'refused', reason: 'auth-expired' };
+        if (login.status !== 200 || !/<response>\s*OK\s*<\/response>/i.test(login.body))
+            return { status: 'refused', reason: 'http-failure' };
+        const session = loggedInSession(login, initial);
+        if (cache)
+            this.#authenticated.set(this.sessionKey(context), session);
+        return { status: 'ready', session };
+    }
+    authExpired(response) {
+        return (response.status === 401 ||
+            response.status === 403 ||
+            parseHilinkXmlValue(response.body, 'code') === '125002');
+    }
+    getResponse(path, session) {
+        return this.request('GET', path, undefined, [`Cookie: ${session.cookie}`]);
+    }
+    postResponse(path, body, session) {
+        return this.request('POST', path, body, [
+            `Cookie: ${session.cookie}`,
+            `__RequestVerificationToken: ${session.token}`,
+            'Content-Type: application/xml',
+        ]);
+    }
+    request(method, path, body, headers = []) {
+        return this.options.transport.request({
+            method,
+            url: `${this.options.adminUrl}${path}`,
+            ...(body === undefined ? {} : { body }),
+            headers,
+            interfaceName: this.options.interfaceName,
+            redirect: 'error',
+        });
+    }
+}

package/dist/providers/huawei-hilink/transport.d.ts

@@ -0,0 +1,19 @@
+export type HilinkHttpRequest = {
+    readonly method: 'GET' | 'POST';
+    readonly url: string;
+    readonly body?: string;
+    readonly headers: readonly string[];
+    readonly interfaceName: string;
+    readonly redirect: 'error';
+};
+export type HilinkHttpResponse = {
+    readonly status: number;
+    readonly body: string;
+    readonly headers?: Readonly<Record<string, string>>;
+};
+export interface HilinkTransport {
+    request(request: HilinkHttpRequest): Promise<HilinkHttpResponse>;
+}
+export type HilinkReplayExchange = HilinkHttpRequest & {
+    readonly response: HilinkHttpResponse;
+};

package/dist/providers/huawei-hilink/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/index.d.ts

@@ -0,0 +1,8 @@
+export * from './contracts.js';
+export * from './huawei-hilink/index.js';
+export * from './matcher.js';
+export * from './modem-manager/index.js';
+export * from './network-manager/index.js';
+export * from './registry.js';
+export * from './ufi-himi/index.js';
+export * from './zte-goform/index.js';

package/dist/providers/index.js

@@ -0,0 +1,8 @@
+export * from './contracts.js';
+export * from './huawei-hilink/index.js';
+export * from './matcher.js';
+export * from './modem-manager/index.js';
+export * from './network-manager/index.js';
+export * from './registry.js';
+export * from './ufi-himi/index.js';
+export * from './zte-goform/index.js';

package/dist/providers/matcher.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderMatcher } from './contracts.js';
+import type { ProviderRegistry } from './registry.js';
+export declare function createProviderMatcher(registry: ProviderRegistry): ProviderMatcher;

package/dist/providers/matcher.js

@@ -0,0 +1,205 @@
+const STRENGTH_POINTS = {
+    none: 0,
+    weak: 1,
+    moderate: 2,
+    strong: 3,
+};
+function scoreOf(points) {
+    if (points <= 0)
+        return 'unsupported';
+    if (points === 1)
+        return 'maybe';
+    if (points === 2)
+        return 'likely';
+    return 'supported';
+}
+function confidenceOf(points) {
+    return Math.min(1, points / 3);
+}
+function cacheSignature(request, registryRevision) {
+    return JSON.stringify({
+        registryRevision,
+        generation: request.generation,
+        transport: request.transport,
+        passiveFacts: request.passiveFacts,
+        composition: request.composition,
+        firmware: request.firmware ?? null,
+    });
+}
+function addCandidate(candidates, provider, profile, strength) {
+    const key = `${provider.id}\u0000${profile}`;
+    const existing = candidates.get(key);
+    if (existing === undefined) {
+        candidates.set(key, { provider, profile, points: STRENGTH_POINTS[strength] });
+        return;
+    }
+    existing.points += STRENGTH_POINTS[strength];
+}
+function unresolvedResult(status, request, points, evidence, conflicts) {
+    return {
+        status,
+        provider: null,
+        profile: null,
+        score: scoreOf(points),
+        confidence: confidenceOf(points),
+        evidence,
+        conflicts,
+        operations: null,
+        writable: false,
+        generation: request.generation,
+        physicalModemId: request.physicalModemId,
+    };
+}
+async function evaluate(registry, request) {
+    const evidence = [];
+    const conflicts = [];
+    const candidates = new Map();
+    const eligible = [];
+    for (const provider of registry.list()) {
+        const transportMatches = provider.eligibleTransports.includes(request.transport);
+        evidence.push({
+            provider: provider.id,
+            profile: null,
+            stage: 'transport-eligibility',
+            source: request.transport,
+            signal: transportMatches ? 'match' : 'mismatch',
+            strength: 'none',
+            detail: transportMatches ? 'eligible-transport' : 'ineligible-transport',
+        });
+        if (transportMatches)
+            eligible.push(provider);
+    }
+    for (const provider of eligible) {
+        for (const matcher of provider.passiveMatchers) {
+            const actual = request.passiveFacts
+                .filter((fact) => fact.kind === matcher.fact)
+                .map((fact) => fact.value);
+            const signal = actual.length === 0
+                ? 'unknown'
+                : actual.some((value) => matcher.expected.includes(value))
+                    ? 'match'
+                    : 'mismatch';
+            const item = {
+                provider: provider.id,
+                profile: matcher.profiles.length === 1 ? (matcher.profiles[0] ?? null) : null,
+                stage: 'passive-facts',
+                source: matcher.id,
+                signal,
+                strength: matcher.strength,
+                detail: signal === 'match' ? 'expected-fact-present' : 'expected-fact-not-proven',
+            };
+            evidence.push(item);
+            if (signal === 'mismatch' && matcher.required)
+                conflicts.push(item);
+            if (signal === 'match') {
+                for (const profile of matcher.profiles) {
+                    addCandidate(candidates, provider, profile, matcher.strength);
+                }
+            }
+        }
+    }
+    for (const provider of eligible) {
+        for (const probe of provider.unauthenticatedProbes) {
+            const result = await probe.run(request);
+            const item = {
+                provider: provider.id,
+                profile: result.profiles.length === 1 ? (result.profiles[0] ?? null) : null,
+                stage: 'unauthenticated-fingerprint',
+                source: probe.id,
+                signal: result.signal,
+                strength: result.strength,
+                detail: result.detail,
+            };
+            evidence.push(item);
+            if (result.signal === 'mismatch')
+                conflicts.push(item);
+            if (result.signal === 'match') {
+                for (const profile of result.profiles) {
+                    addCandidate(candidates, provider, profile, result.strength);
+                }
+            }
+        }
+    }
+    const ranked = [...candidates.values()].sort((left, right) => right.points - left.points);
+    const top = ranked[0];
+    if (top === undefined)
+        return unresolvedResult('unsupported', request, 0, evidence, conflicts);
+    if (ranked[1]?.points === top.points) {
+        return unresolvedResult('ambiguous', request, top.points, evidence, conflicts);
+    }
+    if (top.provider.authenticatedProfile !== undefined) {
+        const auth = await top.provider.authenticatedProfile.authenticate(request, [top.profile]);
+        const matched = auth.status === 'matched' && auth.profile === top.profile;
+        const item = {
+            provider: top.provider.id,
+            profile: top.profile,
+            stage: 'authenticated-profile',
+            source: top.provider.authenticatedProfile.algorithm,
+            signal: matched ? 'match' : auth.status === 'unavailable' ? 'unknown' : 'mismatch',
+            strength: 'strong',
+            detail: auth.detail,
+        };
+        evidence.push(item);
+        if (!matched) {
+            conflicts.push(item);
+            return unresolvedResult('ambiguous', request, top.points, evidence, conflicts);
+        }
+        top.points += STRENGTH_POINTS.strong;
+    }
+    const context = { ...request, profile: top.profile };
+    for (const reader of top.provider.capabilityReaders) {
+        const result = await reader.read(context);
+        const item = {
+            provider: top.provider.id,
+            profile: top.profile,
+            stage: 'capability-read',
+            source: reader.id,
+            signal: result.signal,
+            strength: result.strength,
+            detail: result.detail,
+        };
+        evidence.push(item);
+        if (result.signal === 'match')
+            top.points += STRENGTH_POINTS[result.strength];
+        if (result.signal === 'mismatch')
+            conflicts.push(item);
+    }
+    if (scoreOf(top.points) !== 'supported') {
+        return unresolvedResult('ambiguous', request, top.points, evidence, conflicts);
+    }
+    const operations = top.provider.operations(top.profile);
+    return {
+        status: 'selected',
+        provider: top.provider.id,
+        profile: top.profile,
+        score: 'supported',
+        confidence: confidenceOf(top.points),
+        evidence,
+        conflicts,
+        operations,
+        writable: operations.access === 'read-write',
+        generation: request.generation,
+        physicalModemId: request.physicalModemId,
+    };
+}
+class GenerationScopedProviderMatcher {
+    registry;
+    /** Cache mutation is scoped by physical modem, generation, firmware and composition. */
+    #cache = new Map();
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async match(request) {
+        const key = request.physicalModemId;
+        const signature = cacheSignature(request, this.registry.revision);
+        const cached = this.#cache.get(key);
+        if (cached?.signature === signature)
+            return cached.result;
+        const result = await evaluate(this.registry, request);
+        this.#cache.set(key, { signature, result });
+        return result;
+    }
+}
+export function createProviderMatcher(registry) {
+    return new GenerationScopedProviderMatcher(registry);
+}

package/dist/providers/modem-manager/errors.d.ts

@@ -0,0 +1,7 @@
+export declare const MODEM_MANAGER_REFUSAL_REASONS: readonly ["unauthorized", "unsupported", "wrong-state", "busy", "not-found", "timed-out", "disconnected", "failed"];
+export type ModemManagerRefusalReason = (typeof MODEM_MANAGER_REFUSAL_REASONS)[number];
+export type ModemManagerRefusal = {
+    readonly reason: ModemManagerRefusalReason;
+    readonly retryable: boolean;
+};
+export declare function mapModemManagerError(error: unknown): ModemManagerRefusal;

package/dist/providers/modem-manager/errors.js

@@ -0,0 +1,37 @@
+import { DisconnectedError, TransportError } from '../../transport/index.js';
+export const MODEM_MANAGER_REFUSAL_REASONS = [
+    'unauthorized',
+    'unsupported',
+    'wrong-state',
+    'busy',
+    'not-found',
+    'timed-out',
+    'disconnected',
+    'failed',
+];
+function errorIdentity(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const dbusName = Reflect.get(error, 'dbusName');
+    return `${typeof dbusName === 'string' ? dbusName : error.name} ${error.message}`;
+}
+export function mapModemManagerError(error) {
+    if (error instanceof DisconnectedError)
+        return { reason: 'disconnected', retryable: true };
+    const identity = errorIdentity(error);
+    if (/Unauthorized|AccessDenied/i.test(identity))
+        return { reason: 'unauthorized', retryable: false };
+    if (/Unsupported|NotSupported/i.test(identity))
+        return { reason: 'unsupported', retryable: false };
+    if (/WrongState|InvalidState/i.test(identity))
+        return { reason: 'wrong-state', retryable: true };
+    if (/InProgress|Busy/i.test(identity))
+        return { reason: 'busy', retryable: true };
+    if (/NotFound|UnknownObject|UnknownModem/i.test(identity)) {
+        return { reason: 'not-found', retryable: false };
+    }
+    if (error instanceof TransportError && /timed out/i.test(error.message)) {
+        return { reason: 'timed-out', retryable: true };
+    }
+    return { reason: 'failed', retryable: false };
+}

package/dist/providers/modem-manager/generic-operations.d.ts

@@ -0,0 +1,8 @@
+import type { MmDbusBackend } from '../../backend/index.js';
+import type { ProviderExecutionContext } from '../contracts.js';
+import type { ModemManagerProviderOperations, ModemManagerSnapshotResult } from './types.js';
+export interface GenericOperationsDeps {
+    readonly backend: MmDbusBackend;
+    readSnapshot(context: ProviderExecutionContext): Promise<ModemManagerSnapshotResult>;
+}
+export declare function createGenericOperations(deps: GenericOperationsDeps): Pick<ModemManagerProviderOperations, 'radio' | 'modes' | 'bands' | 'signal' | 'sim' | 'power'>;

package/dist/providers/modem-manager/generic-operations.js

@@ -0,0 +1,207 @@
+import { classifyOperationCompletion, defineOperationDescriptor, runtimePath, } from '../../domain/index.js';
+import { bandWriteReadbackMatches, buildBandWriteDescriptor, buildModeWriteDescriptor, encodeModeSelection, matchAdvertisedCombination, sameSelection, selectionOf, } from '../../radio/index.js';
+import { mapModemManagerError } from './errors.js';
+const PROVIDER_ID = 'modemmanager';
+const PROFILE = 'generic-mm';
+function readDescriptor(id) {
+    return defineOperationDescriptor({
+        id,
+        support: { read: { supported: true }, write: { supported: false, reason: 'read-only' } },
+        authority: 'provider',
+        provider: PROVIDER_ID,
+        constraints: { kind: 'unconstrained' },
+        livePreconditions: ['modem-present', 'runtime-interface-present'],
+        availability: { state: 'available' },
+        mutationImpact: 'read',
+        retryClass: 'idempotent-read',
+        readback: { required: false },
+        rollback: { required: false },
+        journal: { required: false },
+        admission: { required: false },
+        evidence: { profiles: [PROFILE], firmware: [] },
+        confidence: 'high',
+    });
+}
+function writeDescriptor(id) {
+    return defineOperationDescriptor({
+        id,
+        support: { read: { supported: true }, write: { supported: true } },
+        authority: 'provider',
+        provider: PROVIDER_ID,
+        constraints: { kind: 'unconstrained' },
+        livePreconditions: ['modem-present', 'runtime-interface-present'],
+        availability: { state: 'available' },
+        mutationImpact: 'disruptive',
+        retryClass: 'never',
+        readback: { required: false },
+        rollback: { required: false },
+        journal: { required: true, reason: 'disruptive-radio-write' },
+        admission: { required: true, reason: 'provider-mutation' },
+        evidence: { profiles: [PROFILE], firmware: [] },
+        confidence: 'high',
+    });
+}
+function applied(context, value) {
+    return classifyOperationCompletion({
+        operation: 'read',
+        completionGeneration: context.generation,
+        currentGeneration: context.generation,
+        completion: { status: 'applied', value },
+    });
+}
+function refused(context, reason) {
+    return classifyOperationCompletion({
+        operation: 'read',
+        completionGeneration: context.generation,
+        currentGeneration: context.generation,
+        completion: { status: 'refused', reason },
+    });
+}
+function receiptReason(reason) {
+    const mapped = mapModemManagerError(new Error(reason));
+    return mapped.reason === 'failed' ? reason : mapped.reason;
+}
+export function createGenericOperations(deps) {
+    const readField = async (context, capability, select, reason) => {
+        const snapshot = await deps.readSnapshot(context);
+        if (!snapshot.ok)
+            return refused(context, snapshot.reason);
+        return snapshot.capabilities[capability]
+            ? applied(context, select(snapshot))
+            : refused(context, reason);
+    };
+    const readBands = async (context) => {
+        const snapshot = await deps.readSnapshot(context);
+        if (!snapshot.ok)
+            return refused(context, snapshot.reason);
+        if (!snapshot.capabilities.bandRead)
+            return refused(context, 'band-read-unsupported');
+        const result = await deps.backend.readBands(runtimePath(snapshot.modemPath));
+        return result.ok
+            ? applied(context, result.bands)
+            : refused(context, receiptReason(result.reason));
+    };
+    const radioDescriptor = writeDescriptor('modemmanager.radio-modes');
+    const radio = {
+        descriptor: radioDescriptor,
+        describe: () => Promise.resolve(radioDescriptor),
+        read: (context) => readField(context, 'modeRead', (snapshot) => snapshot.radio, 'mode-read-unsupported'),
+        write: async (context, input) => {
+            const snapshot = await deps.readSnapshot(context);
+            if (!snapshot.ok)
+                return refused(context, snapshot.reason);
+            if (!snapshot.capabilities.modeWrite)
+                return refused(context, 'mode-write-unsupported');
+            const receipt = await deps.backend.setRadioModes(runtimePath(snapshot.modemPath), input);
+            if (receipt.status !== 'applied')
+                return refused(context, receiptReason(receipt.reason));
+            return readField(context, 'modeRead', (next) => next.radio, 'mode-read-unsupported');
+        },
+    };
+    const readModeTruth = async (context) => readField(context, 'modeRead', (snapshot) => snapshot.radio.truth, 'mode-read-unsupported');
+    const modes = {
+        descriptor: buildModeWriteDescriptor({
+            provider: PROVIDER_ID,
+            profile: PROFILE,
+            truth: {
+                current: { state: 'not-reported' },
+                supported: { combinations: [], undecodable: [] },
+            },
+            writeSupported: true,
+        }),
+        describe: async (context) => {
+            const snapshot = await deps.readSnapshot(context);
+            return buildModeWriteDescriptor({
+                provider: PROVIDER_ID,
+                profile: PROFILE,
+                truth: snapshot.ok
+                    ? snapshot.radio.truth
+                    : {
+                        current: { state: 'not-reported' },
+                        supported: { combinations: [], undecodable: [] },
+                    },
+                writeSupported: snapshot.ok && snapshot.capabilities.modeWrite,
+            });
+        },
+        read: readModeTruth,
+        write: async (context, selection) => {
+            const snapshot = await deps.readSnapshot(context);
+            if (!snapshot.ok)
+                return refused(context, snapshot.reason);
+            if (!snapshot.capabilities.modeWrite)
+                return refused(context, 'mode-write-unsupported');
+            // A selection the modem never advertised is refused outright — never rounded to
+            // the nearest advertised one. Substituting is how "prefer 4G" on a marginal cell
+            // silently becomes 5G-first, which `five-g-preference.ts` refuses for the same reason.
+            if (matchAdvertisedCombination(snapshot.radio.truth.supported, selection) === undefined) {
+                return refused(context, 'mode-combination-not-advertised');
+            }
+            const encoded = encodeModeSelection(selection);
+            if (!encoded.ok)
+                return refused(context, 'mode-name-unknown');
+            const receipt = await deps.backend.setModeCombination(runtimePath(snapshot.modemPath), encoded.allowedMask, encoded.preferredMask);
+            if (receipt.status !== 'applied')
+                return refused(context, receiptReason(receipt.reason));
+            const readback = await readModeTruth(context);
+            if (readback.status !== 'applied')
+                return readback;
+            // An accepted-but-ignored `SetCurrentModes` is indistinguishable from success at
+            // the call site, so the descriptor requires a readback and this enforces it.
+            return readback.value.current.state === 'reported' &&
+                sameSelection(selectionOf(readback.value.current.combination), selection)
+                ? readback
+                : refused(context, 'mode-write-readback-mismatch');
+        },
+    };
+    const bandDescriptorFor = (snapshot) => buildBandWriteDescriptor({
+        provider: PROVIDER_ID,
+        profile: PROFILE,
+        certification: snapshot.ok
+            ? snapshot.bandCertification
+            : {
+                required: true,
+                satisfied: false,
+                reason: 'band-certification-required',
+                offerable: [],
+            },
+        readSupported: snapshot.ok && snapshot.capabilities.bandRead,
+    });
+    const bands = {
+        descriptor: bandDescriptorFor({ ok: false, reason: 'not-found' }),
+        describe: async (context) => bandDescriptorFor(await deps.readSnapshot(context)),
+        read: readBands,
+        write: async (context, input) => {
+            const snapshot = await deps.readSnapshot(context);
+            if (!snapshot.ok)
+                return refused(context, snapshot.reason);
+            // The certification gate, second of two. `bandWrite` is already false without a
+            // catalog entry, and the descriptor already reads `refused` — but a band lock can
+            // take a working uplink off the air, so the call path refuses independently
+            // rather than trusting a consumer to have read the descriptor.
+            if (!snapshot.bandCertification.satisfied || !snapshot.capabilities.bandWrite)
+                return refused(context, 'band-write-certification-required');
+            const receipt = await deps.backend.setCurrentBands(runtimePath(snapshot.modemPath), input);
+            if (receipt.status !== 'applied')
+                return refused(context, receiptReason(receipt.reason));
+            const readback = await readBands(context);
+            if (readback.status !== 'applied')
+                return readback;
+            return bandWriteReadbackMatches(input, readback.value)
+                ? readback
+                : refused(context, 'band-write-readback-mismatch');
+        },
+    };
+    const signal = {
+        descriptor: readDescriptor('modemmanager.signal'),
+        read: (context) => readField(context, 'signalRead', (snapshot) => snapshot.signal, 'signal-read-unsupported'),
+    };
+    const sim = {
+        descriptor: readDescriptor('modemmanager.sim'),
+        read: (context) => readField(context, 'simRead', (snapshot) => snapshot.sim, 'sim-read-unsupported'),
+    };
+    const power = {
+        descriptor: readDescriptor('modemmanager.power'),
+        read: (context) => readField(context, 'powerRead', (snapshot) => snapshot.power, 'power-read-unsupported'),
+    };
+    return { radio, modes, bands, signal, sim, power };
+}

package/dist/providers/modem-manager/index.d.ts

@@ -0,0 +1,3 @@
+export * from './errors.js';
+export * from './provider.js';
+export * from './types.js';

package/dist/providers/modem-manager/index.js

@@ -0,0 +1,3 @@
+export * from './errors.js';
+export * from './provider.js';
+export * from './types.js';

package/dist/providers/modem-manager/module-operations.d.ts

@@ -0,0 +1,21 @@
+import type { MmLocation } from '../../backend/index.js';
+import type { DbusTransport } from '../../transport/index.js';
+import type { MmUssd } from '../../ussd/index.js';
+import type { ProviderExecutionContext } from '../contracts.js';
+import type { ModemManagerProviderOperations, ModemManagerSnapshotResult } from './types.js';
+export interface ModuleOperationsOptions {
+    readonly transport: DbusTransport;
+    readonly destination: string;
+    readonly location: MmLocation;
+    readonly ussd: MmUssd;
+    readonly now: () => number;
+    readSnapshot(context: ProviderExecutionContext): Promise<ModemManagerSnapshotResult>;
+}
+type ModuleOperationSurface = Pick<ModemManagerProviderOperations, 'location' | 'sms' | 'ussd' | 'initiateUssd' | 'respondUssd' | 'cancelUssd' | 'fccCoverage'>;
+export declare class ModemManagerModuleOperations {
+    #private;
+    readonly operations: ModuleOperationSurface;
+    constructor(options: ModuleOperationsOptions);
+    stop(): Promise<void>;
+}
+export {};