@ceralive/modem-control 0.2.0 → 1.1.0

package/dist/providers/ufi-himi/session.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { ProviderMatchRequest } from '../contracts.js';
+import { type UfiHttpResponse, type UfiReadCommand, type UfiTransport } from './transport.js';
+export type UfiCredentials = {
+    readonly username: string;
+    readonly password: string;
+};
+export type UfiOptions = {
+    readonly interfaceName: string;
+    readonly adminUrl: string;
+    readonly transport: UfiTransport;
+    /** Ephemeral bench input. Injected by the caller, never persisted, never logged. */
+    readonly credentials: UfiCredentials;
+    readonly now?: () => number;
+};
+/** The HIMI firmware's own word for "your session is gone". */
+export declare const UFI_SESSION_REFUSAL = "SessionOut";
+declare const ufiReplySchema: z.ZodObject<{
+    reply: z.ZodString;
+    session: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strip>;
+export type UfiReply = z.infer<typeof ufiReplySchema>;
+export declare function parseUfiReply(body: string): UfiReply | undefined;
+/**
+ * Session acquisition, bounded to ONE login per physical modem per generation.
+ *
+ * The bound is a set of spent keys rather than a counter reset on failure: a HIMI
+ * device that refused a credential refuses it again, and a provider that re-tries on
+ * every poll turns a wrong password into a lockout nobody asked for. A refused or
+ * expired session therefore surfaces as an honest auth-expired READING; the next
+ * enumeration (a new generation) gets the next single attempt.
+ */
+export declare class UfiSessionRuntime {
+    #private;
+    protected readonly options: UfiOptions;
+    constructor(options: UfiOptions);
+    protected session(request: ProviderMatchRequest): Promise<string | undefined>;
+    protected read(command: UfiReadCommand, session: string): Promise<UfiHttpResponse>;
+    /** A refused session is dropped so the NEXT generation may spend its own attempt. */
+    protected forgetSession(request: ProviderMatchRequest): void;
+    protected sessionKey(request: ProviderMatchRequest): string;
+    protected observedAt(): number;
+    private request;
+}
+export {};

package/dist/providers/ufi-himi/session.js

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { UFI_API_PATH, } from './transport.js';
+/** The HIMI firmware's own word for "your session is gone". */
+export const UFI_SESSION_REFUSAL = 'SessionOut';
+const flatRecordSchema = z.record(z.string(), z.union([z.string(), z.number()]));
+const ufiReplySchema = z.object({
+    reply: z.string(),
+    session: z.string().optional(),
+    params: flatRecordSchema.optional(),
+});
+export function parseUfiReply(body) {
+    const parsed = z
+        .string()
+        .transform((value, context) => {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError))
+                throw error;
+            context.addIssue({ code: 'custom', message: 'invalid JSON' });
+            return z.NEVER;
+        }
+    })
+        .pipe(ufiReplySchema)
+        .safeParse(body);
+    return parsed.success ? parsed.data : undefined;
+}
+/**
+ * Session acquisition, bounded to ONE login per physical modem per generation.
+ *
+ * The bound is a set of spent keys rather than a counter reset on failure: a HIMI
+ * device that refused a credential refuses it again, and a provider that re-tries on
+ * every poll turns a wrong password into a lockout nobody asked for. A refused or
+ * expired session therefore surfaces as an honest auth-expired READING; the next
+ * enumeration (a new generation) gets the next single attempt.
+ */
+export class UfiSessionRuntime {
+    options;
+    #sessions = new Map();
+    #spent = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    async session(request) {
+        const key = this.sessionKey(request);
+        const held = this.#sessions.get(key);
+        if (held !== undefined)
+            return held;
+        if (this.#spent.has(key))
+            return undefined;
+        this.#spent.add(key);
+        const response = await this.request('login', JSON.stringify({
+            cmdid: 'login',
+            username: this.options.credentials.username,
+            password: this.options.credentials.password,
+        }));
+        const reply = response.status === 200 ? parseUfiReply(response.body) : undefined;
+        const session = reply?.reply === 'ok' ? reply.session : undefined;
+        if (session === undefined || session === '')
+            return undefined;
+        this.#sessions.set(key, session);
+        return session;
+    }
+    read(command, session) {
+        return this.request(command, JSON.stringify({ cmdid: command, sessionId: session }), session);
+    }
+    /** A refused session is dropped so the NEXT generation may spend its own attempt. */
+    forgetSession(request) {
+        this.#sessions.delete(this.sessionKey(request));
+    }
+    sessionKey(request) {
+        return `${request.physicalModemId}:${request.generation}`;
+    }
+    observedAt() {
+        return this.options.now?.() ?? Date.now();
+    }
+    request(command, body, session) {
+        return this.options.transport.request({
+            method: 'POST',
+            url: `${this.options.adminUrl}${UFI_API_PATH}`,
+            command,
+            body,
+            headers: [
+                ...(session === undefined ? [] : [`Authorization: ${session}`]),
+                'Content-Type: application/json;charset=UTF-8',
+            ],
+            interfaceName: this.options.interfaceName,
+            redirect: 'error',
+        });
+    }
+}

package/dist/providers/ufi-himi/transport.d.ts

@@ -0,0 +1,29 @@
+/** The seven read commands the HIMI firmware answers. Bench-observed, not inferred. */
+export declare const UFI_READ_COMMANDS: readonly ["getoverview", "getsysinfo", "getallstatus", "getapninfo", "getnetworkmode", "gethimiusbtether", "getproduceinfo"];
+export type UfiReadCommand = (typeof UFI_READ_COMMANDS)[number];
+/**
+ * The ONE non-read command. It opens a server-side session and changes nothing on the
+ * device; the modem's configuration, radio and storage are untouched by it.
+ */
+export declare const UFI_SESSION_COMMANDS: readonly ["login"];
+export type UfiSessionCommand = (typeof UFI_SESSION_COMMANDS)[number];
+export declare const UFI_COMMANDS: readonly ["getoverview", "getsysinfo", "getallstatus", "getapninfo", "getnetworkmode", "gethimiusbtether", "getproduceinfo", "login"];
+export type UfiCommand = UfiReadCommand | UfiSessionCommand;
+export declare const UFI_API_PATH = "/himiapi/json";
+export type UfiHttpRequest = {
+    readonly method: 'POST';
+    readonly url: string;
+    /** Frozen vocabulary: the field a write would have to travel in cannot name one. */
+    readonly command: UfiCommand;
+    readonly body: string;
+    readonly headers: readonly string[];
+    readonly interfaceName: string;
+    readonly redirect: 'error';
+};
+export type UfiHttpResponse = {
+    readonly status: number;
+    readonly body: string;
+};
+export interface UfiTransport {
+    request(request: UfiHttpRequest): Promise<UfiHttpResponse>;
+}

package/dist/providers/ufi-himi/transport.js

@@ -0,0 +1,25 @@
+// Qualcomm UFI / HIMI transport shape.
+//
+// HIMI is not a REST surface: every call is `POST /himiapi/json` and the VERB lives in
+// the JSON body's `cmdid`. So "read-only" cannot be expressed here as an HTTP-method
+// restriction the way it can for HiLink. The command vocabulary is frozen as a union
+// instead — a request this transport can carry names a member of `UFI_COMMANDS`, and no
+// `set*` / flash / reset member exists — which makes a write UNREPRESENTABLE rather than
+// merely refused at runtime.
+/** The seven read commands the HIMI firmware answers. Bench-observed, not inferred. */
+export const UFI_READ_COMMANDS = [
+    'getoverview',
+    'getsysinfo',
+    'getallstatus',
+    'getapninfo',
+    'getnetworkmode',
+    'gethimiusbtether',
+    'getproduceinfo',
+];
+/**
+ * The ONE non-read command. It opens a server-side session and changes nothing on the
+ * device; the modem's configuration, radio and storage are untouched by it.
+ */
+export const UFI_SESSION_COMMANDS = ['login'];
+export const UFI_COMMANDS = [...UFI_READ_COMMANDS, ...UFI_SESSION_COMMANDS];
+export const UFI_API_PATH = '/himiapi/json';

package/dist/providers/zte-goform/index.d.ts

@@ -0,0 +1,2 @@
+export * from './provider.js';
+export * from './transport.js';

package/dist/providers/zte-goform/index.js

@@ -0,0 +1,2 @@
+export * from './provider.js';
+export * from './transport.js';

package/dist/providers/zte-goform/provider.d.ts

@@ -0,0 +1,51 @@
+import type { ObservationEnvelope } from '../../domain/index.js';
+import type { NormalizedModemObservation } from '../../observations/index.js';
+import type { CapabilityReader, ProviderDefinition, ProviderExecutionContext, ProviderMatchRequest, ProviderOperationsSurface } from '../contracts.js';
+import { ZteSessionRuntime } from './session.js';
+import type { ZteTransport } from './transport.js';
+export declare const ZTE_PATHS: {
+    readonly get: "/goform/goform_get_cmd_process";
+    readonly set: "/goform/goform_set_cmd_process";
+};
+export type ZteProfile = {
+    readonly id: 'mf79u-legacy' | 'mf266-salted';
+    readonly firmware: 'MF79U' | 'MF266';
+    readonly algorithm: 'legacy-base64' | 'salted-sha256';
+};
+export declare const ZTE_PROFILES: readonly [{
+    readonly id: "mf79u-legacy";
+    readonly firmware: "MF79U";
+    readonly algorithm: "legacy-base64";
+}, {
+    readonly id: "mf266-salted";
+    readonly firmware: "MF266";
+    readonly algorithm: "salted-sha256";
+}];
+export declare const ZTE_UNKNOWN_PROFILE = "zte-unknown-read-only";
+export type ZteCredentials = {
+    readonly username: string;
+    readonly password: string;
+};
+export type ZteOptions = {
+    readonly interfaceName: string;
+    readonly adminUrl: string;
+    readonly transport: ZteTransport;
+    readonly credentials: ZteCredentials;
+    readonly now?: () => number;
+};
+type ZteOperations = ProviderOperationsSurface;
+export declare function zteProfileForFirmware(firmware: string | undefined): ZteProfile | undefined;
+export declare function zteProfileById(profileId: string): ZteProfile | undefined;
+export declare class ZteGoformProvider extends ZteSessionRuntime {
+    fingerprint(request: ProviderMatchRequest): Promise<{
+        signal: "unknown" | "match";
+        strength: "strong";
+        profiles: string[];
+        detail: string;
+    }>;
+    capability(): CapabilityReader;
+    observe(context: ProviderExecutionContext): Promise<readonly ObservationEnvelope<NormalizedModemObservation>[]>;
+    operations(_profile: string): ZteOperations;
+}
+export declare function createZteGoformDefinition(options: ZteOptions): ProviderDefinition<NormalizedModemObservation, ZteOperations>;
+export {};

package/dist/providers/zte-goform/provider.js

@@ -0,0 +1,101 @@
+import { normalizeZteObservation } from '../../observations/sources/zte.js';
+import { parseZteRecord, ZteSessionRuntime } from './session.js';
+export const ZTE_PATHS = {
+    get: '/goform/goform_get_cmd_process',
+    set: '/goform/goform_set_cmd_process',
+};
+export const ZTE_PROFILES = [
+    { id: 'mf79u-legacy', firmware: 'MF79U', algorithm: 'legacy-base64' },
+    { id: 'mf266-salted', firmware: 'MF266', algorithm: 'salted-sha256' },
+];
+export const ZTE_UNKNOWN_PROFILE = 'zte-unknown-read-only';
+export function zteProfileForFirmware(firmware) {
+    return ZTE_PROFILES.find((profile) => profile.firmware === firmware);
+}
+export function zteProfileById(profileId) {
+    return ZTE_PROFILES.find((profile) => profile.id === profileId);
+}
+export class ZteGoformProvider extends ZteSessionRuntime {
+    async fingerprint(request) {
+        const response = await this.get('cr_version,network_type');
+        const record = response.status === 200 ? parseZteRecord(response.body) : undefined;
+        const profile = zteProfileForFirmware(request.firmware);
+        const matches = record !== undefined;
+        return {
+            signal: matches ? 'match' : 'unknown',
+            strength: 'strong',
+            profiles: matches ? [profile?.id ?? ZTE_UNKNOWN_PROFILE] : [],
+            detail: matches ? 'zte-goform-shape' : 'zte-goform-not-proven',
+        };
+    }
+    capability() {
+        return {
+            id: 'zte-telemetry',
+            read: async () => {
+                const response = await this.get('network_type,signalbar,rssi,lte_rsrp,lte_rsrq,lte_snr');
+                const supported = response.status === 200 && parseZteRecord(response.body) !== undefined;
+                return {
+                    signal: supported ? 'match' : 'mismatch',
+                    strength: 'strong',
+                    detail: supported ? 'telemetry-reported' : 'telemetry-refused',
+                };
+            },
+        };
+    }
+    async observe(context) {
+        const response = await this.get('network_type,signalbar,rssi,lte_rsrp,lte_rsrq,lte_snr,network_provider,cell_id', this.sessionCookie(context));
+        if (response.status !== 200)
+            return [];
+        return [
+            normalizeZteObservation({ body: response.body }, {
+                stableKey: `modem:${this.options.interfaceName}`,
+                generation: context.generation,
+                sourceEpoch: 1,
+                observedAt: (this.options.now?.() ?? Date.now()),
+            }),
+        ];
+    }
+    operations(_profile) {
+        return { access: 'read-only' };
+    }
+}
+export function createZteGoformDefinition(options) {
+    const runtime = new ZteGoformProvider(options);
+    return {
+        id: 'zte-goform',
+        profileVersion: '1',
+        eligibleTransports: ['network'],
+        passiveMatchers: ZTE_PROFILES.map((profile) => ({
+            id: `firmware-${profile.firmware}`,
+            fact: 'firmware',
+            expected: [profile.firmware],
+            profiles: [profile.id],
+            strength: 'strong',
+            required: true,
+        })),
+        unauthenticatedProbes: [
+            { id: 'zte-goform-shape', run: (request) => runtime.fingerprint(request) },
+        ],
+        authenticatedProfile: {
+            algorithm: 'firmware-selected-zte-goform',
+            attemptLimit: 1,
+            authenticate: (request, candidates) => runtime.authenticateProfile(request, candidates),
+        },
+        capabilityReaders: [runtime.capability()],
+        observe: (context) => runtime.observe(context),
+        operations: (profile) => runtime.operations(profile),
+        contractFixtures: ZTE_PROFILES.map((profile) => ({
+            profile: profile.id,
+            request: {
+                method: 'POST',
+                path: ZTE_PATHS.set,
+                goformId: profile.algorithm === 'legacy-base64' ? 'LOGIN' : 'LOGIN_MULTI_USER',
+                interfaceBound: true,
+                redirects: 'disabled',
+            },
+            response: profile.algorithm === 'salted-sha256'
+                ? { status: 'matched', sessionMaterial: '[redacted]', ad: '[redacted]' }
+                : { status: 'matched', sessionMaterial: '[redacted]' },
+        })),
+    };
+}

package/dist/providers/zte-goform/session.d.ts

@@ -0,0 +1,17 @@
+import type { AuthenticatedProfileResult, ProviderMatchRequest } from '../contracts.js';
+import { type ZteOptions } from './provider.js';
+import type { ZteHttpResponse } from './transport.js';
+export declare function parseZteRecord(body: string): Readonly<Record<string, string | number>> | undefined;
+export declare class ZteSessionRuntime {
+    #private;
+    protected readonly options: ZteOptions;
+    constructor(options: ZteOptions);
+    authenticateProfile(request: ProviderMatchRequest, candidates: readonly string[]): Promise<AuthenticatedProfileResult>;
+    protected sessionCookie(request: ProviderMatchRequest): string | undefined;
+    protected get(cmd: string, cookie?: string, multiData?: boolean): Promise<ZteHttpResponse>;
+    private loginLegacy;
+    private loginSalted;
+    private sessionKey;
+    private post;
+    private request;
+}

package/dist/providers/zte-goform/session.js

@@ -0,0 +1,133 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { ZTE_PATHS, ZTE_UNKNOWN_PROFILE, zteProfileById, zteProfileForFirmware, } from './provider.js';
+const flatRecordSchema = z.record(z.string(), z.union([z.string(), z.number()]));
+export function parseZteRecord(body) {
+    const result = z
+        .string()
+        .transform((value, context) => {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError))
+                throw error;
+            context.addIssue({ code: 'custom', message: 'invalid JSON' });
+            return z.NEVER;
+        }
+    })
+        .pipe(flatRecordSchema)
+        .safeParse(body);
+    return result.success ? result.data : undefined;
+}
+function stokCookie(response) {
+    const expected = 'set-cookie';
+    const header = Object.entries(response.headers ?? {}).find(([key]) => key.toLowerCase() === expected)?.[1];
+    const cookie = header?.split(';', 1)[0]?.trim();
+    return cookie?.startsWith('stok=') ? cookie : undefined;
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex').toUpperCase();
+}
+export class ZteSessionRuntime {
+    options;
+    #sessions = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async authenticateProfile(request, candidates) {
+        const candidate = candidates.length === 1 ? candidates[0] : undefined;
+        if (candidate === ZTE_UNKNOWN_PROFILE) {
+            return { status: 'matched', profile: ZTE_UNKNOWN_PROFILE, detail: 'read-only-fingerprint' };
+        }
+        const profile = zteProfileById(candidate ?? '');
+        if (profile === undefined || zteProfileForFirmware(request.firmware)?.id !== profile.id) {
+            return { status: 'refused', detail: 'profile-mismatch' };
+        }
+        return profile.algorithm === 'legacy-base64'
+            ? this.loginLegacy(request, profile)
+            : this.loginSalted(request, profile);
+    }
+    sessionCookie(request) {
+        return this.#sessions.get(this.sessionKey(request))?.cookie;
+    }
+    get(cmd, cookie, multiData = false) {
+        const query = new URLSearchParams({ isTest: 'false', cmd });
+        if (multiData)
+            query.set('multi_data', '1');
+        return this.request('GET', `${ZTE_PATHS.get}?${query.toString()}`, undefined, cookie);
+    }
+    async loginLegacy(request, profile) {
+        const response = await this.post(new URLSearchParams({
+            goformId: 'LOGIN',
+            isTest: 'false',
+            password: Buffer.from(this.options.credentials.password).toString('base64'),
+        }).toString());
+        const record = parseZteRecord(response.body);
+        const cookie = stokCookie(response);
+        if (response.status !== 200 || record?.result !== '0' || cookie === undefined) {
+            return {
+                status: 'refused',
+                detail: record?.LD === undefined ? 'auth-rejection' : 'protocol-mismatch',
+            };
+        }
+        this.#sessions.set(this.sessionKey(request), { cookie });
+        return { status: 'matched', profile: profile.id, detail: 'login-ok' };
+    }
+    async loginSalted(request, profile) {
+        const ldResponse = await this.get('LD');
+        const ld = parseZteRecord(ldResponse.body)?.LD;
+        if (ldResponse.status !== 200 || typeof ld !== 'string') {
+            return { status: 'refused', detail: 'protocol-mismatch' };
+        }
+        const login = await this.post(new URLSearchParams({
+            goformId: 'LOGIN_MULTI_USER',
+            isTest: 'false',
+            password: sha256(`${sha256(this.options.credentials.password)}${ld}`),
+            IP: 'localhost',
+            user: this.options.credentials.username,
+        }).toString());
+        const cookie = stokCookie(login);
+        if (login.status !== 200 ||
+            parseZteRecord(login.body)?.result !== '0' ||
+            cookie === undefined) {
+            return { status: 'refused', detail: 'auth-rejection' };
+        }
+        const versions = parseZteRecord((await this.get('wa_inner_version,cr_version', cookie, true)).body);
+        const rd = parseZteRecord((await this.get('RD', cookie)).body)?.RD;
+        const waVersion = versions?.wa_inner_version;
+        const crVersion = versions?.cr_version;
+        if (typeof waVersion !== 'string' || typeof crVersion !== 'string' || typeof rd !== 'string') {
+            return { status: 'refused', detail: 'protocol-mismatch' };
+        }
+        this.#sessions.set(this.sessionKey(request), {
+            cookie,
+            ad: sha256(`${sha256(`${waVersion}${crVersion}`)}${rd}`),
+        });
+        return { status: 'matched', profile: profile.id, detail: 'login-ok' };
+    }
+    sessionKey(request) {
+        return `${request.physicalModemId}:${request.generation}`;
+    }
+    post(body) {
+        return this.request('POST', ZTE_PATHS.set, body);
+    }
+    request(method, path, body, cookie) {
+        const headers = [
+            ...(method === 'POST'
+                ? ['Content-Type: application/x-www-form-urlencoded; charset=UTF-8']
+                : []),
+            ...(cookie === undefined ? [] : [`Cookie: ${cookie}`]),
+            `Origin: ${this.options.adminUrl}`,
+            `Referer: ${this.options.adminUrl}/index.html`,
+        ];
+        return this.options.transport.request({
+            method,
+            url: `${this.options.adminUrl}${path}`,
+            ...(body === undefined ? {} : { body }),
+            headers,
+            interfaceName: this.options.interfaceName,
+            redirect: 'error',
+        });
+    }
+}

package/dist/providers/zte-goform/transport.d.ts

@@ -0,0 +1,16 @@
+export type ZteHttpRequest = {
+    readonly method: 'GET' | 'POST';
+    readonly url: string;
+    readonly body?: string;
+    readonly headers: readonly string[];
+    readonly interfaceName: string;
+    readonly redirect: 'error';
+};
+export type ZteHttpResponse = {
+    readonly status: number;
+    readonly body: string;
+    readonly headers?: Readonly<Record<string, string>>;
+};
+export interface ZteTransport {
+    request(request: ZteHttpRequest): Promise<ZteHttpResponse>;
+}

package/dist/providers/zte-goform/transport.js

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

package/dist/radio/band-truth.d.ts

@@ -0,0 +1,50 @@
+import { type BandCertificationEntry, type BandName } from '../band/index.js';
+import { type OperationDescriptor } from '../domain/index.js';
+import type { ModemBands } from '../ports/index.js';
+export declare const BAND_WRITE_OPERATION_ID = "modemmanager.bands";
+/** The refusal reasons a band write may carry. Certification is the first gate. */
+export declare const BAND_WRITE_REFUSAL = "band-certification-required";
+export declare const BAND_READ_REFUSAL = "band-read-unsupported";
+export declare const BAND_NONE_OFFERABLE_REFUSAL = "no-offerable-certified-bands";
+/**
+ * The band-lock certification decision for one device, as a descriptor consumer sees it.
+ *
+ * `required` is `true` unconditionally and is typed as the literal, so no code path can
+ * produce a band-write decision that does not require certification. This is the one
+ * capability module documented as STRICTER than `support-claim.ts`'s `capable` floor.
+ */
+export type BandWriteCertification = {
+    readonly required: true;
+    readonly satisfied: boolean;
+    readonly reason: 'band-certification-proven' | typeof BAND_WRITE_REFUSAL;
+    /** What the catalog proves is settable, intersected with what the modem advertises. */
+    readonly offerable: readonly BandName[];
+};
+export declare function describeBandWriteCertification(input: {
+    readonly entry: BandCertificationEntry | undefined;
+    readonly supported: readonly BandName[];
+}): BandWriteCertification;
+export type BandWriteDescriptorInput = {
+    readonly provider: string;
+    readonly profile: string;
+    readonly certification: BandWriteCertification;
+    readonly readSupported: boolean;
+};
+/**
+ * Whether a band readback confirms the write.
+ *
+ * A NARROWING lock must match exactly — a superset is a different lock from the one
+ * that was asked for. The reset (`['any']`) is the exception ModemManager forces:
+ * releasing a lock is `SetCurrentBands([ANY])`, and a modem afterwards reports either
+ * `any` or its whole supported set, both of which mean "no lock is in force".
+ */
+export declare function bandWriteReadbackMatches(requested: readonly BandName[], observed: ModemBands): boolean;
+/**
+ * The live band-write descriptor.
+ *
+ * `mutationImpact: 'disruptive'` because `SetCurrentBands` re-registers the radio and
+ * drops the bearer underneath NetworkManager; `readback` is REQUIRED because an
+ * accepted-but-ignored band write is the failure mode the catalog's own `readback`
+ * proof exists to catch, and it looks like success from the call site alone.
+ */
+export declare function buildBandWriteDescriptor(input: BandWriteDescriptorInput): OperationDescriptor<readonly BandName[], ModemBands>;