@limrun/ui 0.9.0-rc.5 → 0.9.0-rc.7

package/src/core/device-install/operations/usbmux.ts

@@ -0,0 +1,270 @@
+/// <reference path="./webusb-dom.d.ts" />
+
+import type { UsbmuxCandidate } from './webusb';
+import { getBulkEndpoints, transferIn, transferOutWithZlp } from './webusb';
+
+const PROTO_VERSION = 0;
+const PROTO_SETUP = 2;
+const PROTO_TCP = 6;
+const MAGIC = 0xfeedface;
+const FLAG_SYN = 0x02;
+const FLAG_RST = 0x04;
+const FLAG_ACK = 0x10;
+const FIRST_SPORT = 49152;
+
+export type UsbmuxSession = {
+  device: USBDevice;
+  candidate: UsbmuxCandidate;
+  inEndpoint: ReturnType<typeof getBulkEndpoints>['inEndpoint'];
+  outEndpoint: ReturnType<typeof getBulkEndpoints>['outEndpoint'];
+  muxVersion: number;
+  txSeq: number;
+  rxSeq: number;
+  nextSport: number;
+  streams: Map<string, UsbmuxStream>;
+  writeChain: Promise<void>;
+  closed: boolean;
+};
+
+export type UsbmuxStream = {
+  session: UsbmuxSession;
+  sport: number;
+  dport: number;
+  seq: number;
+  ack: number;
+  queue: Uint8Array[];
+  waiters: Array<(value: Uint8Array) => void>;
+  error?: Error;
+  opened: Promise<void>;
+  resolveOpened: () => void;
+  rejectOpened: (error: Error) => void;
+};
+
+export async function createUsbmuxSession(device: USBDevice, candidate: UsbmuxCandidate) {
+  const { inEndpoint, outEndpoint } = getBulkEndpoints(candidate);
+  const versionPayload = new Uint8Array(12);
+  const versionView = new DataView(versionPayload.buffer);
+  versionView.setUint32(0, 2);
+  versionView.setUint32(4, 0);
+  versionView.setUint32(8, 0);
+  await transferOutWithZlp(device, outEndpoint, buildV1Packet(PROTO_VERSION, versionPayload));
+  const versionPacket = await readPacket(device, inEndpoint, 1);
+  const version = new DataView(versionPacket.payload.buffer, versionPacket.payload.byteOffset).getUint32(0);
+  const session: UsbmuxSession = {
+    device,
+    candidate,
+    inEndpoint,
+    outEndpoint,
+    muxVersion: version,
+    txSeq: 0,
+    rxSeq: 0xffff,
+    nextSport: FIRST_SPORT,
+    streams: new Map(),
+    writeChain: Promise.resolve(),
+    closed: false,
+  };
+  if (version >= 2) {
+    await sendMux(session, PROTO_SETUP, new Uint8Array([0x07]));
+  }
+  void readLoop(session);
+  return session;
+}
+
+export async function openStream(session: UsbmuxSession, port: number) {
+  if (session.closed) {
+    throw new Error('usbmux session is closed.');
+  }
+  let resolveOpened!: () => void;
+  let rejectOpened!: (error: Error) => void;
+  const stream: UsbmuxStream = {
+    session,
+    sport: session.nextSport++,
+    dport: port,
+    seq: 0,
+    ack: 0,
+    queue: [],
+    waiters: [],
+    opened: new Promise<void>((resolve, reject) => {
+      resolveOpened = resolve;
+      rejectOpened = reject;
+    }),
+    resolveOpened,
+    rejectOpened,
+  };
+  session.streams.set(streamKey(port, stream.sport), stream);
+  await sendTcp(stream, FLAG_SYN, new Uint8Array());
+  await stream.opened;
+  return stream;
+}
+
+export async function sendStreamData(stream: UsbmuxStream, bytes: Uint8Array) {
+  if (stream.session.closed) {
+    throw new Error('usbmux session is closed.');
+  }
+  await sendTcp(stream, FLAG_ACK, bytes);
+  stream.seq += bytes.byteLength;
+}
+
+export async function receiveStreamData(stream: UsbmuxStream) {
+  if (stream.queue.length > 0) {
+    return stream.queue.shift()!;
+  }
+  if (stream.error) {
+    throw stream.error;
+  }
+  return new Promise<Uint8Array>((resolve) => {
+    stream.waiters.push(resolve);
+  });
+}
+
+export function closeUsbmuxSession(session: UsbmuxSession) {
+  session.closed = true;
+  for (const stream of session.streams.values()) {
+    stream.error = new Error('usbmux session closed');
+    stream.rejectOpened(stream.error);
+    while (stream.waiters.length > 0) {
+      stream.waiters.shift()!(new Uint8Array());
+    }
+  }
+  session.streams.clear();
+}
+
+async function sendTcp(stream: UsbmuxStream, flags: number, payload: Uint8Array) {
+  const tcp = new Uint8Array(20 + payload.byteLength);
+  const view = new DataView(tcp.buffer);
+  view.setUint16(0, stream.sport);
+  view.setUint16(2, stream.dport);
+  view.setUint32(4, stream.seq);
+  view.setUint32(8, stream.ack);
+  view.setUint8(12, 0x50);
+  view.setUint8(13, flags);
+  view.setUint16(14, 512);
+  tcp.set(payload, 20);
+  await sendMux(stream.session, PROTO_TCP, tcp);
+}
+
+async function sendMux(session: UsbmuxSession, protocol: number, payload: Uint8Array) {
+  if (session.closed) {
+    throw new Error('usbmux session is closed.');
+  }
+  session.writeChain = session.writeChain.then(async () => {
+    if (session.closed) return;
+    const packet =
+      session.muxVersion >= 2
+        ? buildV2Packet(protocol, payload, session.txSeq++, session.rxSeq)
+        : buildV1Packet(protocol, payload);
+    await transferOutWithZlp(session.device, session.outEndpoint, packet);
+  });
+  return session.writeChain;
+}
+
+async function readLoop(session: UsbmuxSession) {
+  try {
+    for (;;) {
+      if (session.closed) return;
+      const packet = await readPacket(session.device, session.inEndpoint, session.muxVersion);
+      if (session.closed) return;
+      if (packet.rxSeq !== undefined) {
+        session.rxSeq = packet.rxSeq;
+      }
+      if (packet.protocol !== PROTO_TCP) {
+        continue;
+      }
+      const tcp = parseTcp(packet.payload);
+      const stream = session.streams.get(streamKey(tcp.sport, tcp.dport));
+      if (!stream) {
+        continue;
+      }
+      if (tcp.flags & FLAG_RST) {
+        stream.error = new Error(`Device reset stream ${stream.dport}`);
+        stream.rejectOpened(stream.error);
+        while (stream.waiters.length > 0) {
+          stream.waiters.shift()!(new Uint8Array());
+        }
+        session.streams.delete(streamKey(stream.dport, stream.sport));
+        continue;
+      }
+      if ((tcp.flags & (FLAG_SYN | FLAG_ACK)) === (FLAG_SYN | FLAG_ACK)) {
+        stream.seq += 1;
+        stream.ack = tcp.seq + 1;
+        await sendTcp(stream, FLAG_ACK, new Uint8Array());
+        stream.resolveOpened();
+        continue;
+      }
+      if (tcp.payload.byteLength === 0) {
+        continue;
+      }
+      stream.ack = tcp.seq + tcp.payload.byteLength;
+      await sendTcp(stream, FLAG_ACK, new Uint8Array());
+      if (stream.waiters.length > 0) {
+        stream.waiters.shift()!(tcp.payload);
+      } else {
+        stream.queue.push(tcp.payload);
+      }
+    }
+  } catch (error) {
+    if (!session.closed) {
+      closeUsbmuxSession(session);
+    }
+  }
+}
+
+async function readPacket(device: USBDevice, endpoint: UsbmuxSession['inEndpoint'], version: number) {
+  for (;;) {
+    const bytes = await transferIn(device, endpoint);
+    const packet = parseMux(bytes, version);
+    if (version === 1 && packet.protocol !== PROTO_VERSION) continue;
+    return packet;
+  }
+}
+
+function buildV1Packet(protocol: number, payload: Uint8Array) {
+  const bytes = new Uint8Array(8 + payload.byteLength);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, protocol);
+  view.setUint32(4, bytes.byteLength);
+  bytes.set(payload, 8);
+  return bytes;
+}
+
+function buildV2Packet(protocol: number, payload: Uint8Array, txSeq: number, rxSeq: number) {
+  const bytes = new Uint8Array(16 + payload.byteLength);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, protocol);
+  view.setUint32(4, bytes.byteLength);
+  view.setUint32(8, MAGIC);
+  view.setUint16(12, txSeq);
+  view.setUint16(14, rxSeq);
+  bytes.set(payload, 16);
+  return bytes;
+}
+
+function parseMux(bytes: Uint8Array, version: number) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const protocol = view.getUint32(0);
+  const length = view.getUint32(4);
+  const headerSize = version >= 2 ? 16 : 8;
+  return {
+    protocol,
+    length,
+    rxSeq: version >= 2 ? view.getUint16(14) : undefined,
+    payload: bytes.slice(headerSize, length),
+  };
+}
+
+function parseTcp(bytes: Uint8Array) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const dataOffset = (view.getUint8(12) >> 4) * 4;
+  return {
+    sport: view.getUint16(0),
+    dport: view.getUint16(2),
+    seq: view.getUint32(4),
+    ack: view.getUint32(8),
+    flags: view.getUint8(13),
+    payload: bytes.slice(dataOffset),
+  };
+}
+
+function streamKey(devicePort: number, hostPort: number) {
+  return `${devicePort}:${hostPort}`;
+}

package/src/core/device-install/operations/webusb-dom.d.ts

@@ -0,0 +1,54 @@
+type USBTransferStatus = 'ok' | 'stall' | 'babble';
+
+interface USBInTransferResult {
+  data?: DataView;
+  status: USBTransferStatus;
+}
+
+interface USBOutTransferResult {
+  bytesWritten: number;
+  status: USBTransferStatus;
+}
+
+interface USBDevice {
+  vendorId: number;
+  productId: number;
+  productName?: string;
+  manufacturerName?: string;
+  serialNumber?: string;
+  opened: boolean;
+  configuration: { configurationValue: number } | null;
+  configurations: Array<{
+    configurationValue: number;
+    interfaces: Array<{
+      interfaceNumber: number;
+      alternates: Array<{
+        alternateSetting: number;
+        interfaceClass: number;
+        interfaceSubclass: number;
+        interfaceProtocol: number;
+        endpoints: Array<{
+          endpointNumber: number;
+          direction: 'in' | 'out';
+          type: string;
+          packetSize: number;
+        }>;
+      }>;
+    }>;
+  }>;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  selectConfiguration(configurationValue: number): Promise<void>;
+  claimInterface(interfaceNumber: number): Promise<void>;
+  releaseInterface(interfaceNumber: number): Promise<void>;
+  selectAlternateInterface(interfaceNumber: number, alternateSetting: number): Promise<void>;
+  transferIn(endpointNumber: number, length: number): Promise<USBInTransferResult>;
+  transferOut(endpointNumber: number, data: Uint8Array): Promise<USBOutTransferResult>;
+}
+
+interface Navigator {
+  usb?: {
+    requestDevice(options: { filters: Array<{ vendorId: number }> }): Promise<USBDevice>;
+    getDevices(): Promise<USBDevice[]>;
+  };
+}

package/src/core/device-install/operations/webusb.ts

@@ -0,0 +1,105 @@
+/// <reference path="./webusb-dom.d.ts" />
+
+export type UsbEndpoint = {
+  endpointNumber: number;
+  direction: 'in' | 'out';
+  type: string;
+  packetSize: number;
+};
+
+export type UsbmuxCandidate = {
+  configurationValue: number;
+  interfaceNumber: number;
+  alternateSetting: number;
+  endpoints: UsbEndpoint[];
+};
+
+export async function requestAppleDevice() {
+  if (!navigator.usb) {
+    throw new Error('WebUSB is not available in this browser.');
+  }
+  return navigator.usb.requestDevice({ filters: [{ vendorId: 0x05ac }] });
+}
+
+export function findUsbmuxCandidates(device: USBDevice): UsbmuxCandidate[] {
+  const candidates: UsbmuxCandidate[] = [];
+  const activeConfigurationValue = device.configuration?.configurationValue;
+  const activeConfiguration = device.configurations.find(
+    (configuration) => configuration.configurationValue === activeConfigurationValue,
+  );
+  if (activeConfiguration) {
+    candidates.push(...findConfigurationUsbmuxCandidates(activeConfiguration));
+  }
+  for (const configuration of device.configurations) {
+    if (configuration.configurationValue === activeConfigurationValue) {
+      continue;
+    }
+    candidates.push(...findConfigurationUsbmuxCandidates(configuration));
+  }
+  return candidates;
+}
+
+function findConfigurationUsbmuxCandidates(configuration: USBDevice['configurations'][number]): UsbmuxCandidate[] {
+  const candidates: UsbmuxCandidate[] = [];
+  for (const usbInterface of configuration.interfaces) {
+    for (const alternate of usbInterface.alternates) {
+      if (
+        alternate.interfaceClass === 0xff &&
+        alternate.interfaceSubclass === 0xfe &&
+        alternate.interfaceProtocol === 0x02
+      ) {
+        candidates.push({
+          configurationValue: configuration.configurationValue,
+          interfaceNumber: usbInterface.interfaceNumber,
+          alternateSetting: alternate.alternateSetting,
+          endpoints: alternate.endpoints,
+        });
+      }
+    }
+  }
+  return candidates;
+}
+
+export async function claimUsbmux(device: USBDevice, candidate: UsbmuxCandidate) {
+  if (!device.opened) {
+    await device.open();
+  }
+  if (!device.configuration || device.configuration.configurationValue !== candidate.configurationValue) {
+    await device.selectConfiguration(candidate.configurationValue);
+  }
+  await device.claimInterface(candidate.interfaceNumber);
+  if (candidate.alternateSetting !== 0) {
+    await device.selectAlternateInterface(candidate.interfaceNumber, candidate.alternateSetting);
+  }
+}
+
+export function getBulkEndpoints(candidate: UsbmuxCandidate) {
+  const outEndpoint = candidate.endpoints.find(
+    (endpoint) => endpoint.direction === 'out' && endpoint.type === 'bulk',
+  );
+  const inEndpoint = candidate.endpoints.find(
+    (endpoint) => endpoint.direction === 'in' && endpoint.type === 'bulk',
+  );
+  if (!outEndpoint || !inEndpoint) {
+    throw new Error('Could not find usbmux bulk endpoints.');
+  }
+  return { outEndpoint, inEndpoint };
+}
+
+export async function transferOutWithZlp(device: USBDevice, endpoint: UsbEndpoint, bytes: Uint8Array) {
+  const result = await device.transferOut(endpoint.endpointNumber, bytes);
+  if (result.status !== 'ok') {
+    throw new Error(`USB transferOut failed: ${result.status}`);
+  }
+  if (bytes.byteLength % endpoint.packetSize === 0) {
+    await device.transferOut(endpoint.endpointNumber, new Uint8Array());
+  }
+}
+
+export async function transferIn(device: USBDevice, endpoint: UsbEndpoint, size = 16384) {
+  const result = await device.transferIn(endpoint.endpointNumber, size);
+  if (result.status !== 'ok' || !result.data) {
+    throw new Error(`USB transferIn failed: ${result.status}`);
+  }
+  return new Uint8Array(result.data.buffer, result.data.byteOffset, result.data.byteLength);
+}

package/src/core/device-install/storage/browser-storage.ts

@@ -0,0 +1,263 @@
+import type {
+  ProvisioningProfileInfo,
+  PutSigningAssetsInput,
+  StoredPairRecord,
+  StoredSigningAssets,
+} from '../types';
+import type { PairRecordPayload } from '../types';
+
+const PAIRING_DB_NAME = 'limbuild-device-pairing';
+const PAIRING_DB_VERSION = 1;
+const PAIRING_STORE_NAME = 'pairRecords';
+const SIGNING_DB_NAME = 'limbuild-device-signing';
+const SIGNING_DB_VERSION = 1;
+const SIGNING_STORE_NAME = 'signingAssets';
+
+export function normalizeUDID(udid?: string) {
+  return (udid ?? '').replace(/-/g, '').replace(/[^a-fA-F0-9]/g, '');
+}
+
+export function normalizeBundleID(bundleID?: string) {
+  return (bundleID ?? '').trim();
+}
+
+export async function getPairRecord(udid?: string) {
+  const normalized = normalizeUDID(udid);
+  if (!normalized) return undefined;
+  const db = await openDB(PAIRING_DB_NAME, PAIRING_DB_VERSION, PAIRING_STORE_NAME, 'udid');
+  return requestToPromise<StoredPairRecord | undefined>(
+    db.transaction(PAIRING_STORE_NAME, 'readonly').objectStore(PAIRING_STORE_NAME).get(normalized),
+  );
+}
+
+export async function putPairRecord(record: PairRecordPayload, metadata: { productName?: string } = {}) {
+  const normalized = normalizeUDID(record.udid);
+  if (!normalized) throw new Error('Cannot store pair record without a UDID.');
+  const stored: StoredPairRecord = {
+    ...record,
+    udid: normalized,
+    productName: metadata.productName,
+    updatedAt: new Date().toISOString(),
+  };
+  const db = await openDB(PAIRING_DB_NAME, PAIRING_DB_VERSION, PAIRING_STORE_NAME, 'udid');
+  await requestToPromise(
+    db.transaction(PAIRING_STORE_NAME, 'readwrite').objectStore(PAIRING_STORE_NAME).put(stored),
+  );
+  return stored;
+}
+
+export async function getSigningAssets({
+  deviceUDID,
+  bundleID,
+}: {
+  deviceUDID?: string;
+  bundleID?: string;
+}) {
+  const normalizedBundleID = normalizeBundleID(bundleID);
+  if (!normalizedBundleID) return undefined;
+  const normalizedUDID = normalizeUDID(deviceUDID);
+  const bundleScoped = await getSigningAssetsByID(signingAssetID('bundle', normalizedBundleID));
+  if (bundleScoped) return bundleScoped;
+  if (normalizedUDID) {
+    const exact = await getSigningAssetsByID(signingAssetID(normalizedUDID, normalizedBundleID));
+    if (exact) return exact;
+  }
+  const candidates = await findSigningAssetsForBundle(normalizedBundleID);
+  return candidates[0];
+}
+
+export async function getLatestSigningAssets() {
+  const all = await getAllSigningAssets();
+  return all.sort(
+    (left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime(),
+  )[0];
+}
+
+export async function getLatestSigningAssetsWithCertificate(teamID?: string) {
+  const all = await getAllSigningAssets();
+  return all
+    .filter((asset) => {
+      if (!asset.certificateID || !asset.certificateP12Base64 || !asset.certificatePassword) {
+        return false;
+      }
+      return !teamID || !asset.teamID || asset.teamID === teamID;
+    })
+    .sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime())[0];
+}
+
+export async function putSigningAssets(input: PutSigningAssetsInput) {
+  const normalizedBundleID = normalizeBundleID(input.bundleID);
+  if (!normalizedBundleID) {
+    throw new Error('Cannot store signing assets without a bundle ID.');
+  }
+  const normalizedUDID = normalizeUDID(input.deviceUDID);
+  const id = signingAssetID('bundle', normalizedBundleID);
+  const stored: StoredSigningAssets = {
+    ...input,
+    id,
+    deviceUDID: normalizedUDID || undefined,
+    bundleID: normalizedBundleID,
+    updatedAt: new Date().toISOString(),
+  };
+  const db = await openDB(SIGNING_DB_NAME, SIGNING_DB_VERSION, SIGNING_STORE_NAME, 'id');
+  await requestToPromise(
+    db.transaction(SIGNING_STORE_NAME, 'readwrite').objectStore(SIGNING_STORE_NAME).put(stored),
+  );
+  return stored;
+}
+
+export async function findSigningAssetsForBundle(bundleID?: string) {
+  const normalized = normalizeBundleID(bundleID);
+  if (!normalized) return [];
+  const all = await getAllSigningAssets();
+  return all.filter((asset) => asset.bundleID === normalized);
+}
+
+export function profileContainsDevice(profile: ProvisioningProfileInfo, deviceUDID?: string) {
+  const normalized = normalizeUDID(deviceUDID);
+  return !!normalized && profile.provisionedDevices.some((device) => normalizeUDID(device) === normalized);
+}
+
+export function profileMatchesBundleID(profile: ProvisioningProfileInfo, bundleID?: string) {
+  const expected = normalizeBundleID(bundleID);
+  const profileBundleID = normalizeBundleID(profile.bundleID);
+  if (!expected || !profileBundleID) return false;
+  if (profileBundleID === expected) return true;
+  if (profileBundleID === '*') return true;
+  if (!profileBundleID.endsWith('.*')) return false;
+  const prefix = profileBundleID.slice(0, -1);
+  return expected.startsWith(prefix);
+}
+
+export async function parseProvisioningProfile(file: File) {
+  return parseProvisioningProfileBytes(new Uint8Array(await file.arrayBuffer()));
+}
+
+export function parseProvisioningProfileBase64(base64: string) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return parseProvisioningProfileBytes(bytes);
+}
+
+export function parseProvisioningProfileBytes(bytes: Uint8Array) {
+  const text = new TextDecoder('latin1').decode(bytes);
+  const start = text.indexOf('<?xml');
+  const end = text.indexOf('</plist>');
+  if (start < 0 || end < start) {
+    throw new Error('Provisioning profile plist not found.');
+  }
+  const xml = text.slice(start, end + '</plist>'.length);
+  const doc = new DOMParser().parseFromString(xml, 'application/xml');
+  if (doc.querySelector('parsererror')) {
+    throw new Error('Provisioning profile plist could not be parsed.');
+  }
+  const dict = doc.querySelector('plist > dict');
+  if (!dict) {
+    throw new Error('Provisioning profile plist dictionary not found.');
+  }
+  const value = readPlistValue(dict);
+  if (!isRecord(value)) {
+    throw new Error('Provisioning profile plist has an unexpected shape.');
+  }
+  const entitlements = isRecord(value.Entitlements) ? value.Entitlements : {};
+  const applicationIdentifier = stringValue(entitlements['application-identifier']);
+  const bundleID = bundleIDFromApplicationIdentifier(applicationIdentifier);
+  return {
+    name: stringValue(value.Name),
+    uuid: stringValue(value.UUID),
+    teamID:
+      stringValue(entitlements['com.apple.developer.team-identifier']) ??
+      stringArrayValue(value.TeamIdentifier)[0],
+    applicationIdentifier,
+    bundleID,
+    provisionedDevices: stringArrayValue(value.ProvisionedDevices),
+    expirationDate: stringValue(value.ExpirationDate),
+  } satisfies ProvisioningProfileInfo;
+}
+
+async function getSigningAssetsByID(id?: string) {
+  if (!id) return undefined;
+  const db = await openDB(SIGNING_DB_NAME, SIGNING_DB_VERSION, SIGNING_STORE_NAME, 'id');
+  return requestToPromise<StoredSigningAssets | undefined>(
+    db.transaction(SIGNING_STORE_NAME, 'readonly').objectStore(SIGNING_STORE_NAME).get(id),
+  );
+}
+
+async function getAllSigningAssets() {
+  const db = await openDB(SIGNING_DB_NAME, SIGNING_DB_VERSION, SIGNING_STORE_NAME, 'id');
+  return requestToPromise<StoredSigningAssets[]>(
+    db.transaction(SIGNING_STORE_NAME, 'readonly').objectStore(SIGNING_STORE_NAME).getAll(),
+  );
+}
+
+function signingAssetID(deviceUDID: string, bundleID: string) {
+  return `${deviceUDID}:${bundleID}`;
+}
+
+function bundleIDFromApplicationIdentifier(applicationIdentifier?: string) {
+  if (!applicationIdentifier) return undefined;
+  const dot = applicationIdentifier.indexOf('.');
+  return dot >= 0 ? applicationIdentifier.slice(dot + 1) : undefined;
+}
+
+function readPlistValue(element: Element): unknown {
+  switch (element.tagName) {
+    case 'dict':
+      return readPlistDict(element);
+    case 'array':
+      return Array.from(element.children).map(readPlistValue);
+    case 'string':
+    case 'date':
+      return element.textContent ?? '';
+    default:
+      return element.textContent ?? '';
+  }
+}
+
+function readPlistDict(dict: Element) {
+  const result: Record<string, unknown> = {};
+  const children = Array.from(dict.children);
+  for (let index = 0; index < children.length; index += 2) {
+    const key = children[index];
+    const value = children[index + 1];
+    if (!key || key.tagName !== 'key' || !value) continue;
+    result[key.textContent ?? ''] = readPlistValue(value);
+  }
+  return result;
+}
+
+function stringValue(value: unknown) {
+  return typeof value === 'string' && value ? value : undefined;
+}
+
+function stringArrayValue(value: unknown) {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function openDB(dbName: string, dbVersion: number, storeName: string, keyPath: string) {
+  return new Promise<IDBDatabase>((resolve, reject) => {
+    const request = indexedDB.open(dbName, dbVersion);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName, { keyPath });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error('Open IndexedDB failed'));
+  });
+}
+
+function requestToPromise<T = unknown>(request: IDBRequest<T>) {
+  return new Promise<T>((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed'));
+  });
+}

package/src/core/device-install/storage/index.ts

@@ -0,0 +1 @@
+export * from './browser-storage';