@ceralive/modem-control 1.1.0 → 1.2.1

package/dist/operation-ids.d.ts

@@ -0,0 +1,2 @@
+export declare const MODEM_OPERATION_IDS: readonly ["modemmanager.radio-modes", "modemmanager.mode-combination", "modemmanager.bands", "modemmanager.signal", "modemmanager.sim", "modemmanager.power", "modemmanager.usb-composition", "status", "signal", "mode", "data", "ufi.signal.read", "ufi.details.read", "nv.write", "efs.write", "identity.write", "calibration.write", "firmware.flash", "edl.automation", "driver.blind-retry", "interface.blind-retry", "diag.write", "diag.info-probe", "shell.transport-fallback"];
+export type ModemOperationId = (typeof MODEM_OPERATION_IDS)[number];

package/dist/operation-ids.js

@@ -0,0 +1,26 @@
+export const MODEM_OPERATION_IDS = Object.freeze([
+    'modemmanager.radio-modes',
+    'modemmanager.mode-combination',
+    'modemmanager.bands',
+    'modemmanager.signal',
+    'modemmanager.sim',
+    'modemmanager.power',
+    'modemmanager.usb-composition',
+    'status',
+    'signal',
+    'mode',
+    'data',
+    'ufi.signal.read',
+    'ufi.details.read',
+    'nv.write',
+    'efs.write',
+    'identity.write',
+    'calibration.write',
+    'firmware.flash',
+    'edl.automation',
+    'driver.blind-retry',
+    'interface.blind-retry',
+    'diag.write',
+    'diag.info-probe',
+    'shell.transport-fallback',
+]);

package/dist/ports/location.d.ts

@@ -5,7 +5,7 @@ import type { ModemRef } from './modem-manager.js';
  * names. `3gpp-lac-ci` is deliberately absent: coarse cell location is the cell-info
  * module's surface, and MM advertises it on devices with no GNSS receiver at all.
  */
-export declare const GNSS_SOURCES: readonly ["gps-raw", "gps-nmea", "gps-unmanaged", "agps-msa", "agps-msb"];
+export declare const GNSS_SOURCES: readonly ['gps-raw', 'gps-nmea', 'gps-unmanaged', 'agps-msa', 'agps-msb'];
 export type GnssSource = (typeof GNSS_SOURCES)[number];
 /** What `Modem.Location` advertises and what is switched on right now. */
 export interface LocationStatus {

package/dist/providers/contracts.d.ts

@@ -1,7 +1,7 @@
 import type { DeviceGeneration, ObservationEnvelope, OperationDescriptor, OperationResult, PhysicalModemId } from '../domain/index.js';
-export declare const PROVIDER_TRANSPORTS: readonly ["usb", "pci", "network", "modemmanager"];
+export declare const PROVIDER_TRANSPORTS: readonly ['usb', 'pci', 'network', 'modemmanager'];
 export type ProviderTransport = (typeof PROVIDER_TRANSPORTS)[number];
-export declare const PASSIVE_FACT_KINDS: readonly ["usb", "pci", "interface", "driver", "gateway", "model", "firmware"];
+export declare const PASSIVE_FACT_KINDS: readonly ['usb', 'pci', 'interface', 'driver', 'gateway', 'model', 'firmware'];
 export type PassiveFactKind = (typeof PASSIVE_FACT_KINDS)[number];
 export type EvidenceStrength = 'none' | 'weak' | 'moderate' | 'strong';
 export type MatcherScore = 'unsupported' | 'maybe' | 'likely' | 'supported';

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

@@ -4,14 +4,14 @@ import type { ProviderDefinition, ProviderOperationsSurface } from '../contracts
 import { HuaweiProvider, type ReadOperation, type WriteOperation } from './runtime.js';
 import type { HilinkTransport } from './transport.js';
 export declare const HILINK_PATHS: {
-    readonly session: "/api/webserver/SesTokInfo";
-    readonly loginState: "/api/user/state-login";
-    readonly login: "/api/user/login";
-    readonly status: "/api/monitoring/status";
-    readonly signal: "/api/device/signal";
-    readonly modeList: "/api/net/net-mode-list";
-    readonly mode: "/api/net/net-mode";
-    readonly data: "/api/dialup/mobile-dataswitch";
+    readonly session: '/api/webserver/SesTokInfo';
+    readonly loginState: '/api/user/state-login';
+    readonly login: '/api/user/login';
+    readonly status: '/api/monitoring/status';
+    readonly signal: '/api/device/signal';
+    readonly modeList: '/api/net/net-mode-list';
+    readonly mode: '/api/net/net-mode';
+    readonly data: '/api/dialup/mobile-dataswitch';
 };
 export type HilinkProfile = {
     readonly id: string;
@@ -19,12 +19,12 @@ export type HilinkProfile = {
     readonly passwordType: 3 | 4;
 };
 export declare const HILINK_PROFILES: readonly [{
-    readonly id: "e3372h-22.200-password-type-3";
-    readonly firmware: "22.200.05.00.1080";
+    readonly id: 'e3372h-22.200-password-type-3';
+    readonly firmware: '22.200.05.00.1080';
     readonly passwordType: 3;
 }, {
-    readonly id: "e3372h-22.333-password-type-4";
-    readonly firmware: "22.333.01.00.00";
+    readonly id: 'e3372h-22.333-password-type-4';
+    readonly firmware: '22.333.01.00.00';
     readonly passwordType: 4;
 }];
 export type HilinkCredentials = {

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

@@ -5,8 +5,8 @@ import { HilinkSessionRuntime } from './session.js';
 export type { ReadOperation, WriteOperation } from './operations.js';
 export declare class HuaweiProvider extends HilinkSessionRuntime {
     sessionProbe(request: ProviderMatchRequest): Promise<{
-        signal: "unknown" | "match";
-        strength: "strong";
+        signal: "match" | "unknown";
+        strength: 'strong';
         profiles: ("e3372h-22.200-password-type-3" | "e3372h-22.333-password-type-4")[];
         detail: string;
     }>;

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

@@ -1,4 +1,4 @@
-export declare const MODEM_MANAGER_REFUSAL_REASONS: readonly ["unauthorized", "unsupported", "wrong-state", "busy", "not-found", "timed-out", "disconnected", "failed"];
+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;

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

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

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

@@ -1,6 +1,7 @@
 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';
+import { createRuntimeCompositionOperation, } from './runtime-composition-operation.js';
 const PROVIDER_ID = 'modemmanager';
 const PROFILE = 'generic-mm';
 function readDescriptor(id) {
@@ -203,5 +204,6 @@ export function createGenericOperations(deps) {
         descriptor: readDescriptor('modemmanager.power'),
         read: (context) => readField(context, 'powerRead', (snapshot) => snapshot.power, 'power-read-unsupported'),
     };
-    return { radio, modes, bands, signal, sim, power };
+    const usbComposition = createRuntimeCompositionOperation(deps.runtimeComposition);
+    return { radio, modes, bands, signal, sim, power, usbComposition };
 }

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

@@ -1,3 +1,4 @@
 export * from './errors.js';
 export * from './provider.js';
+export * from './runtime-composition-operation.js';
 export * from './types.js';

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

@@ -1,3 +1,4 @@
 export * from './errors.js';
 export * from './provider.js';
+export * from './runtime-composition-operation.js';
 export * from './types.js';

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

@@ -4,6 +4,7 @@ import { type NormalizedModemObservation } from '../../observations/index.js';
 import type { ObservationListener } from '../../ports/index.js';
 import type { DbusTransport } from '../../transport/index.js';
 import type { ProviderDefinition, ProviderExecutionContext } from '../contracts.js';
+import type { RuntimeCompositionOperationDeps } from './runtime-composition-operation.js';
 import type { ModemManagerProviderLifecycle, ModemManagerProviderOperations, ModemManagerSnapshotResult } from './types.js';
 export interface ModemManagerProviderOptions {
     readonly transport: DbusTransport;
@@ -26,6 +27,7 @@ export interface ModemManagerProviderOptions {
      * hence no band write: fail-closed, which is this module's whole stance.
      */
     readonly bandSku?: (context: ProviderExecutionContext) => BandSku | undefined;
+    readonly runtimeComposition?: RuntimeCompositionOperationDeps;
 }
 export declare class ModemManagerProvider implements ModemManagerProviderLifecycle {
     #private;

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

@@ -60,6 +60,9 @@ export class ModemManagerProvider {
             ...createGenericOperations({
                 backend: this.#backend,
                 readSnapshot: (context) => this.readSnapshot(context),
+                ...(options.runtimeComposition === undefined
+                    ? {}
+                    : { runtimeComposition: options.runtimeComposition }),
             }),
             ...this.#moduleOperations.operations,
         };

package/dist/providers/modem-manager/runtime-composition-operation.d.ts

@@ -0,0 +1,32 @@
+import { type AtCommandSender, type UsbModeTransitionOutcome } from '../../backend/index.js';
+import { type RuntimeCompositionCapability, type RuntimeCompositionMode } from '../../usb-mode/index.js';
+import type { ProviderExecutionContext } from '../contracts.js';
+import type { ContextWriteOperation } from './types.js';
+export declare const RUNTIME_COMPOSITION_SUPPRESSIONS: readonly ['unknown-vendor', 'no-return-path', 'blocked-by-state', 'provisioning-disabled'];
+export type RuntimeCompositionSuppression = (typeof RUNTIME_COMPOSITION_SUPPRESSIONS)[number];
+export type RuntimeCompositionState = {
+    readonly status: 'available';
+    readonly current: RuntimeCompositionMode;
+    readonly enumerated: readonly RuntimeCompositionMode[];
+    readonly offerable: readonly RuntimeCompositionMode[];
+} | {
+    readonly status: 'suppressed';
+    readonly reason: RuntimeCompositionSuppression;
+    readonly detail: string;
+    readonly current: RuntimeCompositionMode | null;
+    readonly enumerated: readonly RuntimeCompositionMode[];
+    readonly offerable: readonly [];
+};
+export type RuntimeCompositionOperationDeps = {
+    readonly vendor: (context: ProviderExecutionContext) => string | Promise<string>;
+    readonly provisioningEnabled: (context: ProviderExecutionContext) => boolean | Promise<boolean>;
+    readonly blockedReason: (context: ProviderExecutionContext) => string | undefined | Promise<string | undefined>;
+    readonly atSender: AtCommandSender;
+    readonly transition: (context: ProviderExecutionContext, capability: Extract<RuntimeCompositionCapability, {
+        readonly status: 'available';
+    }>, target: RuntimeCompositionMode) => Promise<UsbModeTransitionOutcome>;
+};
+export interface RuntimeCompositionOperation extends ContextWriteOperation<RuntimeCompositionMode, RuntimeCompositionState> {
+    capability(context: ProviderExecutionContext): Promise<RuntimeCompositionState>;
+}
+export declare function createRuntimeCompositionOperation(deps: RuntimeCompositionOperationDeps | undefined): RuntimeCompositionOperation;

package/dist/providers/modem-manager/runtime-composition-operation.js

@@ -0,0 +1,153 @@
+import { AtCommandLease, computeAtAllowlist, } from '../../backend/index.js';
+import { classifyOperationCompletion, defineOperationDescriptor, } from '../../domain/index.js';
+import { isRuntimeCompositionVendor, RUNTIME_COMPOSITION_QUERY_REGISTRY, resolveRuntimeCompositionCapability, } from '../../usb-mode/index.js';
+export const RUNTIME_COMPOSITION_SUPPRESSIONS = [
+    'unknown-vendor',
+    'no-return-path',
+    'blocked-by-state',
+    'provisioning-disabled',
+];
+const OPERATION_ID = 'modemmanager.usb-composition';
+function suppressed(reason, detail, capability) {
+    return {
+        status: 'suppressed',
+        reason,
+        detail,
+        current: capability?.current ?? null,
+        enumerated: capability?.enumerated ?? [],
+        offerable: [],
+    };
+}
+function descriptorFor(state) {
+    const available = state.status === 'available';
+    return defineOperationDescriptor({
+        id: OPERATION_ID,
+        support: {
+            read: { supported: true },
+            write: available ? { supported: true } : { supported: false, reason: state.reason },
+        },
+        authority: 'provider',
+        provider: 'modemmanager',
+        constraints: {
+            kind: 'allowed-values',
+            values: available ? state.offerable : [],
+        },
+        livePreconditions: [
+            'modem-present',
+            'runtime-interface-present',
+            'identity-confident',
+            'streaming-interlock-open',
+        ],
+        availability: available ? { state: 'available' } : { state: 'refused', reason: state.reason },
+        mutationImpact: 'disruptive',
+        retryClass: 'never',
+        readback: {
+            required: true,
+            reason: 'device-reported-composition',
+            matches: (input, value) => value.status === 'available' && Object.is(input, value.current),
+        },
+        rollback: { required: true, reason: 'restore-previous-composition' },
+        journal: { required: true, reason: 'composition-reenumeration' },
+        admission: { required: true, reason: 'provider-mutation' },
+        evidence: { profiles: ['generic-mm'], firmware: [] },
+        confidence: available ? 'high' : 'unknown',
+    });
+}
+function result(context, completion) {
+    return classifyOperationCompletion({
+        operation: 'write',
+        completionGeneration: context.generation,
+        currentGeneration: context.generation,
+        completion,
+    });
+}
+function disabledOperation() {
+    const state = {
+        status: 'suppressed',
+        reason: 'provisioning-disabled',
+        detail: 'USB composition provisioning is not configured',
+        current: null,
+        enumerated: [],
+        offerable: [],
+    };
+    const descriptor = descriptorFor(state);
+    return {
+        descriptor,
+        describe: () => Promise.resolve(descriptor),
+        capability: () => Promise.resolve(state),
+        read: (context) => Promise.resolve(result(context, { status: 'applied', value: state })),
+        write: (context) => Promise.resolve(result(context, { status: 'refused', reason: state.reason })),
+    };
+}
+export function createRuntimeCompositionOperation(deps) {
+    if (deps === undefined)
+        return disabledOperation();
+    const capability = async (context) => {
+        const vendor = (await deps.vendor(context)).trim().toLowerCase();
+        if (!isRuntimeCompositionVendor(vendor))
+            return suppressed('unknown-vendor', `No reviewed composition query exists for ${vendor}`);
+        if (!(await deps.provisioningEnabled(context)))
+            return suppressed('provisioning-disabled', 'USB composition provisioning is disabled');
+        const blocked = await deps.blockedReason(context);
+        if (blocked !== undefined)
+            return suppressed('blocked-by-state', blocked);
+        const queries = RUNTIME_COMPOSITION_QUERY_REGISTRY[vendor];
+        const lease = new AtCommandLease({
+            sender: deps.atSender,
+            allowlist: computeAtAllowlist([]),
+        });
+        const current = await lease.run(queries.current);
+        const enumeration = await lease.run(queries.enumerate);
+        if (!current.ok || !enumeration.ok)
+            return suppressed('no-return-path', 'A runtime composition query failed');
+        const resolved = resolveRuntimeCompositionCapability({
+            vendor,
+            currentResponse: current.raw,
+            enumerationResponse: enumeration.raw,
+        });
+        if (resolved.status === 'unknown')
+            return suppressed('no-return-path', resolved.reason, resolved);
+        if (!resolved.returnPathProven)
+            return suppressed('no-return-path', 'The current mode is absent from the device catalog', resolved);
+        return {
+            status: 'available',
+            current: resolved.current,
+            enumerated: resolved.enumerated,
+            offerable: resolved.offerable.filter((mode) => !Object.is(mode, resolved.current)),
+        };
+    };
+    return {
+        descriptor: descriptorFor(suppressed('provisioning-disabled', 'Capability has not been read for this device')),
+        describe: async (context) => descriptorFor(await capability(context)),
+        capability,
+        read: async (context) => result(context, { status: 'applied', value: await capability(context) }),
+        write: async (context, target) => {
+            const state = await capability(context);
+            if (state.status === 'suppressed')
+                return result(context, { status: 'refused', reason: state.reason });
+            if (!state.offerable.some((candidate) => Object.is(candidate, target)))
+                return result(context, { status: 'refused', reason: 'no-return-path' });
+            const fullCapability = {
+                status: 'available',
+                current: state.current,
+                enumerated: state.enumerated,
+                returnPathProven: true,
+                offerable: [state.current, ...state.offerable],
+            };
+            const outcome = await deps.transition(context, fullCapability, target);
+            if (outcome.status === 'refused')
+                return result(context, { status: 'refused', reason: 'blocked-by-state' });
+            if (outcome.status === 'failed')
+                return result(context, { status: 'failed', reason: outcome.reason });
+            return result(context, {
+                status: 'applied',
+                value: {
+                    status: 'available',
+                    current: target,
+                    enumerated: state.enumerated,
+                    offerable: state.enumerated.filter((mode) => !Object.is(mode, target)),
+                },
+            });
+        },
+    };
+}

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

@@ -7,6 +7,7 @@ import type { BandWriteCertification, ModeSelection, RadioModeTruth } from '../.
 import type { MmUssd, UssdVerbResult } from '../../ussd/index.js';
 import type { ProviderExecutionContext, ProviderOperationsSurface } from '../contracts.js';
 import type { ModemManagerRefusalReason } from './errors.js';
+import type { RuntimeCompositionOperation } from './runtime-composition-operation.js';
 export type ModemManagerCapabilities = {
     readonly modeRead: boolean;
     readonly modeWrite: boolean;
@@ -113,6 +114,7 @@ export interface ModemManagerProviderOperations extends ProviderOperationsSurfac
     readonly signal: ContextReadOperation<ModemManagerSignalState>;
     readonly sim: ContextReadOperation<ModemManagerSimState>;
     readonly power: ContextReadOperation<RadioPower>;
+    readonly usbComposition: RuntimeCompositionOperation;
     readonly location: {
         status(context: ProviderExecutionContext): Promise<LocationStatusResult>;
         enable(context: ProviderExecutionContext, sources: readonly GnssSource[]): Promise<LocationToggleResult>;

package/dist/providers/network-manager/types.d.ts

@@ -8,7 +8,7 @@ import type { ConnectionId, DeviceIfname, GsmProfileInput, Receipt } from '../..
  * because a device in `prepare` carrying our connection is COMING UP, and reporting
  * that as a lost bearer would turn every ordinary activation into a false alarm.
  */
-export declare const NM_DEVICE_STATES: readonly ["unknown", "unmanaged", "unavailable", "disconnected", "prepare", "config", "need-auth", "ip-config", "ip-check", "secondaries", "activated", "deactivating", "failed"];
+export declare const NM_DEVICE_STATES: readonly ['unknown', 'unmanaged', 'unavailable', 'disconnected', 'prepare', 'config', 'need-auth', 'ip-config', 'ip-check', 'secondaries', 'activated', 'deactivating', 'failed'];
 export type NmDeviceState = (typeof NM_DEVICE_STATES)[number];
 /**
  * The bearer identity all three slots compare in.
@@ -85,7 +85,7 @@ export interface NmDesiredRequest {
     /** Update this existing profile instead of creating a new one. */
     readonly connectionId?: ConnectionId;
 }
-export declare const NM_ADAPTER_REFUSAL_REASONS: readonly ["no-desired-profile", "profile-absent", "activation-failed", "deactivation-failed", "write-failed"];
+export declare const NM_ADAPTER_REFUSAL_REASONS: readonly ['no-desired-profile', 'profile-absent', 'activation-failed', 'deactivation-failed', 'write-failed'];
 export type NmAdapterRefusalReason = (typeof NM_ADAPTER_REFUSAL_REASONS)[number];
 export type NmSaveResult = {
     readonly ok: true;
@@ -106,7 +106,15 @@ export type NmApplyResult = {
     readonly reason: NmAdapterRefusalReason;
     readonly receipt: Receipt;
 };
-export declare const NM_APPLIED_LOSS_REASONS: readonly ["interface-absent", "interface-detached", "connection-replaced", "activation-failed"];
+export declare const NM_APPLIED_LOSS_REASONS: readonly [
+/** The readout has no such device at all — a re-enumeration, or an unplug. */
+'interface-absent', 
+/** The device is present and carries no active connection. */
+'interface-detached', 
+/** A DIFFERENT connection is active on our device. */
+'connection-replaced', 
+/** NM reports the device itself failed. */
+'activation-failed'];
 export type NmAppliedLossReason = (typeof NM_APPLIED_LOSS_REASONS)[number];
 /**
  * The applied bearer stopped being in force.

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

@@ -10,7 +10,7 @@ export type UfiReadValue = Readonly<Record<string, unknown>>;
  * `write` member to omit — the absence is structural, not a convention this file keeps.
  */
 export type UfiReadOperation = ProviderReadOperations<UfiReadValue>;
-export declare const UFI_READ_OPERATION_IDS: readonly ["ufi.signal.read", "ufi.details.read"];
+export declare const UFI_READ_OPERATION_IDS: readonly ['ufi.signal.read', 'ufi.details.read'];
 export type UfiReadOperationId = (typeof UFI_READ_OPERATION_IDS)[number];
 export declare function isUfiReadOperation(operationId: string): operationId is UfiReadOperationId;
 export declare function ufiReadDescriptor(operationId: UfiReadOperationId): OperationDescriptor<never, UfiReadValue>;

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

@@ -2,48 +2,48 @@ import { type OperationDescriptor } from '../../domain/index.js';
 export type UfiProhibitionClass = 'device-integrity' | 'firmware' | 'recovery-automation' | 'diagnostic-channel' | 'transport-fallback';
 export declare const UFI_PROHIBITED_OPERATIONS: {
     readonly 'nv.write': {
-        readonly reason: "nv-write-prohibited";
-        readonly class: "device-integrity";
+        readonly reason: 'nv-write-prohibited';
+        readonly class: 'device-integrity';
     };
     readonly 'efs.write': {
-        readonly reason: "efs-write-prohibited";
-        readonly class: "device-integrity";
+        readonly reason: 'efs-write-prohibited';
+        readonly class: 'device-integrity';
     };
     readonly 'identity.write': {
-        readonly reason: "identity-write-prohibited";
-        readonly class: "device-integrity";
+        readonly reason: 'identity-write-prohibited';
+        readonly class: 'device-integrity';
     };
     readonly 'calibration.write': {
-        readonly reason: "calibration-write-prohibited";
-        readonly class: "device-integrity";
+        readonly reason: 'calibration-write-prohibited';
+        readonly class: 'device-integrity';
     };
     readonly 'firmware.flash': {
-        readonly reason: "firmware-flash-prohibited";
-        readonly class: "firmware";
+        readonly reason: 'firmware-flash-prohibited';
+        readonly class: 'firmware';
     };
     readonly 'edl.automation': {
-        readonly reason: "edl-automation-prohibited";
-        readonly class: "recovery-automation";
+        readonly reason: 'edl-automation-prohibited';
+        readonly class: 'recovery-automation';
     };
     readonly 'driver.blind-retry': {
-        readonly reason: "blind-driver-retry-prohibited";
-        readonly class: "recovery-automation";
+        readonly reason: 'blind-driver-retry-prohibited';
+        readonly class: 'recovery-automation';
     };
     readonly 'interface.blind-retry': {
-        readonly reason: "blind-interface-retry-prohibited";
-        readonly class: "recovery-automation";
+        readonly reason: 'blind-interface-retry-prohibited';
+        readonly class: 'recovery-automation';
     };
     readonly 'diag.write': {
-        readonly reason: "diag-write-prohibited";
-        readonly class: "diagnostic-channel";
+        readonly reason: 'diag-write-prohibited';
+        readonly class: 'diagnostic-channel';
     };
     readonly 'diag.info-probe': {
-        readonly reason: "diag-probe-is-bench-supervised-only";
-        readonly class: "diagnostic-channel";
+        readonly reason: 'diag-probe-is-bench-supervised-only';
+        readonly class: 'diagnostic-channel';
     };
     readonly 'shell.transport-fallback': {
-        readonly reason: "shell-transport-fallback-prohibited";
-        readonly class: "transport-fallback";
+        readonly reason: 'shell-transport-fallback-prohibited';
+        readonly class: 'transport-fallback';
     };
 };
 export type UfiProhibitedOperationId = keyof typeof UFI_PROHIBITED_OPERATIONS;

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

@@ -15,13 +15,13 @@ export type UfiOperationsSurface = ProviderOperationsSurface & {
 };
 export declare class UfiHimiProvider extends UfiSessionRuntime {
     fingerprint(request: ProviderMatchRequest): Promise<{
-        signal: "unknown";
-        strength: "strong";
+        signal: 'unknown';
+        strength: 'strong';
         profiles: readonly string[];
         detail: string;
     } | {
-        signal: "unknown" | "match";
-        strength: "strong";
+        signal: "match" | "unknown";
+        strength: 'strong';
         profiles: string[];
         detail: string;
     }>;

package/dist/providers/ufi-himi/qualcomm-evidence.d.ts

@@ -29,4 +29,4 @@ export declare function classifyUfiDiagEvidence(input: {
  * Unconditional. A descriptor-confirmed DIAG channel raises what a SUPERVISED BENCH
  * operator may attempt by hand; it never raises what this package may do on its own.
  */
-export declare const UFI_DIAG_PRODUCTION_ACCESS: "prohibited";
+export declare const UFI_DIAG_PRODUCTION_ACCESS: 'prohibited';

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

@@ -1,11 +1,11 @@
 /** 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 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 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;

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

@@ -4,22 +4,27 @@ import type { CapabilityReader, ProviderDefinition, ProviderExecutionContext, Pr
 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";
+    readonly get: '/goform/goform_get_cmd_process';
+    readonly set: '/goform/goform_set_cmd_process';
 };
+export declare const ZTE_EVIDENCE_CMD = "LD,psw_fail_num_str,login_lock_time,wa_inner_version,cr_version";
 export type ZteProfile = {
-    readonly id: 'mf79u-legacy' | 'mf266-salted';
+    readonly id: 'mf79u-legacy' | 'mf79u-ld-salted' | 'mf266-salted';
     readonly firmware: 'MF79U' | 'MF266';
-    readonly algorithm: 'legacy-base64' | 'salted-sha256';
+    readonly algorithm: 'legacy-base64' | 'login-salted-sha256' | 'multi-user-salted-sha256';
 };
 export declare const ZTE_PROFILES: readonly [{
-    readonly id: "mf79u-legacy";
-    readonly firmware: "MF79U";
-    readonly algorithm: "legacy-base64";
+    readonly id: 'mf79u-legacy';
+    readonly firmware: 'MF79U';
+    readonly algorithm: 'legacy-base64';
 }, {
-    readonly id: "mf266-salted";
-    readonly firmware: "MF266";
-    readonly algorithm: "salted-sha256";
+    readonly id: 'mf79u-ld-salted';
+    readonly firmware: 'MF79U';
+    readonly algorithm: 'login-salted-sha256';
+}, {
+    readonly id: 'mf266-salted';
+    readonly firmware: 'MF266';
+    readonly algorithm: 'multi-user-salted-sha256';
 }];
 export declare const ZTE_UNKNOWN_PROFILE = "zte-unknown-read-only";
 export type ZteCredentials = {
@@ -34,12 +39,12 @@ export type ZteOptions = {
     readonly now?: () => number;
 };
 type ZteOperations = ProviderOperationsSurface;
-export declare function zteProfileForFirmware(firmware: string | undefined): ZteProfile | undefined;
+export declare function zteProfilesForFirmware(firmware: string | undefined): readonly ZteProfile[];
 export declare function zteProfileById(profileId: string): ZteProfile | undefined;
 export declare class ZteGoformProvider extends ZteSessionRuntime {
     fingerprint(request: ProviderMatchRequest): Promise<{
-        signal: "unknown" | "match";
-        strength: "strong";
+        signal: "match" | "unknown";
+        strength: 'strong';
         profiles: string[];
         detail: string;
     }>;