@ceralive/modem-control 1.1.0 → 1.2.0

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

@@ -4,27 +4,27 @@ export const ZTE_PATHS = {
     get: '/goform/goform_get_cmd_process',
     set: '/goform/goform_set_cmd_process',
 };
+export const ZTE_EVIDENCE_CMD = 'LD,psw_fail_num_str,login_lock_time,wa_inner_version,cr_version';
 export const ZTE_PROFILES = [
     { id: 'mf79u-legacy', firmware: 'MF79U', algorithm: 'legacy-base64' },
-    { id: 'mf266-salted', firmware: 'MF266', algorithm: 'salted-sha256' },
+    { id: 'mf79u-ld-salted', firmware: 'MF79U', algorithm: 'login-salted-sha256' },
+    { id: 'mf266-salted', firmware: 'MF266', algorithm: 'multi-user-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 zteProfilesForFirmware(firmware) {
+    return ZTE_PROFILES.filter((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;
+        const evidence = await this.probeEvidence(request);
+        const matches = evidence !== undefined;
         return {
             signal: matches ? 'match' : 'unknown',
             strength: 'strong',
-            profiles: matches ? [profile?.id ?? ZTE_UNKNOWN_PROFILE] : [],
+            profiles: matches ? [evidence.profile?.id ?? ZTE_UNKNOWN_PROFILE] : [],
             detail: matches ? 'zte-goform-shape' : 'zte-goform-not-proven',
         };
     }
@@ -63,13 +63,13 @@ export function createZteGoformDefinition(options) {
     const runtime = new ZteGoformProvider(options);
     return {
         id: 'zte-goform',
-        profileVersion: '1',
+        profileVersion: '2',
         eligibleTransports: ['network'],
-        passiveMatchers: ZTE_PROFILES.map((profile) => ({
-            id: `firmware-${profile.firmware}`,
+        passiveMatchers: ['MF79U', 'MF266'].map((firmware) => ({
+            id: `firmware-${firmware}`,
             fact: 'firmware',
-            expected: [profile.firmware],
-            profiles: [profile.id],
+            expected: [firmware],
+            profiles: zteProfilesForFirmware(firmware).map((profile) => profile.id),
             strength: 'strong',
             required: true,
         })),
@@ -77,7 +77,7 @@ export function createZteGoformDefinition(options) {
             { id: 'zte-goform-shape', run: (request) => runtime.fingerprint(request) },
         ],
         authenticatedProfile: {
-            algorithm: 'firmware-selected-zte-goform',
+            algorithm: 'evidence-selected-zte-goform',
             attemptLimit: 1,
             authenticate: (request, candidates) => runtime.authenticateProfile(request, candidates),
         },
@@ -89,11 +89,11 @@ export function createZteGoformDefinition(options) {
             request: {
                 method: 'POST',
                 path: ZTE_PATHS.set,
-                goformId: profile.algorithm === 'legacy-base64' ? 'LOGIN' : 'LOGIN_MULTI_USER',
+                goformId: profile.algorithm === 'multi-user-salted-sha256' ? 'LOGIN_MULTI_USER' : 'LOGIN',
                 interfaceBound: true,
                 redirects: 'disabled',
             },
-            response: profile.algorithm === 'salted-sha256'
+            response: profile.algorithm === 'multi-user-salted-sha256'
                 ? { status: 'matched', sessionMaterial: '[redacted]', ad: '[redacted]' }
                 : { status: 'matched', sessionMaterial: '[redacted]' },
         })),

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

@@ -1,17 +1,23 @@
 import type { AuthenticatedProfileResult, ProviderMatchRequest } from '../contracts.js';
-import { type ZteOptions } from './provider.js';
+import { type ZteOptions, type ZteProfile } from './provider.js';
 import type { ZteHttpResponse } from './transport.js';
+type ZteEvidence = {
+    readonly record: Readonly<Record<string, string | number>>;
+    readonly profile: ZteProfile | undefined;
+};
 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 probeEvidence(request: ProviderMatchRequest): Promise<ZteEvidence | undefined>;
     protected sessionCookie(request: ProviderMatchRequest): string | undefined;
     protected get(cmd: string, cookie?: string, multiData?: boolean): Promise<ZteHttpResponse>;
-    private loginLegacy;
+    private login;
     private loginSalted;
     private sessionKey;
     private post;
     private request;
 }
+export {};

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

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
-import { ZTE_PATHS, ZTE_UNKNOWN_PROFILE, zteProfileById, zteProfileForFirmware, } from './provider.js';
+import { ZTE_EVIDENCE_CMD, ZTE_PATHS, ZTE_UNKNOWN_PROFILE, zteProfileById, zteProfilesForFirmware, } from './provider.js';
 const flatRecordSchema = z.record(z.string(), z.union([z.string(), z.number()]));
 export function parseZteRecord(body) {
     const result = z
@@ -29,9 +29,47 @@ function stokCookie(response) {
 function sha256(value) {
     return createHash('sha256').update(value).digest('hex').toUpperCase();
 }
+function evidenceNumber(value) {
+    if (typeof value === 'string' && value.trim() === '')
+        return undefined;
+    const parsed = typeof value === 'number' ? value : Number(value);
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function profileFromEvidence(firmware, record) {
+    const versionEvidence = `${record.wa_inner_version ?? ''} ${record.cr_version ?? ''}`.toUpperCase();
+    const family = versionEvidence.includes('MF266')
+        ? 'MF266'
+        : versionEvidence.includes('MF79U')
+            ? 'MF79U'
+            : firmware;
+    const hasLd = typeof record.LD === 'string' && record.LD.length > 0;
+    const profileId = family === 'MF266'
+        ? hasLd
+            ? 'mf266-salted'
+            : undefined
+        : family === 'MF79U'
+            ? hasLd
+                ? 'mf79u-ld-salted'
+                : 'mf79u-legacy'
+            : undefined;
+    return zteProfilesForFirmware(family).find((profile) => profile.id === profileId);
+}
+function classifyLogin(response) {
+    const result = parseZteRecord(response.body)?.result;
+    if (response.status !== 200 || result === '1') {
+        return { status: 'refused', detail: 'protocol-mismatch' };
+    }
+    if (result === '3')
+        return { status: 'refused', detail: 'auth-rejection' };
+    const cookie = stokCookie(response);
+    return result === '0' && cookie !== undefined
+        ? { status: 'accepted', cookie }
+        : { status: 'refused', detail: 'protocol-mismatch' };
+}
 export class ZteSessionRuntime {
     options;
     #sessions = new Map();
+    #evidence = new Map();
     constructor(options) {
         this.options = options;
     }
@@ -41,12 +79,48 @@ export class ZteSessionRuntime {
             return { status: 'matched', profile: ZTE_UNKNOWN_PROFILE, detail: 'read-only-fingerprint' };
         }
         const profile = zteProfileById(candidate ?? '');
-        if (profile === undefined || zteProfileForFirmware(request.firmware)?.id !== profile.id) {
+        if (profile === undefined) {
             return { status: 'refused', detail: 'profile-mismatch' };
         }
-        return profile.algorithm === 'legacy-base64'
-            ? this.loginLegacy(request, profile)
-            : this.loginSalted(request, profile);
+        const evidence = this.#evidence.get(this.sessionKey(request)) ?? (await this.probeEvidence(request));
+        if (evidence === undefined)
+            return { status: 'refused', detail: 'protocol-mismatch' };
+        const remainingAttempts = evidenceNumber(evidence.record.psw_fail_num_str);
+        const lockTime = evidenceNumber(evidence.record.login_lock_time);
+        if (remainingAttempts === undefined || lockTime === undefined) {
+            return { status: 'refused', detail: 'protocol-mismatch' };
+        }
+        if (lockTime > 0 || remainingAttempts === 0) {
+            return { status: 'refused', detail: 'lockout' };
+        }
+        if (evidence.profile?.id !== profile.id) {
+            return { status: 'refused', detail: 'protocol-mismatch' };
+        }
+        switch (profile.algorithm) {
+            case 'legacy-base64':
+                return this.login(request, profile, Buffer.from(this.options.credentials.password).toString('base64'));
+            case 'login-salted-sha256': {
+                const ld = evidence.record.LD;
+                if (typeof ld !== 'string')
+                    return { status: 'refused', detail: 'protocol-mismatch' };
+                return this.login(request, profile, sha256(`${sha256(this.options.credentials.password)}${ld}`));
+            }
+            case 'multi-user-salted-sha256':
+                return this.loginSalted(request, profile, evidence.record);
+            default: {
+                const exhaustive = profile.algorithm;
+                return exhaustive;
+            }
+        }
+    }
+    async probeEvidence(request) {
+        const response = await this.get(ZTE_EVIDENCE_CMD, undefined, true);
+        const record = response.status === 200 ? parseZteRecord(response.body) : undefined;
+        if (record === undefined)
+            return undefined;
+        const evidence = { record, profile: profileFromEvidence(request.firmware, record) };
+        this.#evidence.set(this.sessionKey(request), evidence);
+        return evidence;
     }
     sessionCookie(request) {
         return this.#sessions.get(this.sessionKey(request))?.cookie;
@@ -57,27 +131,21 @@ export class ZteSessionRuntime {
             query.set('multi_data', '1');
         return this.request('GET', `${ZTE_PATHS.get}?${query.toString()}`, undefined, cookie);
     }
-    async loginLegacy(request, profile) {
+    async login(request, profile, password) {
         const response = await this.post(new URLSearchParams({
             goformId: 'LOGIN',
             isTest: 'false',
-            password: Buffer.from(this.options.credentials.password).toString('base64'),
+            password,
         }).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 });
+        const result = classifyLogin(response);
+        if (result.status === 'refused')
+            return result;
+        this.#sessions.set(this.sessionKey(request), { cookie: result.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') {
+    async loginSalted(request, profile, evidence) {
+        const ld = evidence.LD;
+        if (typeof ld !== 'string') {
             return { status: 'refused', detail: 'protocol-mismatch' };
         }
         const login = await this.post(new URLSearchParams({
@@ -87,21 +155,17 @@ export class ZteSessionRuntime {
             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;
+        const result = classifyLogin(login);
+        if (result.status === 'refused')
+            return result;
+        const rd = parseZteRecord((await this.get('RD', result.cookie)).body)?.RD;
+        const waVersion = evidence.wa_inner_version;
+        const crVersion = evidence.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,
+            cookie: result.cookie,
             ad: sha256(`${sha256(`${waVersion}${crVersion}`)}${rd}`),
         });
         return { status: 'matched', profile: profile.id, detail: 'login-ok' };

package/dist/radio/mode-combinations.d.ts

@@ -28,7 +28,17 @@ export declare function encodeModeNames(names: readonly ModeName[]): {
     readonly unknown: ModeName;
 };
 /** Why a combination could not be fully placed. Never a reason to hide it. */
-export declare const MODE_COMBINATION_ANOMALIES: readonly ["unnamed-allowed-bit", "unnamed-preferred-bit", "preferred-not-in-allowed", "preferred-not-singular", "empty-allowed"];
+export declare const MODE_COMBINATION_ANOMALIES: readonly [
+/** The allowed mask carries a bit this build does not name. */
+'unnamed-allowed-bit', 
+/** The preferred mask carries a bit this build does not name. */
+'unnamed-preferred-bit', 
+/** The preferred mode is not a member of the allowed set. */
+'preferred-not-in-allowed', 
+/** The preferred mask names more than one mode; MM's contract is at most one. */
+'preferred-not-singular', 
+/** The allowed mask is zero — nothing can be selected from this combination. */
+'empty-allowed'];
 export type ModeCombinationAnomaly = (typeof MODE_COMBINATION_ANOMALIES)[number];
 export type ModeCombinationClassification = 'named' | 'unknown-combination';
 /**

package/dist/safety/flock-resource-ownership.js

@@ -1,14 +1,5 @@
 import { spawn } from 'node:child_process';
-import { readFile } from 'node:fs/promises';
-const LOCK_HELPER = String.raw `
-import { writeFileSync } from 'node:fs';
-const lockPath = process.env.CERALIVE_MODEM_CONTROL_LOCK_PATH;
-if (!lockPath) process.exit(64);
-const holder = { pid: process.pid, startedAtEpochMs: Date.now() };
-writeFileSync(lockPath, JSON.stringify(holder) + '\n', { mode: 0o600 });
-process.stdout.write(JSON.stringify({ type: 'acquired', holder }) + '\n');
-process.stdin.resume();
-`;
+import { readFile, writeFile } from 'node:fs/promises';
 export class FlockResourceOwnershipError extends Error {
     detail;
     name = 'FlockResourceOwnershipError';
@@ -20,23 +11,13 @@ export class FlockResourceOwnershipError extends Error {
 export function createFlockResourceOwnershipPort(options) {
     return {
         async acquire() {
-            const child = spawn(options.flockBinary ?? 'flock', [
-                '--exclusive',
-                '--nonblock',
-                '--no-fork',
-                options.lockPath,
-                process.execPath,
-                '-e',
-                LOCK_HELPER,
-            ], {
-                env: {
-                    ...process.env,
-                    CERALIVE_MODEM_CONTROL_LOCK_PATH: options.lockPath,
-                },
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
+            const child = spawn(options.flockBinary ?? 'flock', ['--exclusive', '--nonblock', '--no-fork', options.lockPath, '/bin/cat'], { stdio: ['pipe', 'pipe', 'pipe'] });
+            if (child.pid === undefined) {
+                throw new FlockResourceOwnershipError('helper started without a process id');
+            }
+            const holder = { pid: child.pid, startedAtEpochMs: Date.now() };
             const closed = childClosed(child);
-            const started = await childStarted(child);
+            const started = await childStarted(child, options.lockPath, holder);
             if (started.status === 'closed') {
                 if (started.code === 1) {
                     const holder = await readHolder(options.lockPath);
@@ -74,8 +55,8 @@ function createLease(child, closed, holder) {
 function childClosed(child) {
     return new Promise((resolve) => child.once('close', () => resolve()));
 }
-function childStarted(child) {
-    return new Promise((resolve) => {
+function childStarted(child, lockPath, holder) {
+    return new Promise((resolve, reject) => {
         let stdout = '';
         let stderr = '';
         let settled = false;
@@ -93,11 +74,17 @@ function childStarted(child) {
             const newline = stdout.indexOf('\n');
             if (newline < 0)
                 return;
-            const holder = parseAcquiredLine(stdout.slice(0, newline));
-            if (holder !== undefined)
-                finish({ status: 'acquired', holder });
+            const acquired = parseAcquiredLine(stdout.slice(0, newline));
+            if (acquired === undefined || settled)
+                return;
+            settled = true;
+            void writeFile(lockPath, `${JSON.stringify(holder)}\n`, { mode: 0o600 }).then(() => resolve({ status: 'acquired', holder }), (error) => {
+                child.stdin.end();
+                reject(error);
+            });
         });
         child.once('close', (code) => finish({ status: 'closed', code, stderr: stderr.trim() }));
+        child.stdin.write(`${JSON.stringify({ type: 'acquired', holder })}\n`);
     });
 }
 function parseAcquiredLine(line) {

package/dist/usb-mode/catalog-schema.d.ts

@@ -4,14 +4,14 @@ import { z } from 'zod';
  * any of these; only the first three are ModemManager-manageable. (Structurally
  * identical to `PreferredUsbMode` in the power contract — A4.2 owns this vocabulary.)
  */
-export declare const CANONICAL_USB_MODES: readonly ["qmi", "mbim", "ecm-ncm", "rndis", "router-ethernet"];
+export declare const CANONICAL_USB_MODES: readonly ['qmi', 'mbim', 'ecm-ncm', 'rndis', 'router-ethernet'];
 export type CanonicalUsbMode = (typeof CANONICAL_USB_MODES)[number];
 /**
  * The ModemManager-manageable modes — the ONLY modes a transition may move between.
  * `rndis` and `router-ethernet` are deliberately absent: a device in either is not
  * MM-managed, so switching to/from them crosses the MM↔router line the schema forbids.
  */
-export declare const MM_USB_MODES: readonly ["qmi", "mbim", "ecm-ncm"];
+export declare const MM_USB_MODES: readonly ['qmi', 'mbim', 'ecm-ncm'];
 export type MmUsbMode = (typeof MM_USB_MODES)[number];
 /** The USB descriptors a device must present AFTER a transition — the postcondition. */
 export declare const expectedDescriptorsSchema: z.ZodObject<{
@@ -26,14 +26,14 @@ export type ExpectedDescriptors = z.infer<typeof expectedDescriptorsSchema>;
 /** One permitted, certified transition between two MM modes. */
 export declare const permittedTransitionSchema: z.ZodObject<{
     from: z.ZodEnum<{
-        qmi: "qmi";
-        mbim: "mbim";
         "ecm-ncm": "ecm-ncm";
+        mbim: "mbim";
+        qmi: "qmi";
     }>;
     to: z.ZodEnum<{
-        qmi: "qmi";
-        mbim: "mbim";
         "ecm-ncm": "ecm-ncm";
+        mbim: "mbim";
+        qmi: "qmi";
     }>;
     atCommand: z.ZodString;
     applyCommand: z.ZodOptional<z.ZodString>;
@@ -56,22 +56,22 @@ export declare const catalogEntrySchema: z.ZodObject<{
     model: z.ZodString;
     firmwarePrefix: z.ZodString;
     canonicalMode: z.ZodEnum<{
-        qmi: "qmi";
-        mbim: "mbim";
         "ecm-ncm": "ecm-ncm";
+        mbim: "mbim";
+        qmi: "qmi";
         rndis: "rndis";
         "router-ethernet": "router-ethernet";
     }>;
     permittedTransitions: z.ZodArray<z.ZodObject<{
         from: z.ZodEnum<{
-            qmi: "qmi";
-            mbim: "mbim";
             "ecm-ncm": "ecm-ncm";
+            mbim: "mbim";
+            qmi: "qmi";
         }>;
         to: z.ZodEnum<{
-            qmi: "qmi";
-            mbim: "mbim";
             "ecm-ncm": "ecm-ncm";
+            mbim: "mbim";
+            qmi: "qmi";
         }>;
         atCommand: z.ZodString;
         applyCommand: z.ZodOptional<z.ZodString>;
@@ -97,22 +97,22 @@ export declare const certifiedCatalogSchema: z.ZodObject<{
         model: z.ZodString;
         firmwarePrefix: z.ZodString;
         canonicalMode: z.ZodEnum<{
-            qmi: "qmi";
-            mbim: "mbim";
             "ecm-ncm": "ecm-ncm";
+            mbim: "mbim";
+            qmi: "qmi";
             rndis: "rndis";
             "router-ethernet": "router-ethernet";
         }>;
         permittedTransitions: z.ZodArray<z.ZodObject<{
             from: z.ZodEnum<{
-                qmi: "qmi";
-                mbim: "mbim";
                 "ecm-ncm": "ecm-ncm";
+                mbim: "mbim";
+                qmi: "qmi";
             }>;
             to: z.ZodEnum<{
-                qmi: "qmi";
-                mbim: "mbim";
                 "ecm-ncm": "ecm-ncm";
+                mbim: "mbim";
+                qmi: "qmi";
             }>;
             atCommand: z.ZodString;
             applyCommand: z.ZodOptional<z.ZodString>;

package/dist/usb-mode/index.d.ts

@@ -2,4 +2,5 @@ export { CERTIFIED_CATALOG, findCatalogEntry, findPermittedTransition, loadCerti
 export { CANONICAL_USB_MODES, type CanonicalUsbMode, type CatalogEntry, type CertifiedCatalog, catalogEntrySchema, certifiedCatalogSchema, type ExpectedDescriptors, expectedDescriptorsSchema, MM_USB_MODES, type MmUsbMode, type PermittedTransition, permittedTransitionSchema, type SkuDiscriminator, } from './catalog-schema.js';
 export { buildCatalogEntryCandidate, buildClassifierFixture, type CatalogClaim, CLAIMABLE_CANONICAL_MODES, type ClassifierFixture, type EvidenceBundleView, evidenceBundleViewSchema, type FixtureProvenance, type IngestionOutcome, type IngestionRefusal, type IngestionRefusalReason, type IngestionRequest, parseIngestionRequest, } from './ingestion.js';
 export { type PromotionContext, type PromotionRequest, renderPromotionReview, } from './promotion-review.js';
+export { buildRuntimeCompositionSetCommand, isRuntimeCompositionVendor, RUNTIME_COMPOSITION_QUERY_REGISTRY, RUNTIME_COMPOSITION_SET_REGISTRY, RUNTIME_COMPOSITION_VENDORS, type RuntimeCompositionCapability, type RuntimeCompositionMode, type RuntimeCompositionQuery, type RuntimeCompositionResponse, type RuntimeCompositionSetCommand, type RuntimeCompositionVendor, readRuntimeCompositionCurrent, resolveRuntimeCompositionCapability, } from './runtime-capability.js';
 export { type ParsedUsbDevice, type ParsedUsbInterface, parseUsbDevices, selectUniqueDevice, } from './usb-devices-parse.js';

package/dist/usb-mode/index.js

@@ -12,4 +12,5 @@ export { CERTIFIED_CATALOG, findCatalogEntry, findPermittedTransition, loadCerti
 export { CANONICAL_USB_MODES, catalogEntrySchema, certifiedCatalogSchema, expectedDescriptorsSchema, MM_USB_MODES, permittedTransitionSchema, } from './catalog-schema.js';
 export { buildCatalogEntryCandidate, buildClassifierFixture, CLAIMABLE_CANONICAL_MODES, evidenceBundleViewSchema, parseIngestionRequest, } from './ingestion.js';
 export { renderPromotionReview, } from './promotion-review.js';
+export { buildRuntimeCompositionSetCommand, isRuntimeCompositionVendor, RUNTIME_COMPOSITION_QUERY_REGISTRY, RUNTIME_COMPOSITION_SET_REGISTRY, RUNTIME_COMPOSITION_VENDORS, readRuntimeCompositionCurrent, resolveRuntimeCompositionCapability, } from './runtime-capability.js';
 export { parseUsbDevices, selectUniqueDevice, } from './usb-devices-parse.js';

package/dist/usb-mode/ingestion.d.ts

@@ -18,14 +18,14 @@ export declare const evidenceBundleViewSchema: z.ZodObject<{
     }, z.core.$strip>;
     transition: z.ZodOptional<z.ZodObject<{
         from: z.ZodEnum<{
-            qmi: "qmi";
-            mbim: "mbim";
             "ecm-ncm": "ecm-ncm";
+            mbim: "mbim";
+            qmi: "qmi";
         }>;
         to: z.ZodEnum<{
-            qmi: "qmi";
-            mbim: "mbim";
             "ecm-ncm": "ecm-ncm";
+            mbim: "mbim";
+            qmi: "qmi";
         }>;
         atCommand: z.ZodString;
         expectedResponse: z.ZodString;

package/dist/usb-mode/runtime-capability.d.ts

@@ -0,0 +1,59 @@
+export declare const RUNTIME_COMPOSITION_VENDORS: readonly ['fibocom', 'quectel', 'simcom', 'sierra'];
+export type RuntimeCompositionVendor = (typeof RUNTIME_COMPOSITION_VENDORS)[number];
+export type RuntimeCompositionMode = number | string;
+export type RuntimeCompositionQuery = {
+    readonly current: string;
+    readonly enumerate: string;
+};
+export type RuntimeCompositionSetCommand = (target: RuntimeCompositionMode) => string | undefined;
+/** Commands only: selecting a port, sending, deadlines, and retries belong to the provider. */
+export declare const RUNTIME_COMPOSITION_QUERY_REGISTRY: Readonly<{
+    fibocom: Readonly<{
+        current: "AT+GTUSBMODE?";
+        enumerate: "AT+GTUSBMODE=?";
+    }>;
+    quectel: Readonly<{
+        current: "AT+QCFG=\"usbnet\"";
+        enumerate: "AT+QCFG=?";
+    }>;
+    simcom: Readonly<{
+        current: "AT+CUSBPIDSWITCH?";
+        enumerate: "AT+CUSBPIDSWITCH=?";
+    }>;
+    sierra: Readonly<{
+        current: "AT!USBCOMP?";
+        enumerate: "AT!USBCOMP=?";
+    }>;
+}>;
+/** Exact reviewed SET forms. Callers still allowlist only the one enumerated target selected. */
+export declare const RUNTIME_COMPOSITION_SET_REGISTRY: Readonly<{
+    fibocom: RuntimeCompositionSetCommand;
+    quectel: RuntimeCompositionSetCommand;
+    simcom: (target: RuntimeCompositionMode) => string | undefined;
+    sierra: RuntimeCompositionSetCommand;
+}>;
+export type RuntimeCompositionCapability = {
+    readonly status: 'available';
+    readonly current: RuntimeCompositionMode;
+    readonly enumerated: readonly RuntimeCompositionMode[];
+    readonly returnPathProven: boolean;
+    readonly offerable: readonly RuntimeCompositionMode[];
+} | {
+    readonly status: 'unknown';
+    readonly current: null;
+    readonly enumerated: readonly [];
+    readonly returnPathProven: false;
+    readonly offerable: readonly [];
+    readonly reason: 'vendor-unsupported' | 'malformed-response';
+};
+export type RuntimeCompositionResponse = {
+    readonly vendor: string;
+    readonly currentResponse: string;
+    readonly enumerationResponse: string;
+};
+export declare function isRuntimeCompositionVendor(vendor: string): vendor is RuntimeCompositionVendor;
+export declare function buildRuntimeCompositionSetCommand(vendor: string, target: RuntimeCompositionMode): string | undefined;
+/** Parse only the vendor READ response used by the weaker post-switch proof tier. */
+export declare function readRuntimeCompositionCurrent(vendor: string, response: string): RuntimeCompositionMode | undefined;
+/** Derive controls exclusively from the device's current and enumerated response text. */
+export declare function resolveRuntimeCompositionCapability(input: RuntimeCompositionResponse): RuntimeCompositionCapability;