@moldable-ai/ui 0.2.17 → 0.2.19

package/dist/lib/native-hardware/native-device-io.d.ts

@@ -0,0 +1,28 @@
+import { type NativeHardwareBridgeOptions } from './bridge';
+export type MoldableNativeDeviceKind = 'usb' | 'hid' | 'serial';
+export interface MoldableNativeDeviceDescriptor {
+    selector: string;
+    kind: MoldableNativeDeviceKind;
+    label: string;
+    vendorId?: number;
+    productId?: number;
+}
+export interface MoldableNativeDeviceHandle {
+    handle: string;
+    kind: MoldableNativeDeviceKind;
+}
+export interface MoldableNativeDeviceFilter {
+    vendorId?: number;
+    productId?: number;
+}
+export interface MoldableNativeDeviceListOptions extends NativeHardwareBridgeOptions {
+    filters?: readonly MoldableNativeDeviceFilter[];
+    exclusionFilters?: readonly MoldableNativeDeviceFilter[];
+}
+export declare function listMoldableNativeDevices(kind: MoldableNativeDeviceKind, options?: MoldableNativeDeviceListOptions): Promise<MoldableNativeDeviceDescriptor[]>;
+export declare function openMoldableNativeDevice(kind: MoldableNativeDeviceKind, selector: string, deviceOptions: Record<string, unknown>, options?: NativeHardwareBridgeOptions): Promise<MoldableNativeDeviceHandle>;
+export declare function executeMoldableNativeDeviceOperation(kind: MoldableNativeDeviceKind, handle: string, operation: Record<string, unknown>, options?: NativeHardwareBridgeOptions): Promise<Record<string, unknown>>;
+export declare function closeMoldableNativeDevice(kind: MoldableNativeDeviceKind, handle: string, options?: NativeHardwareBridgeOptions): Promise<void>;
+export declare function bytesFromNativeDeviceResult(result: Record<string, unknown>): Uint8Array;
+export declare function bytesWrittenFromNativeDeviceResult(result: Record<string, unknown>): number;
+//# sourceMappingURL=native-device-io.d.ts.map

package/dist/lib/native-hardware/native-device-io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-device-io.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/native-device-io.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,2BAA2B,EAEjC,MAAM,UAAU,CAAA;AAOjB,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,CAAA;AAE/D,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,wBAAwB,CAAA;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,wBAAwB,CAAA;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,+BACf,SAAQ,2BAA2B;IACnC,OAAO,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAA;IAC/C,gBAAgB,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAA;CACzD;AAkCD,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,wBAAwB,EAC9B,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAsB3C;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,wBAAwB,EAC9B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,0BAA0B,CAAC,CAwBrC;AAED,wBAAsB,oCAAoC,CACxD,IAAI,EAAE,wBAAwB,EAC9B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAalC;AAED,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,wBAAwB,EAC9B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,IAAI,CAAC,CAMf;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,UAAU,CAYZ;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAUR"}

package/dist/lib/native-hardware/native-device-io.js

@@ -0,0 +1,91 @@
+import { NativeHardwareBridgeError, callNativeHardwareBridge, } from './bridge';
+const REQUEST_TYPE = 'moldable:native-device-io-request';
+const RESULT_TYPE = 'moldable:native-device-io-result';
+const OPAQUE_ID_PATTERN = /^(selector|device)-[a-f0-9]{36}$/;
+const MAX_TRANSFER_BYTES = 65_536;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function invalidResponse(message, details) {
+    throw new NativeHardwareBridgeError({
+        code: 'invalid_response',
+        message,
+        details,
+        retryable: false,
+    });
+}
+function isDescriptor(value) {
+    return (isRecord(value) &&
+        typeof value.selector === 'string' &&
+        OPAQUE_ID_PATTERN.test(value.selector) &&
+        (value.kind === 'usb' || value.kind === 'hid' || value.kind === 'serial') &&
+        typeof value.label === 'string' &&
+        value.label.length <= 120 &&
+        (value.vendorId === undefined ||
+            (Number.isInteger(value.vendorId) &&
+                Number(value.vendorId) >= 0 &&
+                Number(value.vendorId) <= 0xffff)) &&
+        (value.productId === undefined ||
+            (Number.isInteger(value.productId) &&
+                Number(value.productId) >= 0 &&
+                Number(value.productId) <= 0xffff)));
+}
+export async function listMoldableNativeDevices(kind, options = {}) {
+    const { filters, exclusionFilters, ...bridgeOptions } = options;
+    const result = await callNativeHardwareBridge({
+        type: REQUEST_TYPE,
+        action: 'list',
+        kind,
+        ...(filters ? { filters: [...filters] } : {}),
+        ...(exclusionFilters ? { exclusionFilters: [...exclusionFilters] } : {}),
+    }, RESULT_TYPE, { timeoutMs: 120_000, ...bridgeOptions });
+    if (!Array.isArray(result) ||
+        !result.every((descriptor) => isDescriptor(descriptor) && descriptor.kind === kind)) {
+        invalidResponse('Moldable returned an invalid native device list.', result);
+    }
+    return result;
+}
+export async function openMoldableNativeDevice(kind, selector, deviceOptions, options = {}) {
+    const result = await callNativeHardwareBridge({
+        type: REQUEST_TYPE,
+        action: 'open',
+        kind,
+        selector,
+        options: deviceOptions,
+    }, RESULT_TYPE, { timeoutMs: 120_000, ...options });
+    if (!isRecord(result) ||
+        typeof result.handle !== 'string' ||
+        !OPAQUE_ID_PATTERN.test(result.handle) ||
+        (result.kind !== 'usb' && result.kind !== 'hid' && result.kind !== 'serial')) {
+        invalidResponse('Moldable returned an invalid native device handle.', result);
+    }
+    return result;
+}
+export async function executeMoldableNativeDeviceOperation(kind, handle, operation, options = {}) {
+    const result = await callNativeHardwareBridge({ type: REQUEST_TYPE, action: 'execute', kind, handle, operation }, RESULT_TYPE, { timeoutMs: 35_000, ...options });
+    if (!isRecord(result)) {
+        invalidResponse('Moldable returned an invalid native device result.', result);
+    }
+    return result;
+}
+export async function closeMoldableNativeDevice(kind, handle, options = {}) {
+    await callNativeHardwareBridge({ type: REQUEST_TYPE, action: 'close', kind, handle }, RESULT_TYPE, options);
+}
+export function bytesFromNativeDeviceResult(result) {
+    if (result.kind !== 'data' ||
+        !Array.isArray(result.data) ||
+        result.data.length > MAX_TRANSFER_BYTES ||
+        !result.data.every((value) => Number.isInteger(value) && value >= 0 && value <= 255)) {
+        invalidResponse('Moldable returned invalid device bytes.', result);
+    }
+    return Uint8Array.from(result.data);
+}
+export function bytesWrittenFromNativeDeviceResult(result) {
+    if (result.kind !== 'written' ||
+        !Number.isInteger(result.bytesWritten) ||
+        Number(result.bytesWritten) < 0 ||
+        Number(result.bytesWritten) > MAX_TRANSFER_BYTES) {
+        invalidResponse('Moldable returned an invalid device write result.', result);
+    }
+    return Number(result.bytesWritten);
+}

package/dist/lib/native-hardware/native-device-lifecycle.d.ts

@@ -0,0 +1,13 @@
+export declare class NativeDeviceLifecycle {
+    private open;
+    private attached;
+    private disconnectDispatched;
+    get opened(): boolean;
+    get connected(): boolean;
+    get disconnected(): boolean;
+    didOpen(): void;
+    didClose(): void;
+    didDisconnect(target: EventTarget, error: unknown): void;
+}
+export declare function isNativeDeviceDisconnect(error: unknown): boolean;
+//# sourceMappingURL=native-device-lifecycle.d.ts.map

package/dist/lib/native-hardware/native-device-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-device-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/native-device-lifecycle.ts"],"names":[],"mappings":"AAEA,qBAAa,qBAAqB;IAChC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,QAAQ,CAAO;IACvB,OAAO,CAAC,oBAAoB,CAAQ;IAEpC,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,OAAO,IAAI,IAAI;IAMf,QAAQ,IAAI,IAAI;IAIhB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;CASzD;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMhE"}

package/dist/lib/native-hardware/native-device-lifecycle.js

@@ -0,0 +1,40 @@
+import { NativeHardwareBridgeError } from './bridge';
+export class NativeDeviceLifecycle {
+    open = false;
+    attached = true;
+    disconnectDispatched = false;
+    get opened() {
+        return this.open;
+    }
+    get connected() {
+        return this.attached;
+    }
+    get disconnected() {
+        return !this.attached;
+    }
+    didOpen() {
+        this.open = true;
+        this.attached = true;
+        this.disconnectDispatched = false;
+    }
+    didClose() {
+        this.open = false;
+    }
+    didDisconnect(target, error) {
+        this.open = false;
+        this.attached = false;
+        if (this.disconnectDispatched)
+            return;
+        this.disconnectDispatched = true;
+        const event = new Event('disconnect');
+        Object.defineProperty(event, 'error', { value: error });
+        target.dispatchEvent(event);
+    }
+}
+export function isNativeDeviceDisconnect(error) {
+    if (!(error instanceof NativeHardwareBridgeError))
+        return false;
+    if (error.code !== 'unavailable')
+        return false;
+    return /\b(disconnected|no longer available|not connected)\b/i.test(error.message);
+}

package/dist/lib/native-hardware/notifications.d.ts

@@ -0,0 +1,38 @@
+import { type NativeHardwareBridgeOptions } from './bridge';
+import type { NativeHardwareRequestEnvelope, NativeHardwareResultEnvelope } from './types';
+export declare const NATIVE_NOTIFICATION_REQUEST_TYPE: "moldable:native-notifications";
+export declare const NATIVE_NOTIFICATION_RESULT_TYPE: "moldable:native-notifications-result";
+export declare const NATIVE_NOTIFICATION_MAX_TITLE_LENGTH = 256;
+export declare const NATIVE_NOTIFICATION_MAX_BODY_LENGTH = 4096;
+export declare const NATIVE_NOTIFICATION_MAX_TAG_LENGTH = 128;
+export type MoldableNotificationPermission = 'granted' | 'denied' | 'prompt';
+export interface MoldableNotificationOptions {
+    title: string;
+    body?: string;
+    tag?: string;
+    silent?: boolean;
+}
+export interface MoldableNotificationPermissionResult {
+    permission: MoldableNotificationPermission;
+}
+export interface MoldableNotificationSendResult {
+    sent: true;
+}
+export type NativeNotificationAction = 'getPermission' | 'requestPermission' | 'send';
+export type NativeNotificationRequest = NativeHardwareRequestEnvelope<typeof NATIVE_NOTIFICATION_REQUEST_TYPE, {
+    capability: 'notifications';
+    action: 'getPermission';
+} | {
+    capability: 'notifications';
+    action: 'requestPermission';
+} | {
+    capability: 'notifications';
+    action: 'send';
+    notification: MoldableNotificationOptions;
+}>;
+export type NativeNotificationResult = NativeHardwareResultEnvelope<typeof NATIVE_NOTIFICATION_RESULT_TYPE, MoldableNotificationPermissionResult | MoldableNotificationSendResult>;
+export declare function isMoldableNotificationOptions(value: unknown): value is MoldableNotificationOptions;
+export declare function getMoldableNotificationPermission(options?: NativeHardwareBridgeOptions): Promise<MoldableNotificationPermissionResult>;
+export declare function requestMoldableNotificationPermission(options?: NativeHardwareBridgeOptions): Promise<MoldableNotificationPermissionResult>;
+export declare function sendMoldableNotification(notification: MoldableNotificationOptions, options?: NativeHardwareBridgeOptions): Promise<MoldableNotificationSendResult>;
+//# sourceMappingURL=notifications.d.ts.map

package/dist/lib/native-hardware/notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EACV,6BAA6B,EAC7B,4BAA4B,EAC7B,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,gCAAgC,EAC3C,+BAAwC,CAAA;AAC1C,eAAO,MAAM,+BAA+B,EAC1C,sCAA+C,CAAA;AAEjD,eAAO,MAAM,oCAAoC,MAAM,CAAA;AACvD,eAAO,MAAM,mCAAmC,OAAQ,CAAA;AACxD,eAAO,MAAM,kCAAkC,MAAM,CAAA;AAErD,MAAM,MAAM,8BAA8B,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAE5E,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,oCAAoC;IACnD,UAAU,EAAE,8BAA8B,CAAA;CAC3C;AAED,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,IAAI,CAAA;CACX;AAED,MAAM,MAAM,wBAAwB,GAChC,eAAe,GACf,mBAAmB,GACnB,MAAM,CAAA;AAEV,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,CACnE,OAAO,gCAAgC,EACrC;IACE,UAAU,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,eAAe,CAAA;CACxB,GACD;IACE,UAAU,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,mBAAmB,CAAA;CAC5B,GACD;IACE,UAAU,EAAE,eAAe,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,2BAA2B,CAAA;CAC1C,CACJ,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,4BAA4B,CACjE,OAAO,+BAA+B,EACtC,oCAAoC,GAAG,8BAA8B,CACtE,CAAA;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,2BAA2B,CA+BtC;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,oCAAoC,CAAC,CAU/C;AAED,wBAAgB,qCAAqC,CACnD,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,oCAAoC,CAAC,CAU/C;AAED,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,2BAA2B,EACzC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,8BAA8B,CAAC,CAWzC"}

package/dist/lib/native-hardware/notifications.js

@@ -0,0 +1,50 @@
+import { callNativeHardwareBridge, } from './bridge';
+export const NATIVE_NOTIFICATION_REQUEST_TYPE = 'moldable:native-notifications';
+export const NATIVE_NOTIFICATION_RESULT_TYPE = 'moldable:native-notifications-result';
+export const NATIVE_NOTIFICATION_MAX_TITLE_LENGTH = 256;
+export const NATIVE_NOTIFICATION_MAX_BODY_LENGTH = 4_096;
+export const NATIVE_NOTIFICATION_MAX_TAG_LENGTH = 128;
+export function isMoldableNotificationOptions(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const notification = value;
+    const { title, body, tag, silent } = notification;
+    if (typeof title !== 'string' ||
+        title.trim().length === 0 ||
+        title.length > NATIVE_NOTIFICATION_MAX_TITLE_LENGTH) {
+        return false;
+    }
+    if ((body !== undefined && typeof body !== 'string') ||
+        (typeof body === 'string' &&
+            body.length > NATIVE_NOTIFICATION_MAX_BODY_LENGTH)) {
+        return false;
+    }
+    if ((tag !== undefined &&
+        (typeof tag !== 'string' || tag.trim().length === 0)) ||
+        (typeof tag === 'string' && tag.length > NATIVE_NOTIFICATION_MAX_TAG_LENGTH)) {
+        return false;
+    }
+    return silent === undefined || typeof silent === 'boolean';
+}
+export function getMoldableNotificationPermission(options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_NOTIFICATION_REQUEST_TYPE,
+        capability: 'notifications',
+        action: 'getPermission',
+    }, NATIVE_NOTIFICATION_RESULT_TYPE, options);
+}
+export function requestMoldableNotificationPermission(options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_NOTIFICATION_REQUEST_TYPE,
+        capability: 'notifications',
+        action: 'requestPermission',
+    }, NATIVE_NOTIFICATION_RESULT_TYPE, options);
+}
+export function sendMoldableNotification(notification, options = {}) {
+    return callNativeHardwareBridge({
+        type: NATIVE_NOTIFICATION_REQUEST_TYPE,
+        capability: 'notifications',
+        action: 'send',
+        notification,
+    }, NATIVE_NOTIFICATION_RESULT_TYPE, options);
+}

package/dist/lib/native-hardware/power-session.d.ts

@@ -0,0 +1,113 @@
+import { type NativeHardwareBridgeOptions } from './bridge';
+import type { NativeHardwareRequestEnvelope, NativeHardwareResultEnvelope } from './types';
+export declare const NATIVE_POWER_SESSION_REQUEST_TYPE: "moldable:native-power-session";
+export declare const NATIVE_POWER_SESSION_RESULT_TYPE: "moldable:native-power-session-result";
+export declare const NATIVE_POWER_SESSION_EVENT_TYPE: "moldable:native-power-session-event";
+export type MoldablePowerSource = 'ac' | 'battery' | 'unknown';
+export type MoldableBatteryState = 'charging' | 'discharging' | 'empty' | 'full' | 'unknown';
+export interface MoldableBatteryStatus {
+    state: MoldableBatteryState;
+    chargePercent: number;
+    timeToEmptySeconds: number | null;
+    timeToFullSeconds: number | null;
+}
+export interface MoldablePowerState {
+    source: MoldablePowerSource;
+    batteries: MoldableBatteryStatus[];
+}
+export type MoldableSystemIdleState = 'active' | 'idle' | 'locked';
+export type MoldableThermalState = 'nominal' | 'fair' | 'serious' | 'critical' | 'unknown';
+export interface MoldableSystemIdleResult {
+    seconds: number;
+    state: MoldableSystemIdleState;
+    thresholdSeconds: number;
+}
+export type MoldableSleepBlockerType = 'prevent-app-suspension' | 'prevent-display-sleep';
+export type MoldablePowerSessionEvent = {
+    kind: 'suspend';
+    occurredAt: string;
+} | {
+    kind: 'resume';
+    occurredAt: string;
+} | {
+    kind: 'lock';
+    occurredAt: string;
+} | {
+    kind: 'unlock';
+    occurredAt: string;
+} | {
+    kind: 'session-active';
+    occurredAt: string;
+} | {
+    kind: 'session-inactive';
+    occurredAt: string;
+} | {
+    kind: 'shutdown';
+    occurredAt: string;
+} | {
+    kind: 'thermal-state-change';
+    occurredAt: string;
+    state: MoldableThermalState;
+} | {
+    kind: 'power-source-change';
+    occurredAt: string;
+    powerState: MoldablePowerState;
+};
+export type NativePowerSessionRequest = NativeHardwareRequestEnvelope<typeof NATIVE_POWER_SESSION_REQUEST_TYPE, {
+    action: 'getPowerState';
+} | {
+    action: 'getCurrentThermalState';
+} | {
+    action: 'getIdleState';
+    thresholdSeconds: number;
+} | {
+    action: 'startSleepBlocker';
+    blockerType: MoldableSleepBlockerType;
+} | {
+    action: 'stopSleepBlocker';
+    blockerId: string;
+} | {
+    action: 'isSleepBlockerStarted';
+    blockerId: string;
+} | {
+    action: 'subscribeEvents';
+} | {
+    action: 'unsubscribeEvents';
+    subscriptionId: string;
+}>;
+export type NativePowerSessionResult = NativeHardwareResultEnvelope<typeof NATIVE_POWER_SESSION_RESULT_TYPE, MoldablePowerState | MoldableThermalState | MoldableSystemIdleResult | {
+    blockerId: string;
+    blockerType: MoldableSleepBlockerType;
+} | {
+    stopped: true;
+} | {
+    started: boolean;
+} | {
+    subscriptionId: string;
+} | {
+    unsubscribed: true;
+}>;
+export interface WatchMoldablePowerSessionOptions {
+    signal?: AbortSignal;
+}
+export type StopWatchingMoldablePowerSession = () => Promise<void>;
+export declare function isMoldablePowerSessionEvent(value: unknown): value is MoldablePowerSessionEvent;
+export declare function getMoldablePowerState(options?: NativeHardwareBridgeOptions): Promise<MoldablePowerState>;
+/** Return the host's current thermal pressure classification. */
+export declare function getMoldableCurrentThermalState(options?: NativeHardwareBridgeOptions): Promise<MoldableThermalState>;
+export declare function getMoldableSystemIdleState(thresholdSeconds: number, options?: NativeHardwareBridgeOptions): Promise<MoldableSystemIdleResult>;
+export declare function getMoldableSystemIdleTime(options?: NativeHardwareBridgeOptions): Promise<number>;
+export interface MoldableSleepBlocker {
+    readonly id: string;
+    readonly type: MoldableSleepBlockerType;
+    readonly stopped: boolean;
+    isStarted(options?: NativeHardwareBridgeOptions): Promise<boolean>;
+    stop(options?: NativeHardwareBridgeOptions): Promise<void>;
+}
+export declare function startMoldableSleepBlocker(blockerType: MoldableSleepBlockerType, options?: NativeHardwareBridgeOptions): Promise<MoldableSleepBlocker>;
+/** Stop a blocker returned by {@link startMoldableSleepBlocker}. */
+export declare function stopMoldableSleepBlocker(blocker: MoldableSleepBlocker, options?: NativeHardwareBridgeOptions): Promise<void>;
+/** Ask the host whether a blocker still belongs to this active app scope. */
+export declare function isMoldableSleepBlockerStarted(blocker: MoldableSleepBlocker, options?: NativeHardwareBridgeOptions): Promise<boolean>;
+export declare function watchMoldablePowerSession(listener: (event: MoldablePowerSessionEvent) => void, options?: WatchMoldablePowerSessionOptions & NativeHardwareBridgeOptions): Promise<StopWatchingMoldablePowerSession>;
+//# sourceMappingURL=power-session.d.ts.map

package/dist/lib/native-hardware/power-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"power-session.d.ts","sourceRoot":"","sources":["../../../src/lib/native-hardware/power-session.ts"],"names":[],"mappings":"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"}

package/dist/lib/native-hardware/power-session.js

@@ -0,0 +1,264 @@
+import { NativeHardwareBridgeError, callNativeHardwareBridge, resolveNativeHardwareParentOrigin, } from './bridge';
+export const NATIVE_POWER_SESSION_REQUEST_TYPE = 'moldable:native-power-session';
+export const NATIVE_POWER_SESSION_RESULT_TYPE = 'moldable:native-power-session-result';
+export const NATIVE_POWER_SESSION_EVENT_TYPE = 'moldable:native-power-session-event';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPowerState(value) {
+    if (!isRecord(value))
+        return false;
+    if (!['ac', 'battery', 'unknown'].includes(String(value.source)))
+        return false;
+    if (!Array.isArray(value.batteries))
+        return false;
+    return value.batteries.every((battery) => isRecord(battery) &&
+        ['charging', 'discharging', 'empty', 'full', 'unknown'].includes(String(battery.state)) &&
+        typeof battery.chargePercent === 'number' &&
+        Number.isFinite(battery.chargePercent) &&
+        battery.chargePercent >= 0 &&
+        battery.chargePercent <= 100 &&
+        (battery.timeToEmptySeconds === null ||
+            (typeof battery.timeToEmptySeconds === 'number' &&
+                Number.isFinite(battery.timeToEmptySeconds) &&
+                battery.timeToEmptySeconds >= 0)) &&
+        (battery.timeToFullSeconds === null ||
+            (typeof battery.timeToFullSeconds === 'number' &&
+                Number.isFinite(battery.timeToFullSeconds) &&
+                battery.timeToFullSeconds >= 0)));
+}
+function isThermalState(value) {
+    return ['nominal', 'fair', 'serious', 'critical', 'unknown'].includes(String(value));
+}
+export function isMoldablePowerSessionEvent(value) {
+    if (!isRecord(value) || typeof value.occurredAt !== 'string')
+        return false;
+    if (Number.isNaN(Date.parse(value.occurredAt)))
+        return false;
+    if (value.kind === 'suspend' ||
+        value.kind === 'resume' ||
+        value.kind === 'lock' ||
+        value.kind === 'unlock' ||
+        value.kind === 'session-active' ||
+        value.kind === 'session-inactive' ||
+        value.kind === 'shutdown') {
+        return true;
+    }
+    if (value.kind === 'thermal-state-change') {
+        return isThermalState(value.state);
+    }
+    return value.kind === 'power-source-change' && isPowerState(value.powerState);
+}
+export async function getMoldablePowerState(options = {}) {
+    const value = await callNativeHardwareBridge({ type: NATIVE_POWER_SESSION_REQUEST_TYPE, action: 'getPowerState' }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+    if (!isPowerState(value)) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid power state.',
+            details: value,
+            retryable: false,
+        });
+    }
+    return value;
+}
+/** Return the host's current thermal pressure classification. */
+export async function getMoldableCurrentThermalState(options = {}) {
+    const value = await callNativeHardwareBridge({
+        type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+        action: 'getCurrentThermalState',
+    }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+    if (!isThermalState(value)) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid thermal state.',
+            details: value,
+            retryable: false,
+        });
+    }
+    return value;
+}
+export async function getMoldableSystemIdleState(thresholdSeconds, options = {}) {
+    if (!Number.isSafeInteger(thresholdSeconds) ||
+        thresholdSeconds < 1 ||
+        thresholdSeconds > 86_400) {
+        throw new RangeError('thresholdSeconds must be an integer from 1 to 86400.');
+    }
+    const value = await callNativeHardwareBridge({
+        type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+        action: 'getIdleState',
+        thresholdSeconds,
+    }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+    if (!isRecord(value) ||
+        typeof value.seconds !== 'number' ||
+        !Number.isFinite(value.seconds) ||
+        value.seconds < 0 ||
+        !['active', 'idle', 'locked'].includes(String(value.state)) ||
+        value.thresholdSeconds !== thresholdSeconds) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid system idle state.',
+            details: value,
+            retryable: false,
+        });
+    }
+    return value;
+}
+export async function getMoldableSystemIdleTime(options = {}) {
+    const result = await getMoldableSystemIdleState(86_400, options);
+    return result.seconds;
+}
+class MoldableSleepBlockerHandle {
+    id;
+    type;
+    #stopPromise = null;
+    #stopped = false;
+    constructor(id, type) {
+        this.id = id;
+        this.type = type;
+    }
+    get stopped() {
+        return this.#stopped;
+    }
+    async isStarted(options = {}) {
+        if (this.#stopped)
+            return false;
+        const result = await callNativeHardwareBridge({
+            type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+            action: 'isSleepBlockerStarted',
+            blockerId: this.id,
+        }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+        if (typeof result.started !== 'boolean') {
+            throw new NativeHardwareBridgeError({
+                code: 'invalid_response',
+                message: 'Moldable returned an invalid sleep blocker state.',
+                details: result,
+                retryable: false,
+            });
+        }
+        if (!result.started)
+            this.#stopped = true;
+        return result.started;
+    }
+    stop(options = {}) {
+        if (this.#stopped)
+            return Promise.resolve();
+        if (this.#stopPromise)
+            return this.#stopPromise;
+        this.#stopPromise = callNativeHardwareBridge({
+            type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+            action: 'stopSleepBlocker',
+            blockerId: this.id,
+        }, NATIVE_POWER_SESSION_RESULT_TYPE, options)
+            .then(() => {
+            this.#stopped = true;
+        })
+            .catch((error) => {
+            this.#stopPromise = null;
+            throw error;
+        });
+        return this.#stopPromise;
+    }
+}
+export async function startMoldableSleepBlocker(blockerType, options = {}) {
+    const result = await callNativeHardwareBridge({
+        type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+        action: 'startSleepBlocker',
+        blockerType,
+    }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+    if (typeof result.blockerId !== 'string' ||
+        result.blockerId.length === 0 ||
+        result.blockerType !== blockerType) {
+        throw new NativeHardwareBridgeError({
+            code: 'invalid_response',
+            message: 'Moldable returned an invalid sleep blocker handle.',
+            details: result,
+            retryable: false,
+        });
+    }
+    return new MoldableSleepBlockerHandle(result.blockerId, blockerType);
+}
+/** Stop a blocker returned by {@link startMoldableSleepBlocker}. */
+export function stopMoldableSleepBlocker(blocker, options = {}) {
+    return blocker.stop(options);
+}
+/** Ask the host whether a blocker still belongs to this active app scope. */
+export function isMoldableSleepBlockerStarted(blocker, options = {}) {
+    return blocker.isStarted(options);
+}
+export async function watchMoldablePowerSession(listener, options = {}) {
+    if (typeof window === 'undefined' || window.parent === window) {
+        throw new NativeHardwareBridgeError({
+            code: 'not_in_moldable',
+            message: 'Power/session events are only available inside Moldable.',
+            retryable: false,
+        });
+    }
+    const parentOrigin = resolveNativeHardwareParentOrigin(document.referrer);
+    if (!parentOrigin) {
+        throw new NativeHardwareBridgeError({
+            code: 'not_in_moldable',
+            message: 'The power/session event parent could not be verified.',
+            retryable: false,
+        });
+    }
+    let active = true;
+    const handleMessage = (event) => {
+        if (!active ||
+            event.source !== window.parent ||
+            event.origin !== parentOrigin ||
+            !isRecord(event.data)) {
+            return;
+        }
+        if (event.data.type !== NATIVE_POWER_SESSION_EVENT_TYPE)
+            return;
+        if (!isMoldablePowerSessionEvent(event.data.event))
+            return;
+        listener(event.data.event);
+    };
+    let stopPromise = null;
+    let subscriptionId = '';
+    const stop = () => {
+        if (stopPromise)
+            return stopPromise;
+        active = false;
+        window.removeEventListener('message', handleMessage);
+        options.signal?.removeEventListener('abort', handleAbort);
+        stopPromise = callNativeHardwareBridge({
+            type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+            action: 'unsubscribeEvents',
+            subscriptionId,
+        }, NATIVE_POWER_SESSION_RESULT_TYPE, { timeoutMs: options.timeoutMs })
+            .then(() => undefined)
+            .catch((error) => {
+            stopPromise = null;
+            throw error;
+        });
+        return stopPromise;
+    };
+    const handleAbort = () => void stop().catch(() => undefined);
+    window.addEventListener('message', handleMessage);
+    try {
+        const result = await callNativeHardwareBridge({
+            type: NATIVE_POWER_SESSION_REQUEST_TYPE,
+            action: 'subscribeEvents',
+        }, NATIVE_POWER_SESSION_RESULT_TYPE, options);
+        if (typeof result.subscriptionId !== 'string' || !result.subscriptionId) {
+            throw new NativeHardwareBridgeError({
+                code: 'invalid_response',
+                message: 'Moldable returned an invalid power event subscription.',
+                details: result,
+                retryable: false,
+            });
+        }
+        subscriptionId = result.subscriptionId;
+    }
+    catch (error) {
+        active = false;
+        window.removeEventListener('message', handleMessage);
+        throw error;
+    }
+    options.signal?.addEventListener('abort', handleAbort, { once: true });
+    if (options.signal?.aborted)
+        handleAbort();
+    return stop;
+}