@condorinst/mobile-bridge 0.22.0 → 0.23.0

package/dist/dev.js

@@ -48,7 +48,7 @@ function telemetry(spec, now) {
         serialNo: spec.serialNo,
         attemptDate: now - 10 * 6e4,
         message: spec.syncError,
-        messageCode: "SYNC_FAILED"
+        messageCode: "send_data_log_error"
       }
     ] : []
   };
@@ -132,6 +132,7 @@ function systemStatus(overrides = {}) {
     internet: true,
     permission: true,
     hasDevices: true,
+    hasDevicesKnown: true,
     missingOptionalPermissions: [],
     missingEssentialPermissions: [],
     deviceSyncError: {},
@@ -147,13 +148,15 @@ function lightAt(epochMs, serialNo) {
   const photopic = Math.round((daylight * 1800 + noise * 40) * 10) / 10;
   return { photopic, melanopic: Math.round(photopic * 0.62 * 10) / 10 };
 }
-function logAt(epochMs, serialNo, deviceId) {
-  const { photopic, melanopic } = lightAt(epochMs, serialNo);
+function logAt(epochMs, serialNo, deviceId, bodyPart, docked) {
+  const { photopic, melanopic } = docked ? { photopic: 0, melanopic: 0 } : lightAt(epochMs, serialNo);
   return {
     id: Math.floor(epochMs / 1e3) * 10 + serialNo % 10,
     log_time: formatLocalTimestamp(new Date(epochMs)),
     log_type: 1,
-    body_part: "wrist",
+    body_part: bodyPart,
+    // The device's raw wear flag; the name misleads: 1 = worn, 0 = on the dock.
+    off_wrist: docked ? 0 : 1,
     temperature: 31.5,
     lux_photopic: photopic,
     lux_melanopic: melanopic,
@@ -161,6 +164,67 @@ function logAt(epochMs, serialNo, deviceId) {
     act_data_pim: 120
   };
 }
+function spectrum(nm, photopic) {
+  const out = {};
+  for (const w of nm) {
+    const weight = Math.exp(-(((w - 555) / 120) ** 2));
+    out[`wavelength${w}`] = Math.round(photopic * weight * 0.01 * 1e4) / 1e4;
+  }
+  return out;
+}
+var GEN1_NM = [390, 415, 445, 480, 515, 555, 590, 630, 680, 750];
+var GEN2_NM = [395, 426, 457, 488, 520, 551, 582, 613, 644, 675, 707, 738, 769, 800];
+function lightSensorsReading(device, epochMs = Date.now(), withDeviceId = true) {
+  const { photopic, melanopic } = lightAt(epochMs, device.serialNo);
+  const raw = {
+    light_sensor_f1: 0.01,
+    light_sensor_f2: 0.02,
+    light_sensor_f3: 0.03,
+    light_sensor_f4: 0.04,
+    light_sensor_f5: 0.05,
+    light_sensor_f6: 0.04,
+    light_sensor_f7: 0.03,
+    light_sensor_f8: 0.02,
+    light_sensor_clear: Math.round(photopic * 2e-4 * 1e4) / 1e4,
+    light_sensor_nir: 0.01
+  };
+  const address = {
+    serialNo: device.serialNo,
+    ...withDeviceId ? { deviceId: device.deviceId } : {}
+  };
+  if (device.modelId === "actlumus_plus") {
+    return {
+      ...address,
+      type: "actlumus2",
+      data: {
+        ...raw,
+        ...spectrum(GEN2_NM, photopic),
+        time: epochMs,
+        photopic,
+        melanopic,
+        light_sensor_z: 9e-3,
+        light_sensor_y: 0.038,
+        light_sensor_x: 0.044,
+        light_sensor_fd: 0
+      }
+    };
+  }
+  return {
+    ...address,
+    type: "actlumus",
+    data: {
+      ...raw,
+      ...spectrum(GEN1_NM, photopic),
+      time: epochMs,
+      photopic,
+      melanopic,
+      light_sensor_z: null,
+      light_sensor_y: null,
+      light_sensor_x: null,
+      light_sensor_fd: null
+    }
+  };
+}
 var HISTORY_DAYS = 14;
 var encodeCursor = (epochMs) => `mock:${epochMs}`;
 var decodeCursor = (cursor) => Number(cursor.slice("mock:".length));
@@ -175,7 +239,15 @@ function sensorLogPage(query, opts = {}) {
     return { requestId: query.requestId, success: false, error: "CONFLICTING_CURSORS" };
   }
   const newest = Math.floor(now / periodMs) * periodMs;
-  const oldest = newest - HISTORY_DAYS * 864e5;
+  const history = opts.history ?? {};
+  const oldest = newest - (history.days ?? HISTORY_DAYS) * 864e5;
+  const dock = new Set(history.dockHours ?? [7]);
+  const gapHours = new Set(history.gapHours ?? []);
+  const gapDates = new Set(history.gapDates ?? []);
+  const present = (t) => {
+    const d = new Date(t);
+    return !gapHours.has(d.getHours()) && !gapDates.has(formatLocalTimestamp(d).slice(0, 10));
+  };
   const rangeStart = query.startTime ? parseLocalTimestamp(query.startTime) : oldest;
   const rangeEnd = query.endTime ? parseLocalTimestamp(query.endTime) - 1 : newest;
   if (Number.isNaN(rangeStart) || Number.isNaN(rangeEnd) || rangeStart > rangeEnd + 1) {
@@ -183,33 +255,41 @@ function sensorLogPage(query, opts = {}) {
   }
   const first = Math.max(oldest, Math.ceil(rangeStart / periodMs) * periodMs);
   const last = Math.min(newest, Math.floor(rangeEnd / periodMs) * periodMs);
-  let from;
-  let to;
+  const walk = (start, step, max) => {
+    const out = [];
+    for (let t = start; t >= first && t <= last && out.length < max; t += step) {
+      if (present(t)) out.push(t);
+    }
+    return out;
+  };
+  let slots;
   if (query.endingBefore) {
-    to = Math.min(last, decodeCursor(query.endingBefore) - periodMs);
-    from = Math.max(first, to - (limit - 1) * periodMs);
+    slots = walk(
+      Math.min(last, decodeCursor(query.endingBefore) - periodMs),
+      -periodMs,
+      limit
+    ).reverse();
   } else if (query.startingAfter) {
-    from = Math.max(first, decodeCursor(query.startingAfter) + periodMs);
-    to = Math.min(last, from + (limit - 1) * periodMs);
+    slots = walk(Math.max(first, decodeCursor(query.startingAfter) + periodMs), periodMs, limit);
   } else if (query.startTime) {
-    from = first;
-    to = Math.min(last, from + (limit - 1) * periodMs);
+    slots = walk(first, periodMs, limit);
   } else {
-    to = last;
-    from = Math.max(first, to - (limit - 1) * periodMs);
-  }
-  const logs = [];
-  for (let t = from; t <= to; t += periodMs) {
-    logs.push(logAt(t, query.serialNo, opts.deviceId ?? 0));
+    slots = walk(last, -periodMs, limit).reverse();
   }
+  const bodyPart = opts.bodyPart ?? "wrist";
+  const logs = slots.map(
+    (t) => logAt(t, query.serialNo, opts.deviceId ?? 0, bodyPart, dock.has(new Date(t).getHours()))
+  );
+  const from = slots[0] ?? 0;
+  const to = slots[slots.length - 1] ?? 0;
   return {
     requestId: query.requestId,
     success: true,
     logs,
     startingAfter: logs.length ? encodeCursor(to) : null,
     endingBefore: logs.length ? encodeCursor(from) : null,
-    hasMore: logs.length > 0 && to < last,
-    hasPrevious: logs.length > 0 && from > first
+    hasMore: logs.length > 0 && walk(to + periodMs, periodMs, 1).length > 0,
+    hasPrevious: logs.length > 0 && walk(from - periodMs, -periodMs, 1).length > 0
   };
 }
 
@@ -1203,6 +1283,19 @@ var BridgeShell = class {
   }
 };
 
+// src/version.ts
+function versionAtLeast(version, min) {
+  if (!version) return false;
+  const a = version.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const b = min.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return true;
+}
+
 // src/dev/policy.ts
 var CANVAS_POLICY = {
   readOnlyKeys: [
@@ -1238,28 +1331,27 @@ var CANVAS_POLICY = {
 var CANVAS_CSP = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self'; frame-src 'self'; object-src 'none'; base-uri 'none'; form-action 'none';";
 
 // src/dev/scenarios.ts
-var HARNESS_NATIVE_VERSION = "0.17.0";
+var HARNESS_NATIVE_VERSION = "0.18.0";
 var base = {
-  description: "Two devices, background service already running, realistic latency.",
+  description: "Two devices, background service already running, realistic latency. The first device starts a BLE session 3 s after load; the second stays between sessions.",
   nativeVersion: HARNESS_NATIVE_VERSION,
   latencyMs: [80, 250],
   serviceStartMs: 0,
-  userDeviceSilent: false,
   logPeriodS: 60,
   systemStatus: systemStatus(),
   devices: () => twoDevices()
 };
 var SCENARIOS = {
-  default: base,
+  default: { ...base, firstSessionAfterMs: 3e3 },
   "cold-start": {
     ...base,
-    description: "App launched from cold: the background service takes 4 s to start, and every ping/userDevice sent before that is lost. A bundle that asks once stays on its loading screen forever.",
+    description: "App launched from cold: the background service takes 4 s to start, and every ping/userDevice sent before that is lost. From nativeVersion 0.18.0 the app re-sends the lost userDevice itself; below it, a bundle that asks once stays on its loading screen forever.",
     serviceStartMs: 4e3
   },
   "no-devices": {
     ...base,
-    description: "Account with no linked device: userDevice never answers and systemStatus.hasDevices is false. Your bundle must show an empty state.",
-    userDeviceSilent: true,
+    description: "Account with no linked device: userDevice answers with error NO_DEVICES (below nativeVersion 0.18.0: never answers) and systemStatus.hasDevices is false. Your bundle must show an empty state.",
+    userDeviceError: "NO_DEVICES",
     systemStatus: systemStatus({ hasDevices: false })
   },
   "shared-serial": {
@@ -1269,9 +1361,8 @@ var SCENARIOS = {
   },
   offline: {
     ...base,
-    description: "No internet. systemStatus.internet is false and sensorLog fails; userDevice answers from the cache.",
-    sensorLogError: "Connection failed",
-    systemStatus: systemStatus({ internet: false })
+    description: "No internet. systemStatus.internet is false and sensorLog fails; userDevice answers from the cache. The internet comes back when a test calls window.condorDev.setStatus({ internet: true }).",
+    systemStatus: systemStatus({ internet: false, hasDevicesKnown: false })
   }
 };
 function resolveScenario(scenario) {
@@ -1290,6 +1381,7 @@ function resolveScenario(scenario) {
 
 // src/dev/harness.ts
 var DEV_HARNESS_MARKER = "__condorDevHarness__";
+var STEP_MS = 200;
 function createSimulatedNative(adapter, scenario, hooks = {}) {
   const now = hooks.now ?? Date.now;
   const startedAt = now();
@@ -1297,6 +1389,25 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
   const timers = /* @__PURE__ */ new Set();
   let status = { ...scenario.systemStatus };
   let canGoBack = false;
+  const alwaysReplies = versionAtLeast(scenario.nativeVersion, "0.18.0");
+  let pendingUserDevice = false;
+  let sensorLogCount = 0;
+  const roster = scenario.devices().devicesConfig;
+  const connected = new Map(roster.map((d) => [d.deviceId, false]));
+  const subscribed = /* @__PURE__ */ new Set();
+  const realTimeOn = /* @__PURE__ */ new Set();
+  const streams = /* @__PURE__ */ new Map();
+  const byId = versionAtLeast(scenario.nativeVersion, "0.17.0");
+  const pendingSync = /* @__PURE__ */ new Set();
+  const pendingErase = /* @__PURE__ */ new Set();
+  const running = /* @__PURE__ */ new Set();
+  const idOf = (device) => byId && roster.filter((d) => d.serialNo === device.serialNo).length > 1 ? { deviceId: device.deviceId } : {};
+  const findDevice = (args) => args.deviceId !== void 0 ? roster.find((d) => d.deviceId === args.deviceId) : roster.find((d) => d.serialNo === args.serialNo);
+  const statusForBundle = () => {
+    if (alwaysReplies) return status;
+    const { hasDevicesKnown: _omitted, ...older } = status;
+    return older;
+  };
   const record2 = (entry) => {
     const full = { at: now(), ...entry };
     log.push(full);
@@ -1311,12 +1422,34 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
   const reply = (key, payload, delay = latency()) => {
     const timer = setTimeout(() => {
       timers.delete(timer);
-      record2({ kind: "reply", key, detail: `${key} \u2192 bundle` });
+      if (typeof payload === "function") payload = payload();
+      record2({ kind: "reply", key, detail: `${key} \u2192 bundle`, payload });
       adapter.triggerEmit(key, payload);
     }, delay);
     timers.add(timer);
   };
   const serviceUp = () => now() - startedAt >= scenario.serviceStartMs;
+  const answerUserDevice = () => {
+    if (scenario.userDeviceError) {
+      if (!alwaysReplies) {
+        record2({
+          kind: "dropped",
+          command: "userDevice",
+          detail: `userDevice unanswered: the lookup failed (${scenario.userDeviceError}) and this app version replies only on success`
+        });
+        return;
+      }
+      reply("userDevice", {
+        lastUpdate: now(),
+        devicesConfig: [],
+        devicesTelemetry: [],
+        devicesUserConfig: [],
+        error: scenario.userDeviceError
+      });
+      return;
+    }
+    reply("userDevice", scenario.devices());
+  };
   const language = () => {
     const deviceLocale = typeof navigator !== "undefined" ? navigator.language : "en-US";
     const lang = deviceLocale.slice(0, 2);
@@ -1333,7 +1466,7 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
     if (command !== "handshake") {
       const shown = JSON.stringify(args);
       const detail = shown === "{}" ? command : `${command} ${shown.length > 160 ? `${shown.slice(0, 157)}...` : shown}`;
-      record2({ kind: "sent", command, detail });
+      record2({ kind: "sent", command, detail, args });
     }
     switch (command) {
       case "handshake":
@@ -1345,8 +1478,8 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
           return;
         }
         reply("handshake-ack", { nativeVersion: scenario.nativeVersion, accepted: true });
-        reply("systemStatus", status, latency() + 20);
-        reply("language", language(), latency() + 30);
+        reply("systemStatus", statusForBundle, latency() + 20);
+        reply("language", language, latency() + 30);
         return;
       case "ping":
         if (!serviceUp()) {
@@ -1361,30 +1494,33 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
         return;
       case "userDevice":
         if (!serviceUp()) {
+          pendingUserDevice = alwaysReplies;
           record2({
             kind: "dropped",
             command,
-            detail: "userDevice lost: the background service is not running yet. Ask again."
-          });
-          return;
-        }
-        if (scenario.userDeviceSilent) {
-          record2({
-            kind: "dropped",
-            command,
-            detail: "userDevice unanswered: the account has no linked device (the app replies only on success)"
+            detail: alwaysReplies ? "userDevice lost: the background service is not running yet; the app re-sends it when the service is up" : "userDevice lost: the background service is not running yet. Ask again."
           });
           return;
         }
-        reply("userDevice", scenario.devices());
+        answerUserDevice();
         return;
       case "sensorLog": {
         const query = args;
-        if (scenario.sensorLogError) {
+        sensorLogCount += 1;
+        if (scenario.sensorLogFailOnRequest === sensorLogCount) {
           reply("sensorLog", {
             requestId: query.requestId,
             success: false,
-            error: scenario.sensorLogError
+            error: "Connection failed"
+          });
+          return;
+        }
+        const logError = scenario.sensorLogError ?? (status.internet === false ? "Connection failed" : void 0);
+        if (logError) {
+          reply("sensorLog", {
+            requestId: query.requestId,
+            success: false,
+            error: logError
           });
           return;
         }
@@ -1403,12 +1539,29 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
           sensorLogPage(query, {
             now: now(),
             periodS: scenario.logPeriodS,
-            deviceId: device?.deviceId
+            deviceId: device?.deviceId,
+            bodyPart: device?.deviceBodyPart ?? "wrist",
+            history: scenario.history
           })
         );
         return;
       }
-      case "realTime":
+      case "realTime": {
+        const device = findDevice(args);
+        if (device) {
+          if (args.value === true) realTimeOn.add(device.deviceId);
+          else realTimeOn.delete(device.deviceId);
+          syncStream(device.deviceId);
+          if (args.value !== true && connected.get(device.deviceId) && !running.has(device.deviceId)) {
+            endSession(device.deviceId, latency());
+          }
+          if (args.value === true && !connected.get(device.deviceId)) {
+            record2({
+              kind: "info",
+              detail: `realTime on for device ${device.deviceId}, which is between BLE sessions: readings start when it connects`
+            });
+          }
+        }
         reply("realTime", {
           serialNo: args.serialNo,
           ...args.deviceId !== void 0 ? { deviceId: args.deviceId } : {},
@@ -1416,23 +1569,37 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
           value: args.value === true
         });
         return;
+      }
       case "syncTime":
       case "deleteMemory":
+        {
+          const target = findDevice(args);
+          if (target) (command === "syncTime" ? pendingSync : pendingErase).add(target.deviceId);
+        }
+        record2({
+          kind: "info",
+          detail: command === "deleteMemory" ? "deleteMemory recorded: the app erases the memory in the next sync, after the data is uploaded" : "syncTime recorded: the app sets the clock in the next sync"
+        });
         reply(command, {
           serialNo: args.serialNo,
           ...args.deviceId !== void 0 ? { deviceId: args.deviceId } : {},
           success: true
         });
         return;
-      case "deviceConnection":
-        if (args.type === "add") {
+      case "deviceConnection": {
+        const device = findDevice(args);
+        if (!device) {
           reply("deviceConnection", {
             serialNo: args.serialNo,
             ...args.deviceId !== void 0 ? { deviceId: args.deviceId } : {},
-            isConnect: true
+            isConnect: false
           });
+          return;
         }
+        if (args.type === "add") subscribed.add(device.deviceId);
+        else if (args.type === "remove") subscribed.delete(device.deviceId);
         return;
+      }
       case "language":
         reply("language", language());
         return;
@@ -1443,7 +1610,7 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
           missingEssentialPermissions: status.missingEssentialPermissions.filter((p) => p !== name),
           missingOptionalPermissions: status.missingOptionalPermissions.filter((p) => p !== name)
         };
-        reply("systemStatus", status, latency() + 400);
+        reply("systemStatus", statusForBundle, latency() + 400);
         return;
       }
       case "jsError":
@@ -1467,11 +1634,157 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
         return;
     }
   };
+  function emitConnection(deviceId) {
+    if (!subscribed.has(deviceId)) return;
+    const device = roster.find((d) => d.deviceId === deviceId);
+    if (!device) return;
+    reply("deviceConnection", {
+      serialNo: device.serialNo,
+      ...idOf(device),
+      isConnect: connected.get(deviceId) === true
+    });
+  }
+  function syncStream(deviceId) {
+    const want = realTimeOn.has(deviceId) && connected.get(deviceId) === true;
+    const running2 = streams.get(deviceId);
+    if (want && !running2) {
+      const device = roster.find((d) => d.deviceId === deviceId);
+      if (!device) return;
+      streams.set(
+        deviceId,
+        setInterval(() => {
+          adapter.triggerEmit(
+            "deviceLightSensors",
+            lightSensorsReading(device, now(), "deviceId" in idOf(device))
+          );
+        }, 1e3)
+      );
+    } else if (!want && running2) {
+      clearInterval(running2);
+      streams.delete(deviceId);
+    }
+  }
+  function setConnected(deviceId, value) {
+    if (!connected.has(deviceId)) {
+      record2({ kind: "info", detail: `setConnected: no device ${deviceId} in this scenario` });
+      return;
+    }
+    if (connected.get(deviceId) === value) return;
+    connected.set(deviceId, value);
+    record2({
+      kind: "info",
+      detail: `device ${deviceId}: BLE session ${value ? "started" : "ended"}`
+    });
+    emitConnection(deviceId);
+    syncStream(deviceId);
+    const device = roster.find((d) => d.deviceId === deviceId);
+    if (device) runSession(device, value);
+  }
+  function setSyncError(device, text, delay) {
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      const byId2 = { ...status.deviceSyncErrorById ?? {} };
+      const bySerial = { ...status.deviceSyncError };
+      const shared = roster.filter((d) => d.serialNo === device.serialNo).length > 1;
+      if (text === null) {
+        if (!(device.deviceId in byId2)) return;
+        delete byId2[device.deviceId];
+        if (!shared) delete bySerial[device.serialNo];
+      } else {
+        byId2[device.deviceId] = text;
+        if (!shared) bySerial[device.serialNo] = text;
+      }
+      status = { ...status, deviceSyncErrorById: byId2, deviceSyncError: bySerial };
+      reply("systemStatus", statusForBundle, 0);
+    }, delay);
+    timers.add(timer);
+  }
+  function runSession(device, start) {
+    const note = (message, messageCode, isError = false) => ({
+      serialNo: device.serialNo,
+      ...idOf(device),
+      isConnect: !isError,
+      message,
+      messageCode,
+      isError
+    });
+    if (!start) {
+      reply("deviceNotification", { ...note("Device disconnected", null), isConnect: false });
+      return;
+    }
+    const id = device.deviceId;
+    const steps = [
+      ["[Start] Enable BLE periodic", "enable_ble_periodic_notification", "enable_ble_periodic"],
+      ["[Not needed] Enable BLE periodic", "enable_ble_periodic_not_needed_notification", ""],
+      ["[Start] Set BLE period", "set_ble_period_notification", "set_ble_period"],
+      ["[Not needed] Set BLE period", "set_ble_period_not_needed_notification", ""],
+      ["[Start] Set sync time", "set_sync_time_notification", "set_sync_time"],
+      ...pendingSync.has(id) ? [] : [["[Not needed] Set sync time", "set_sync_time_not_needed_notification", ""]],
+      ["[Start] Get data log", "get_data_log_notification", "get_data_log"],
+      ["[Start] Send data log", "send_data_log_notification", "send_data_log"],
+      [
+        "[Success] Set last data log sent to server",
+        "set_last_data_log_sent_to_server_notification",
+        ""
+      ],
+      ["[Start] Get system log", "get_system_log_notification", "get_system_log"],
+      ["[Start] Send system log", "send_system_log_notification", "send_system_log"],
+      ["[Start] Get full charge log", "get_full_charge_log_notification", "get_full_charge_log"],
+      ["[Start] Send full charge log", "send_full_charge_log_notification", "send_full_charge_log"],
+      ["[Start] Set erase memory", "set_erase_memory_notification", "set_erase_memory"],
+      ...pendingErase.has(id) ? [["[Start] Erase memory", "erase_memory_notification", ""]] : [],
+      ["[Start] Get device telemetry", "get_device_telemetry_notification", "get_device_telemetry"],
+      ["[Start] Save device telemetry", "save_device_telemetry_notification", ""]
+    ];
+    const failAt = scenario.sessionFailAt ?? (status.internet === false ? "send_data_log" : void 0);
+    running.add(id);
+    let delay = latency();
+    reply("deviceNotification", note("Device connected", null), delay);
+    for (const [message, code, stage] of steps) {
+      delay += STEP_MS;
+      reply("deviceNotification", note(message, code), delay);
+      if (stage && failAt === stage) {
+        delay += STEP_MS;
+        const what = message.replace(/^\[\w+\] /, "");
+        reply("deviceNotification", note(`[Error] ${what}`, `${stage}_error`, true), delay);
+        setSyncError(device, `Sync failed (${stage}_error)`, delay + 20);
+        endSession(id, delay + STEP_MS);
+        return;
+      }
+      if (stage === "set_sync_time") pendingSync.delete(id);
+    }
+    delay += STEP_MS;
+    reply("deviceNotification", note("[Done] Pipeline", "pipeline_done_notification"), delay);
+    setSyncError(device, null, delay + 20);
+    pendingErase.delete(id);
+    endSession(id, delay + STEP_MS);
+  }
+  function endSession(deviceId, delay) {
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      running.delete(deviceId);
+      if (!realTimeOn.has(deviceId)) setConnected(deviceId, false);
+    }, delay);
+    timers.add(timer);
+  }
   const unsubscribe = adapter.onCallHandler(handle);
+  const first = roster[0];
+  if (first && typeof scenario.firstSessionAfterMs === "number") {
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      setConnected(first.deviceId, true);
+    }, scenario.firstSessionAfterMs);
+    timers.add(timer);
+  }
   if (scenario.serviceStartMs > 0) {
     const timer = setTimeout(() => {
       timers.delete(timer);
       record2({ kind: "info", detail: "background service is up: ping and userDevice now answer" });
+      if (pendingUserDevice) {
+        pendingUserDevice = false;
+        record2({ kind: "info", detail: "the app re-sent the pending userDevice" });
+        answerUserDevice();
+      }
     }, scenario.serviceStartMs);
     timers.add(timer);
   }
@@ -1487,8 +1800,15 @@ function createSimulatedNative(adapter, scenario, hooks = {}) {
       }
       reply("navigationBack", {}, 0);
     },
+    setStatus(patch) {
+      status = { ...status, ...patch };
+      reply("systemStatus", statusForBundle(), 0);
+    },
+    setConnected,
     dispose() {
       unsubscribe();
+      for (const t of streams.values()) clearInterval(t);
+      streams.clear();
       for (const t of timers) clearTimeout(t);
       timers.clear();
     }
@@ -1548,15 +1868,18 @@ async function createDevHarness(opts) {
   iframe.setAttribute("title", "Condor Canvas bundle");
   iframe.setAttribute("style", "border:0;width:100%;height:100%;display:block;background:#fff");
   (opts.mount ?? document.body).appendChild(iframe);
+  let confirmations = "ask";
   const shell = new BridgeShell({
     iframe,
     policy: CANVAS_POLICY,
-    onConfirmationRequest: opts.onConfirmationRequest ?? confirmInPage
+    onConfirmationRequest: (req) => confirmations === "ask" ? (opts.onConfirmationRequest ?? confirmInPage)(req) : confirmations === "accept"
   });
   if (opts.devPanel !== false) {
     installDevPanel({ adapter, options: { startCollapsed: true } });
   }
-  await shell.bootstrapClientIframeWithHtml(opts.html);
+  const deviceLike = "<script>try{delete Crypto.prototype.randomUUID}catch(e){}</script>";
+  const html = /<head[^>]*>/i.test(opts.html) ? opts.html.replace(/<head[^>]*>/i, (m) => m + deviceLike) : deviceLike + opts.html;
+  await shell.bootstrapClientIframeWithHtml(html);
   try {
     const result = await shell.verifySandbox();
     if (!result.ok) {
@@ -1581,6 +1904,15 @@ async function createDevHarness(opts) {
     emit(key, payload) {
       Bridge.mockEmit(key, payload);
     },
+    setStatus(patch) {
+      native.setStatus(patch);
+    },
+    setConnected(deviceId, value) {
+      native.setConnected(deviceId, value);
+    },
+    setConfirmations(mode) {
+      confirmations = mode;
+    },
     pressBack() {
       native.pressBack();
     },
@@ -1601,6 +1933,7 @@ export {
   createDevHarness,
   createSimulatedNative,
   formatLocalTimestamp,
+  lightSensorsReading,
   parseLocalTimestamp,
   resolveScenario,
   sensorLogPage,