amaran-light-cli 1.10.0 → 1.12.0

package/scripts/ble-followup-check.ts

@@ -0,0 +1,165 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { z } from 'zod';
+import { SavedStateSchema } from '../src/ble/library.js';
+import { FAN_MODES } from '../src/ble/telink.js';
+import { captureWebcam } from './webcam.js';
+
+const base = process.env.AMARAN_BLE_URL ?? 'http://127.0.0.1:2708';
+const run = Date.now();
+const records: unknown[] = [];
+const failures: string[] = [];
+const cleanup: string[] = [];
+let baseline: { id: string; states: Record<string, z.infer<typeof SavedStateSchema>> } | undefined;
+let group: string | undefined;
+let priorOverrides: Record<string, number> = {};
+
+async function request(route: string, body?: object, method = body ? 'POST' : 'GET') {
+  const response = await fetch(`${base}${route}`, {
+    method,
+    headers: { connection: 'close', ...(body ? { 'content-type': 'application/json' } : {}) },
+    ...(body ? { body: JSON.stringify(body) } : {}),
+    signal: AbortSignal.timeout(60_000),
+  });
+  const data = z
+    .object({ ok: z.boolean(), result: z.unknown().optional(), error: z.string().optional() })
+    .parse(await response.json());
+  if (!response.ok || !data.ok) throw new Error(`${route}: ${data.error ?? response.status}`);
+  records.push({ route, body, result: data.result });
+  return data.result;
+}
+function cli(...args: string[]) {
+  const output = execFileSync(process.execPath, ['dist/cli.js', ...args, '--backend', 'ble', '--url', base], {
+    encoding: 'utf8',
+    timeout: 60_000,
+  });
+  records.push({ cli: args, output });
+  return output;
+}
+async function state(key: string) {
+  return SavedStateSchema.parse(await request(`/lights/${key}/state`));
+}
+const entry = z.object({ id: z.string() });
+function image(label: string) {
+  const filename = captureWebcam(`followup-${run}-${label}`);
+  const report = z
+    .object({
+      regions: z.array(
+        z.object({ name: z.string(), clippedFraction: z.number(), haloRgb: z.array(z.number()).optional() })
+      ),
+    })
+    .parse(JSON.parse(readFileSync(filename.replace(/\.png$/, '.json'), 'utf8')));
+  records.push({ camera: filename, regions: report.regions });
+  return report.regions;
+}
+
+try {
+  const remaining = z.record(z.number()).parse(await request('/overrides', { targets: 'all' }));
+  priorOverrides = Object.fromEntries(Object.entries(remaining).map(([key, ms]) => [key, ms ? Date.now() + ms : 0]));
+  for (const key of ['desk', 'front', 'back']) {
+    const before = await state(key);
+    assert.equal(before.mode, 'cct', 'Start these checks in steady CCT mode');
+    assert.ok(!before.sleep && before.intensity >= 10 && before.intensity <= 50, 'Begin with all fixtures on at 1-5%');
+  }
+  const regions = image('baseline');
+  for (const key of ['desk', 'front', 'back']) {
+    const region = regions.find((item) => item.name === key);
+    assert.ok(
+      region && region.clippedFraction > 0.25,
+      `${key}: camera region is not on the emitter; recalibrate before testing`
+    );
+  }
+  baseline = z
+    .object({ id: z.string(), states: z.record(SavedStateSchema) })
+    .parse(await request('/library/scenes', { name: `Followup baseline ${run}` }));
+  for (const key of Object.keys(baseline.states)) {
+    const info = z
+      .object({ cctMin: z.number(), cctMax: z.number(), protocolVersion: z.number() })
+      .parse(await request(`/lights/${key}/info`));
+    assert.equal(info.cctMin, key === 'back' ? 2500 : 2700);
+  }
+  group = entry.parse(await request('/groups', { name: `Followup ${run}` })).id;
+  for (const member of ['desk', 'back']) await request(`/groups/${encodeURIComponent(group)}/members`, { member });
+  cli('group', 'rename', group, `Followup renamed ${run}`);
+  assert.equal(
+    z.object({ name: z.string() }).parse(await request(`/groups/${encodeURIComponent(group)}`)).name,
+    `Followup renamed ${run}`
+  );
+  cli('ble', 'transition', 'cct', '2', '--targets', 'all', '--args', '{"kelvin":3200,"brightness":1}');
+  for (const key of ['desk', 'front', 'back']) assert.equal((await state(key)).cct, 3200);
+  cli('ble', 'transition', 'hsi', '2', '--targets', 'back', '--args', '{"hue":120,"saturation":100,"brightness":1}');
+  const green = image('green').find((region) => region.name === 'back')?.haloRgb;
+  assert.ok(green && green[1] - Math.max(green[0], green[2]) > 20);
+  assert.deepEqual(await request('/lights/back/auto-cct', { kelvin: 5600, brightness: 1 }), {
+    skipped: true,
+    reason: 'manual-override',
+  });
+  assert.equal((await state('back')).mode, 'hsi');
+  for (const key of ['desk', 'back'])
+    await request(`/lights/${key}/effect`, { name: 'pulsing', brightness: 0, frequency: 1 });
+  const triggered = z
+    .object({ triggerRequest: z.object({ sent: z.literal(true), eventConfirmed: z.literal(false) }) })
+    .parse(await request(`/lights/${encodeURIComponent(group)}/effect-trigger`, {}));
+  assert.equal(triggered.triggerRequest.eventConfirmed, false);
+  cli('effect', 'stop', group);
+  assert.equal((await state('desk')).mode, 'cct');
+  assert.equal((await state('back')).mode, 'hsi');
+  const preset = entry.parse(await request('/library/presets', { name: `Preset ${run}`, keys: ['back'] }));
+  cleanup.push(`/library/presets/${preset.id}`);
+  cli('preset', 'update', preset.id, '--name', `Preset updated ${run}`);
+  assert.equal(
+    z.object({ name: z.string() }).parse(await request(`/library/presets/${preset.id}`)).name,
+    `Preset updated ${run}`
+  );
+  const quickshot = entry.parse(await request('/library/quickshots', { name: `Quickshot ${run}` }));
+  cleanup.push(`/library/quickshots/${quickshot.id}`);
+  cli('quickshot', 'update', quickshot.id, '--name', `Quickshot updated ${run}`);
+  await request('/lights/back/fan', { mode: 'medium' });
+  cli('scene', 'recall', baseline.id, '--fade', '2');
+  for (const [key, expected] of Object.entries(baseline.states)) {
+    const actual = await state(key);
+    for (const field of ['mode', 'cct', 'intensity', 'sleep'] as const) assert.equal(actual[field], expected[field]);
+    if (expected.fan)
+      assert.equal(
+        z.object({ mode: z.number() }).parse(await request(`/lights/${key}/fan`)).mode,
+        FAN_MODES[expected.fan.mode]
+      );
+  }
+} catch (error) {
+  failures.push(String(error));
+} finally {
+  if (baseline) {
+    try {
+      await request(`/library/scenes/${baseline.id}/recall`, {});
+    } catch (error) {
+      failures.push(`Restore baseline: ${error}`);
+    }
+    cleanup.push(`/library/scenes/${baseline.id}`);
+  }
+  if (group) cleanup.push(`/groups/${encodeURIComponent(group)}`);
+  for (const route of cleanup) {
+    try {
+      await request(route, undefined, 'DELETE');
+    } catch (error) {
+      failures.push(`Cleanup ${route}: ${error}`);
+    }
+  }
+  if (!failures.length)
+    for (const [key, expires] of Object.entries(priorOverrides)) {
+      try {
+        await request('/overrides', { targets: [key], minutes: Math.max(0, (expires - Date.now()) / 60_000) });
+      } catch (error) {
+        failures.push(`Restore override ${key}: ${error}`);
+      }
+    }
+  writeFileSync(
+    `artifacts/followup-${run}-results.json`,
+    JSON.stringify({ baseline, priorOverrides, records, failures }, null, 2),
+    { mode: 0o600 }
+  );
+}
+if (failures.length) throw new Error(failures.join('\n'));
+console.log(
+  `Supported-control checks passed; lighting, fan profiles and overrides restored. artifacts/followup-${run}-results.json`
+);

package/scripts/ble-hardware-check.ts

@@ -0,0 +1,99 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { setTimeout as delay } from 'node:timers/promises';
+import { captureWebcam } from './webcam.js';
+
+const base = process.env.AMARAN_BLE_URL ?? 'http://127.0.0.1:2708';
+const run = Date.now();
+const results: object[] = [];
+const positions: Record<string, string> = { desk: 'desk', front: 'front', back: 'back' };
+
+async function request(key: string, action: string, body?: object) {
+  const response = await fetch(`${base}/lights/${encodeURIComponent(key)}/${action}`, {
+    method: body ? 'POST' : 'GET',
+    headers: body ? { 'content-type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+    signal: AbortSignal.timeout(60_000),
+  });
+  const data = await response.json();
+  if (!response.ok || !data.ok) throw new Error(`${key} ${action}: ${data.error ?? response.status}`);
+  return data.result;
+}
+
+function image(label: string, key: string) {
+  const filename = captureWebcam(`ble-check-${run}-${label}`);
+  const metrics = JSON.parse(readFileSync(filename.replace(/\.png$/, '.json'), 'utf8'));
+  const region = metrics.regions.find((entry: { name: string }) => entry.name === positions[key]);
+  if (!region) throw new Error(`No camera ROI for ${key}`);
+  return {
+    filename,
+    rgb: region.rgb as number[],
+    haloRgb: region.haloRgb as number[] | undefined,
+    clippedFraction: region.clippedFraction as number,
+  };
+}
+
+const initial: Record<string, unknown> = {};
+const errors: unknown[] = [];
+try {
+  for (const key of Object.keys(positions)) initial[key] = await request(key, 'state');
+  writeFileSync(`artifacts/ble-check-${run}-initial.json`, JSON.stringify(initial, null, 2), { mode: 0o600 });
+  for (const key of Object.keys(positions)) await request(key, 'off', {});
+  for (const key of Object.keys(positions)) {
+    const dark = image(`${key}-off`, key);
+    await request(key, 'cct', { kelvin: 3200, brightness: 1 });
+    await request(key, 'on', {});
+    for (const kelvin of [3200, 6500]) {
+      const state = await request(key, 'cct', { kelvin, brightness: 1 });
+      await delay(500);
+      const optical = image(`${key}-${kelvin}-1pct`, key);
+      const difference = optical.rgb.reduce((sum, value, i) => sum + value - dark.rgb[i], 0) / 3;
+      if (difference < 40) throw new Error(`${key}: camera did not confirm illumination (difference ${difference})`);
+      results.push({ key, action: 'cct', requested: kelvin, state, optical, opticalOnDifference: difference });
+    }
+    for (const value of [0, 1, 2]) {
+      const state = await request(key, 'brightness', { value });
+      results.push({
+        key,
+        action: 'brightness',
+        requested: value,
+        state,
+        optical: image(`${key}-${value}pct`, key),
+      });
+    }
+    const state = await request(key, 'off', {});
+    results.push({ key, action: 'off', state, optical: image(`${key}-off-after`, key) });
+  }
+  await request('back', 'on', {});
+  for (const [hue, channel] of [
+    [0, 0],
+    [120, 1],
+    [240, 2],
+  ]) {
+    const state = await request('back', 'hsi', { hue, saturation: 100, brightness: 1 });
+    await delay(500);
+    const optical = image(`back-hue-${hue}`, 'back');
+    const color = optical.haloRgb;
+    if (!color || color[channel] - Math.max(...color.filter((_, i) => i !== channel)) < 20)
+      throw new Error(`Camera did not confirm hue ${hue}: halo RGB ${color}`);
+    results.push({ key: 'back', action: 'hsi', requested: hue, state, optical });
+  }
+} catch (error) {
+  errors.push(error);
+} finally {
+  const failures: string[] = [];
+  for (const key of Object.keys(positions)) {
+    try {
+      await request(key, 'off', {});
+    } catch (error) {
+      failures.push(`${key}: ${(error as Error).message}`);
+    }
+  }
+  writeFileSync(
+    `artifacts/ble-check-${run}-results.json`,
+    JSON.stringify({ results, errors: errors.map(String), shutdownFailures: failures }, null, 2),
+    { mode: 0o600 }
+  );
+  if (failures.length) errors.push(new Error(`Could not confirm lights off: ${failures.join('; ')}`));
+}
+if (errors.length) throw new AggregateError(errors, 'Hardware verification failed');
+console.log(`Hardware feedback checks completed: ${results.length} verified states with local images.`);

package/scripts/ble-live-extended-check.ts

@@ -0,0 +1,205 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { z } from 'zod';
+import { SavedStateSchema } from '../src/ble/library.js';
+import { FAN_MODES, type FixtureState, parseFanMode } from '../src/ble/telink.js';
+import { captureWebcam, imagePixels, RegionSchema, regionsFile } from './webcam.js';
+
+const base = process.env.AMARAN_BLE_URL ?? 'http://127.0.0.1:2708';
+const run = Date.now();
+const results: unknown[] = [];
+const errors: string[] = [];
+const initial: Record<string, FixtureState> = {};
+const fans: Record<string, number> = {};
+const calibration = z.object({ regions: z.array(RegionSchema) }).parse(JSON.parse(readFileSync(regionsFile, 'utf8')));
+const keys = ['desk', 'front', 'back'];
+let changed = false;
+
+async function request(route: string, body?: object, method = body ? 'POST' : 'GET'): Promise<unknown> {
+  const response = await fetch(`${base}${route}`, {
+    method,
+    ...(body ? { body: JSON.stringify(body), headers: { 'content-type': 'application/json' } } : {}),
+    signal: AbortSignal.timeout(60_000),
+  });
+  const data = z
+    .object({ ok: z.boolean(), result: z.unknown().optional(), error: z.string().optional() })
+    .parse(await response.json());
+  if (!response.ok || !data.ok) throw new Error(`${route}: ${data.error ?? response.status}`);
+  results.push({ route, body, result: data.result });
+  return data.result;
+}
+async function light(key: string, action: string, body?: object) {
+  return SavedStateSchema.parse(await request(`/lights/${key}/${action}`, body));
+}
+function image(label: string) {
+  const filename = captureWebcam(`extended-${run}-${label}`);
+  return z
+    .object({
+      regions: z.array(
+        z.object({ name: z.string(), rgb: z.array(z.number()), haloRgb: z.array(z.number()).optional() })
+      ),
+    })
+    .parse(JSON.parse(readFileSync(filename.replace(/\.png$/, '.json'), 'utf8'))).regions;
+}
+function mean(rgb: number[]) {
+  return rgb.reduce((sum, value) => sum + value, 0) / rgb.length;
+}
+function pulsingVideo(key: string) {
+  const region = calibration.regions.find((entry) => entry.name === key);
+  if (!region) throw new Error(`No calibrated region for ${key}`);
+  const prefix = `extended-${run}-pulsing`;
+  const capture = spawnSync(
+    'ffmpeg',
+    [
+      '-hide_banner',
+      '-loglevel',
+      'error',
+      '-f',
+      'avfoundation',
+      '-pixel_format',
+      'nv12',
+      '-framerate',
+      '30',
+      '-video_size',
+      '1280x720',
+      '-i',
+      `${process.env.AMARAN_CAMERA_INDEX ?? '0'}:none`,
+      '-t',
+      '12',
+      '-vf',
+      'fps=2',
+      '-y',
+      `artifacts/webcam/${prefix}-%03d.png`,
+    ],
+    { encoding: 'utf8', timeout: 30_000 }
+  );
+  if (capture.status !== 0) throw new Error(capture.stderr || 'Pulsing video capture failed');
+  const levels = readdirSync('artifacts/webcam')
+    .filter((name) => name.startsWith(`${prefix}-`) && name.endsWith('.png'))
+    .sort()
+    .map((name) => {
+      const pixels = imagePixels(`artifacts/webcam/${name}`);
+      let sum = 0;
+      for (let y = region.y; y < region.y + region.height; y++)
+        for (let x = region.x; x < region.x + region.width; x++) {
+          const offset = (y * 1280 + x) * 3;
+          sum += mean([...pixels.subarray(offset, offset + 3)]);
+        }
+      return sum / (region.width * region.height);
+    });
+  assert.ok(levels.length >= 20, 'Need enough camera samples to observe pulsing');
+  const settled = levels.slice(6);
+  assert.ok(Math.max(...settled) - Math.min(...settled) > 40, `Camera did not confirm pulse modulation: ${levels}`);
+  const changes = settled.slice(1).map((value, index) => value - settled[index]);
+  assert.ok(
+    changes.some((value) => value > 20) && changes.some((value) => value < -20),
+    'Need both rising and falling output after camera exposure settles'
+  );
+  results.push({ opticalPulsing: { key, levels, span: Math.max(...settled) - Math.min(...settled) } });
+}
+
+try {
+  for (const key of keys) {
+    initial[key] = await light(key, 'state');
+    const fan = z.object({ mode: z.number() }).parse(await request(`/lights/${key}/fan`));
+    parseFanMode(fan.mode);
+    assert.notEqual(fan.mode, FAN_MODES.manual, 'Cannot infer an original manual RPM setpoint for restoration');
+    fans[key] = fan.mode;
+  }
+  writeFileSync(`artifacts/extended-${run}-initial.json`, JSON.stringify({ states: initial, fans }, null, 2), {
+    mode: 0o600,
+  });
+  assert.ok(
+    Object.values(initial).every((state) => state.mode === 'cct'),
+    'Begin hardware checks with all three fixtures in steady CCT mode'
+  );
+  changed = true;
+  await request('/batch', { targets: 'all', action: 'off', args: {} });
+  const dark = image('all-off');
+  await request('/batch', { targets: 'all', action: 'cct', args: { kelvin: 3200, brightness: 1 } });
+  const bright = image('all-1pct');
+  for (const key of keys) {
+    const before = dark.find((region) => region.name === key);
+    const after = bright.find((region) => region.name === key);
+    assert.ok(before && after);
+    assert.ok(mean(after.rgb) - mean(before.rgb) > 40, `Camera did not confirm ${key} illumination`);
+    const fan = z
+      .object({ mode: z.number(), speed: z.number(), highTemperature: z.boolean() })
+      .parse(await request(`/lights/${key}/fan`, { mode: 'medium' }));
+    assert.equal(fan.mode, 5);
+    assert.equal(fan.highTemperature, false);
+    await request(`/lights/${key}/fan`, { mode: fans[key] });
+  }
+  for (const gm of [-30, 30, 0]) {
+    assert.equal((await light('back', 'gm', { value: gm })).gm, gm);
+    image(`gm-${gm}`);
+  }
+  await request('/batch', { targets: 'all', action: 'brightness', args: { value: 2 }, broadcast: true });
+  for (const key of keys) assert.equal((await light(key, 'state')).intensity, 20);
+  image('broadcast-2pct');
+  await request('/fade', { targets: 'all', brightness: 1, seconds: 2 });
+  for (const key of keys) assert.equal((await light(key, 'state')).intensity, 10);
+  image('faded-1pct');
+  const scene = z.object({ id: z.string() }).parse(await request('/library/scenes', { name: `Hardware check ${run}` }));
+  try {
+    await light('back', 'color', { color: '#00ff00', brightness: 1 });
+    const colored = image('hsi-green').find((region) => region.name === 'back');
+    assert.ok(
+      colored?.haloRgb && colored.haloRgb[1] - Math.max(colored.haloRgb[0], colored.haloRgb[2]) > 20,
+      'Camera did not confirm green HSI'
+    );
+    await request(`/library/scenes/${scene.id}/recall`, {});
+    for (const key of keys) assert.equal((await light(key, 'state')).cct, 3200);
+  } finally {
+    await request(`/library/scenes/${scene.id}`, undefined, 'DELETE');
+  }
+  await light('front', 'off', {});
+  await light('back', 'off', {});
+  const pulse = await light('desk', 'effect', { name: 'pulsing', brightness: 1, frequency: 1, kelvin: 3200 });
+  assert.equal(pulse.effect, 'pulsing');
+  pulsingVideo('desk');
+  await light('desk', 'effect-stop', {});
+  await light('desk', 'off', {});
+  for (const settings of [
+    { name: 'pulsing', brightness: 1, frequency: 1, hue: 120, saturation: 100 },
+    { name: 'party-lights', brightness: 1, frequency: 1, saturation: 80 },
+  ]) {
+    const state = await light('back', 'effect', settings);
+    assert.equal(state.effect, settings.name);
+    image(settings.name);
+    await light('back', 'effect-intensity', { value: 2 });
+    await light('back', 'effect-stop', {});
+  }
+} catch (error) {
+  errors.push(String(error));
+} finally {
+  for (const [key, state] of changed ? Object.entries(initial) : []) {
+    try {
+      assert.equal(state.mode, 'cct', 'This check restores an initial steady CCT setup');
+      await light(key, 'cct', {
+        kelvin: state.cct,
+        brightness: state.intensity / 10,
+        ...(key === 'back' ? { gm: state.gm } : {}),
+      });
+      await light(key, state.sleep ? 'off' : 'on', {});
+      const restored = await light(key, 'state');
+      for (const field of ['cct', 'intensity', 'sleep'] as const) assert.equal(restored[field], state[field]);
+      if (key === 'back') assert.equal(restored.gm, state.gm);
+    } catch (error) {
+      errors.push(`Restore ${key}: ${error}`);
+    }
+    if (fans[key] !== undefined) {
+      try {
+        await request(`/lights/${key}/fan`, { mode: fans[key] });
+      } catch (error) {
+        errors.push(`Restore ${key} fan: ${error}`);
+      }
+    }
+  }
+  writeFileSync(`artifacts/extended-${run}-results.json`, JSON.stringify({ results, errors }, null, 2), {
+    mode: 0o600,
+  });
+}
+if (errors.length) throw new Error(errors.join('\n'));
+console.log(`Extended live checks passed; results saved to artifacts/extended-${run}-results.json`);

package/scripts/ble-non-ota-check.ts

@@ -0,0 +1,193 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { realpathSync, writeFileSync } from 'node:fs';
+import { z } from 'zod';
+import { SavedStateSchema } from '../src/ble/library.js';
+
+const base = process.env.AMARAN_BLE_URL ?? 'http://127.0.0.1:2708';
+const database = process.argv[2];
+if (!database) throw new Error('Supply the matching Desktop database path');
+const run = Date.now();
+const records: unknown[] = [],
+  failures: string[] = [];
+const cleanup: string[] = [],
+  jobs: string[] = [];
+let baseline: { id: string; states: Record<string, z.infer<typeof SavedStateSchema>> } | undefined;
+let overrides: Record<string, number> = {};
+async function request(route: string, body?: object, method = body ? 'POST' : 'GET') {
+  const response = await fetch(`${base}${route}`, {
+    method,
+    headers: { connection: 'close', ...(body ? { 'content-type': 'application/json' } : {}) },
+    ...(body ? { body: JSON.stringify(body) } : {}),
+    signal: AbortSignal.timeout(60_000),
+  });
+  const data = z
+    .object({ ok: z.boolean(), result: z.unknown().optional(), error: z.string().optional() })
+    .parse(await response.json());
+  if (!response.ok || !data.ok) throw new Error(`${route}: ${data.error ?? response.status}`);
+  records.push({ route, body, result: data.result });
+  return data.result;
+}
+const Status = z.object({ id: z.string(), state: z.string(), frames: z.number(), error: z.string().optional() });
+async function start(body: object) {
+  const status = Status.parse(await request('/programs', body));
+  jobs.push(status.id);
+  return status;
+}
+async function wait(id: string, condition: (state: z.infer<typeof Status>) => boolean) {
+  const end = Date.now() + 30_000;
+  while (Date.now() < end) {
+    const status = Status.parse(await request(`/programs/${id}`));
+    if (status.state === 'failed') throw new Error(status.error);
+    if (condition(status)) return status;
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  throw new Error('Timed out waiting for program');
+}
+async function state(key: string) {
+  return SavedStateSchema.parse(await request(`/lights/${key}/state`));
+}
+try {
+  overrides = Object.fromEntries(
+    Object.entries(z.record(z.number()).parse(await request('/overrides', { targets: 'all' }))).map(([key, ms]) => [
+      key,
+      ms ? Date.now() + ms : 0,
+    ])
+  );
+  for (const key of ['desk', 'front', 'back']) {
+    const light = await state(key);
+    assert.ok(!light.sleep && light.mode === 'cct' && light.intensity <= 50, 'Begin awake in CCT at 5% or less');
+  }
+  baseline = z
+    .object({ id: z.string(), states: z.record(SavedStateSchema) })
+    .parse(await request('/library/scenes', { name: `Non-OTA baseline ${run}` }));
+  const group = z.object({ id: z.string() }).parse(await request('/groups', { name: `Native verification ${run}` }));
+  cleanup.push(`/groups/${encodeURIComponent(group.id)}`);
+  for (const member of ['desk', 'back']) await request(`/groups/${encodeURIComponent(group.id)}/members`, { member });
+  await request(`/groups/${encodeURIComponent(group.id)}/native`, { action: 'enable' });
+  const changed = z
+    .object({ delivery: z.literal('native-group') })
+    .parse(await request(`/lights/${encodeURIComponent(group.id)}/brightness`, { value: 1 }));
+  assert.equal(changed.delivery, 'native-group');
+  assert.equal((await state('desk')).intensity, 10);
+  assert.equal((await state('back')).intensity, 10);
+  assert.equal((await state('front')).intensity, baseline.states.front.intensity);
+  await request(`/groups/${encodeURIComponent(group.id)}/members`, { member: 'front' });
+  await request(`/groups/${encodeURIComponent(group.id)}/members`, { member: 'front', remove: true });
+  await request(`/groups/${encodeURIComponent(group.id)}/native`, { action: 'disable' });
+  await request(`/library/scenes/${baseline.id}/recall`, {});
+  const preview = z
+    .object({
+      valid: z.boolean(),
+      plan: z.object({
+        groups: z.array(z.object({ id: z.string() })),
+        entries: z.array(z.object({ collection: z.string(), entry: z.object({ id: z.string() }) })),
+      }),
+    })
+    .parse(await request('/desktop/import', { database: realpathSync(database), prefix: `Import check ${run}` }));
+  assert.equal(preview.valid, true);
+  for (const item of preview.plan.groups) cleanup.push(`/groups/${encodeURIComponent(item.id)}`);
+  for (const item of preview.plan.entries)
+    cleanup.push(`/library/${item.collection}/${encodeURIComponent(item.entry.id)}`);
+  await request('/desktop/import', { database: realpathSync(database), prefix: `Import check ${run}`, apply: true });
+  const again = z
+    .object({ changes: z.object({ created: z.number(), unchanged: z.number() }) })
+    .parse(
+      await request('/desktop/import', { database: realpathSync(database), prefix: `Import check ${run}`, apply: true })
+    );
+  assert.equal(again.changes.created, 0);
+  assert.ok(again.changes.unchanged > 0);
+  const timeline = await start({
+    kind: 'timeline',
+    targets: 'all',
+    duration: 2,
+    steps: [
+      { at: 0, action: 'brightness', args: { value: 1 } },
+      { at: 1, action: 'brightness', args: { value: 2 } },
+    ],
+  });
+  await wait(timeline.id, (status) => status.state === 'completed');
+  const takeover = await start({
+    kind: 'timeline',
+    targets: ['back'],
+    duration: 5,
+    steps: [
+      { at: 0, action: 'brightness', args: { value: 1 } },
+      { at: 4, action: 'brightness', args: { value: 2 } },
+    ],
+  });
+  await wait(takeover.id, (status) => status.frames > 0);
+  await request('/lights/back/brightness', { value: 3 });
+  assert.equal(Status.parse(await request(`/programs/${takeover.id}`)).state, 'cancelled');
+  assert.equal((await state('back')).intensity, 30);
+  await request(`/library/scenes/${baseline.id}/recall`, {});
+  const picker = await start({
+    kind: 'picker',
+    targets: ['back'],
+    duration: 4,
+    maxBrightness: 1,
+    source: { kind: 'image-file', file: realpathSync('artifacts/program-test-green.png') },
+  });
+  await wait(picker.id, (status) => status.frames > 0);
+  assert.equal((await state('back')).mode, 'hsi');
+  assert.equal((await state('back')).hue, 120);
+  await wait(picker.id, (status) => status.state === 'completed');
+  const audio = await start({
+    kind: 'audio',
+    targets: 'all',
+    duration: 3,
+    maxBrightness: 2,
+    source: { kind: 'audio-file', file: realpathSync('artifacts/program-test-tone.wav') },
+  });
+  const audioDone = await wait(audio.id, (status) => status.state === 'completed');
+  assert.ok(audioDone.frames > 0);
+  const file = `artifacts/timeline-check-${run}.json`;
+  writeFileSync(file, JSON.stringify({ duration: 1, steps: [{ at: 0, action: 'brightness', args: { value: 1 } }] }), {
+    mode: 0o600,
+  });
+  execFileSync(process.execPath, ['dist/cli.js', 'ble', 'program', file, '--targets', 'back'], {
+    stdio: 'pipe',
+    timeout: 20_000,
+  });
+} catch (error) {
+  failures.push(String(error));
+} finally {
+  for (const id of jobs) {
+    try {
+      await request(`/programs/${id}`, undefined, 'DELETE');
+    } catch (error) {
+      failures.push(`Stop program ${id}: ${error}`);
+    }
+  }
+  if (baseline) {
+    try {
+      await request(`/library/scenes/${baseline.id}/recall`, {});
+      for (const [key, expected] of Object.entries(baseline.states)) {
+        const actual = await state(key);
+        for (const field of ['mode', 'intensity', 'sleep', 'cct'] as const)
+          assert.equal(actual[field], expected[field]);
+      }
+    } catch (error) {
+      failures.push(`Restore: ${error}`);
+    }
+    cleanup.push(`/library/scenes/${baseline.id}`);
+  }
+  for (const route of cleanup.reverse()) {
+    try {
+      await request(route, undefined, 'DELETE');
+    } catch (error) {
+      failures.push(`Cleanup ${route}: ${error}`);
+    }
+  }
+  if (!failures.length)
+    for (const [key, until] of Object.entries(overrides)) {
+      try {
+        await request('/overrides', { targets: [key], minutes: Math.max(0, (until - Date.now()) / 60_000) });
+      } catch (error) {
+        failures.push(`Restore override ${key}: ${error}`);
+      }
+    }
+  writeFileSync(`artifacts/non-ota-check-${run}.json`, JSON.stringify({ records, failures }, null, 2), { mode: 0o600 });
+}
+if (failures.length) throw new Error(failures.join('\n'));
+console.log(`Non-OTA checks passed; original state restored: artifacts/non-ota-check-${run}.json`);