@mongrov/analytics 0.23.1 → 0.24.0

package/dist/sync/mapper/firmware.js

@@ -18,12 +18,11 @@ import { mapBattery } from './battery';
 import { mapHeartRate } from './heart-rate';
 import { mapHrv } from './hrv';
 import { mapRingConfig } from './ring-config';
-import { reconstructSleepSessions } from './sleep';
+import { mapSleepRaw } from './sleep';
 import { mapSpo2 } from './spo2';
 import { mapTemperature } from './temperature';
 export function mapFirmwareExport(fw, ctx, opts = {}) {
     const activity = mapActivity(fw.activitydetails ?? [], ctx);
-    const sleep = reconstructSleepSessions(fw.sleep_processed ?? [], ctx);
     const config = mapRingConfigIfPossible(fw, ctx, opts);
     return {
         hrv: mapHrv(fw.hrv_table ?? [], ctx),
@@ -32,9 +31,12 @@ export function mapFirmwareExport(fw, ctx, opts = {}) {
         temperature: mapTemperature(fw.temperature_table ?? [], ctx),
         activity: activity.activity,
         activity_bucket: activity.activity_bucket,
-        sleep_session: sleep.sleep_session,
-        sleep_stage: sleep.sleep_stage,
-        sleep_raw: sleep.sleep_raw,
+        // Raw firmware minutes only. Sessions and stages are DERIVED — the sync
+        // factory runs the sleep-correction pipeline over `sleep_raw` after the
+        // batch flushes and writes them night by night (sleep-correction §3).
+        sleep_session: [],
+        sleep_stage: [],
+        sleep_raw: mapSleepRaw(fw.sleep ?? [], ctx),
         // Battery moved off the generic event stream in 0.6.0 (fix B2);
         // `device_event` stays in the batch shape for future event types.
         device_event: [],

package/dist/sync/mapper/firmware.js.map

@@ -1 +1 @@
-{"version":3,"file":"firmware.js","sourceRoot":"","sources":["../../../src/sync/mapper/firmware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAe9C,MAAM,UAAU,iBAAiB,CAC/B,EAAkB,EAClB,GAAkB,EAClB,OAA2B,EAAE;IAE7B,MAAM,QAAQ,GAAG,WAAW,CAAC,EAAE,CAAC,eAAe,IAAI,EAAE,EAAE,GAAG,CAAC,CAAA;IAC3D,MAAM,KAAK,GAAG,wBAAwB,CAAC,EAAE,CAAC,eAAe,IAAI,EAAE,EAAE,GAAG,CAAC,CAAA;IACrE,MAAM,MAAM,GAAG,uBAAuB,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA;IAErD,OAAO;QACL,GAAG,EAAE,MAAM,CAAC,EAAE,CAAC,SAAS,IAAI,EAAE,EAAE,GAAG,CAAC;QACpC,UAAU,EAAE,YAAY,CAAC,EAAE,CAAC,SAAS,IAAI,EAAE,EAAE,GAAG,CAAC;QACjD,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,EAAE,GAAG,CAAC;QACjC,WAAW,EAAE,cAAc,CAAC,EAAE,CAAC,iBAAiB,IAAI,EAAE,EAAE,GAAG,CAAC;QAC5D,QAAQ,EAAE,QAAQ,CAAC,QAAQ;QAC3B,eAAe,EAAE,QAAQ,CAAC,eAAe;QACzC,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,gEAAgE;QAChE,kEAAkE;QAClE,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,UAAU,CAAC,EAAE,CAAC,aAAa,IAAI,EAAE,EAAE,GAAG,CAAC;QACvD,aAAa,EAAE,MAAM,CAAC,OAAO;QAC7B,oBAAoB,EAAE,MAAM,CAAC,MAAM;KACpC,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,uBAAuB,CAC9B,EAAkB,EAClB,GAAkB,EAClB,IAAwB;IAExB,sEAAsE;IACtE,+DAA+D;IAC/D,OAAO,aAAa,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,uBAAuB,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE;QACpE,GAAG,EAAE,IAAI,CAAC,GAAG;QACb,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;KAC5C,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"firmware.js","sourceRoot":"","sources":["../../../src/sync/mapper/firmware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAe9C,MAAM,UAAU,iBAAiB,CAC/B,EAAkB,EAClB,GAAkB,EAClB,OAA2B,EAAE;IAE7B,MAAM,QAAQ,GAAG,WAAW,CAAC,EAAE,CAAC,eAAe,IAAI,EAAE,EAAE,GAAG,CAAC,CAAA;IAC3D,MAAM,MAAM,GAAG,uBAAuB,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA;IAErD,OAAO;QACL,GAAG,EAAE,MAAM,CAAC,EAAE,CAAC,SAAS,IAAI,EAAE,EAAE,GAAG,CAAC;QACpC,UAAU,EAAE,YAAY,CAAC,EAAE,CAAC,SAAS,IAAI,EAAE,EAAE,GAAG,CAAC;QACjD,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,EAAE,GAAG,CAAC;QACjC,WAAW,EAAE,cAAc,CAAC,EAAE,CAAC,iBAAiB,IAAI,EAAE,EAAE,GAAG,CAAC;QAC5D,QAAQ,EAAE,QAAQ,CAAC,QAAQ;QAC3B,eAAe,EAAE,QAAQ,CAAC,eAAe;QACzC,wEAAwE;QACxE,wEAAwE;QACxE,sEAAsE;QACtE,aAAa,EAAE,EAAE;QACjB,WAAW,EAAE,EAAE;QACf,SAAS,EAAE,WAAW,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE,EAAE,GAAG,CAAC;QAC3C,gEAAgE;QAChE,kEAAkE;QAClE,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,UAAU,CAAC,EAAE,CAAC,aAAa,IAAI,EAAE,EAAE,GAAG,CAAC;QACvD,aAAa,EAAE,MAAM,CAAC,OAAO;QAC7B,oBAAoB,EAAE,MAAM,CAAC,MAAM;KACpC,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,uBAAuB,CAC9B,EAAkB,EAClB,GAAkB,EAClB,IAAwB;IAExB,sEAAsE;IACtE,+DAA+D;IAC/D,OAAO,aAAa,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,uBAAuB,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE;QACpE,GAAG,EAAE,IAAI,CAAC,GAAG;QACb,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;KAC5C,CAAC,CAAA;AACJ,CAAC"}

package/dist/sync/mapper/schema.d.ts

@@ -78,35 +78,33 @@ export declare const firmwareActivityRowSchema: z.ZodObject<{
     arraySteps: z.ZodArray<z.ZodNumber, "many">;
 }, "strict", z.ZodTypeAny, {
     calories: number;
-    timestamp: string;
     step: number;
+    timestamp: string;
     distance: number;
     arraySteps: number[];
 }, {
     calories: number;
-    timestamp: string;
     step: number;
+    timestamp: string;
     distance: number;
     arraySteps: number[];
 }>;
-export declare const firmwareSleepRowSchema: z.ZodObject<{
-    start: z.ZodString;
-    end: z.ZodString;
-    block_type: z.ZodString;
-    confidence: z.ZodNumber;
+/** Raw firmware sleep sample (types 0.10.0); `quality` is the firmware code. */
+export declare const firmwareSleepRawRowSchema: z.ZodObject<{
     timestamp: z.ZodString;
+    quality: z.ZodNumber;
+    start: z.ZodString;
+    unitLength: z.ZodNumber;
 }, "strict", z.ZodTypeAny, {
     start: string;
+    quality: number;
+    unitLength: number;
     timestamp: string;
-    end: string;
-    block_type: string;
-    confidence: number;
 }, {
     start: string;
+    quality: number;
+    unitLength: number;
     timestamp: string;
-    end: string;
-    block_type: string;
-    confidence: number;
 }>;
 export declare const firmwareBatteryRowSchema: z.ZodObject<{
     timestamp: z.ZodString;
@@ -389,35 +387,32 @@ export declare const firmwareExportSchema: z.ZodObject<{
         arraySteps: z.ZodArray<z.ZodNumber, "many">;
     }, "strict", z.ZodTypeAny, {
         calories: number;
-        timestamp: string;
         step: number;
+        timestamp: string;
         distance: number;
         arraySteps: number[];
     }, {
         calories: number;
-        timestamp: string;
         step: number;
+        timestamp: string;
         distance: number;
         arraySteps: number[];
     }>, "many">;
-    sleep_processed: z.ZodArray<z.ZodObject<{
-        start: z.ZodString;
-        end: z.ZodString;
-        block_type: z.ZodString;
-        confidence: z.ZodNumber;
+    sleep: z.ZodArray<z.ZodObject<{
         timestamp: z.ZodString;
+        quality: z.ZodNumber;
+        start: z.ZodString;
+        unitLength: z.ZodNumber;
     }, "strict", z.ZodTypeAny, {
         start: string;
+        quality: number;
+        unitLength: number;
         timestamp: string;
-        end: string;
-        block_type: string;
-        confidence: number;
     }, {
         start: string;
+        quality: number;
+        unitLength: number;
         timestamp: string;
-        end: string;
-        block_type: string;
-        confidence: number;
     }>, "many">;
     battery_table: z.ZodArray<z.ZodObject<{
         timestamp: z.ZodString;
@@ -561,17 +556,16 @@ export declare const firmwareExportSchema: z.ZodObject<{
     }[];
     activitydetails: {
         calories: number;
-        timestamp: string;
         step: number;
+        timestamp: string;
         distance: number;
         arraySteps: number[];
     }[];
-    sleep_processed: {
+    sleep: {
         start: string;
+        quality: number;
+        unitLength: number;
         timestamp: string;
-        end: string;
-        block_type: string;
-        confidence: number;
     }[];
     battery_table: {
         timestamp: string;
@@ -622,17 +616,16 @@ export declare const firmwareExportSchema: z.ZodObject<{
     }[];
     activitydetails: {
         calories: number;
-        timestamp: string;
         step: number;
+        timestamp: string;
         distance: number;
         arraySteps: number[];
     }[];
-    sleep_processed: {
+    sleep: {
         start: string;
+        quality: number;
+        unitLength: number;
         timestamp: string;
-        end: string;
-        block_type: string;
-        confidence: number;
     }[];
     battery_table: {
         timestamp: string;

package/dist/sync/mapper/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/sync/mapper/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,mBAAmB;;;;;;;;;EAGrB,CAAA;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAQtB,CAAA;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;EAGvB,CAAA;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;EAGvB,CAAA;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;EAM3B,CAAA;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;EAMxB,CAAA;AAEX,eAAO,MAAM,wBAAwB;;;;;;;;;EAG1B,CAAA;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;EAQxB,CAAA;AAEX;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAShC,CAAA;AAEX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE1B,CAAA;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYtB,CAAA;AAEX,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AASvE;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAsDxD,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/sync/mapper/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,mBAAmB;;;;;;;;;EAGrB,CAAA;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAQtB,CAAA;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;EAGvB,CAAA;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;EAGvB,CAAA;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;EAM3B,CAAA;AAEX,gFAAgF;AAChF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAK3B,CAAA;AAEX,eAAO,MAAM,wBAAwB;;;;;;;;;EAG1B,CAAA;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;EAQxB,CAAA;AAEX;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAShC,CAAA;AAEX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE1B,CAAA;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYtB,CAAA;AAEX,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AASvE;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAqDxD,CAAA"}

package/dist/sync/mapper/schema.js

@@ -45,12 +45,12 @@ export const firmwareActivityRowSchema = z.object({
     distance: z.number(),
     arraySteps: z.array(z.number()).length(10),
 }).strict();
-export const firmwareSleepRowSchema = z.object({
-    start: firmwareTimestamp,
-    end: firmwareTimestamp,
-    block_type: z.string(),
-    confidence: z.number(),
+/** Raw firmware sleep sample (types 0.10.0); `quality` is the firmware code. */
+export const firmwareSleepRawRowSchema = z.object({
     timestamp: firmwareTimestamp,
+    quality: z.number().int(),
+    start: firmwareTimestamp,
+    unitLength: z.number().int().positive(),
 }).strict();
 export const firmwareBatteryRowSchema = z.object({
     timestamp: firmwareTimestamp,
@@ -92,7 +92,7 @@ export const firmwareExportSchema = z.object({
     spo2: z.array(firmwareSpO2RowSchema),
     temperature_table: z.array(firmwareTempRowSchema),
     activitydetails: z.array(firmwareActivityRowSchema),
-    sleep_processed: z.array(firmwareSleepRowSchema),
+    sleep: z.array(firmwareSleepRawRowSchema),
     battery_table: z.array(firmwareBatteryRowSchema),
     ring: firmwareRingConfigSchema,
 }).strict();
@@ -127,12 +127,11 @@ export const FIRMWARE_EXPORT_KEY_PATHS = new Set([
     'activitydetails[].calories',
     'activitydetails[].distance',
     'activitydetails[].arraySteps',
-    'sleep_processed',
-    'sleep_processed[].start',
-    'sleep_processed[].end',
-    'sleep_processed[].block_type',
-    'sleep_processed[].confidence',
-    'sleep_processed[].timestamp',
+    'sleep',
+    'sleep[].timestamp',
+    'sleep[].quality',
+    'sleep[].start',
+    'sleep[].unitLength',
     'battery_table',
     'battery_table[].timestamp',
     'battery_table[].battery',

package/dist/sync/mapper/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/sync/mapper/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,gFAAgF;AAChF,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CACxC,mDAAmD,EACnD,mDAAmD,CACpD,CAAA;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,SAAS,EAAE,iBAAiB;IAC5B,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;CACrB,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,SAAS,EAAE,iBAAiB;IAC5B,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC1B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACrC,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,SAAS,EAAE,iBAAiB;IAC5B,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE;CAC9B,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,SAAS,EAAE,iBAAiB;IAC5B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;CACxB,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,SAAS,EAAE,iBAAiB;IAC5B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;CAC3C,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,KAAK,EAAE,iBAAiB;IACxB,GAAG,EAAE,iBAAiB;IACtB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,SAAS,EAAE,iBAAiB;CAC7B,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,SAAS,EAAE,iBAAiB;IAC5B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;CACpB,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;IACnB,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;IACnB,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;IACtB,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;IACrB,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;IACnB,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;CACtB,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAAC;IACrD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IAC1B,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC5C,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IAChC,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACnC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IAC9B,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACjC,KAAK,EAAE,sBAAsB;IAC7B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,uBAAuB,EAAE,CAAC,CAAC,KAAK,CAAC,8BAA8B,CAAC;CACjE,CAAC,CAAC,MAAM,EAAE,CAAA;AAEX,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,uEAAuE;IACvE,uEAAuE;IACvE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC;IACvC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC;IACxC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC;IACpC,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC;IACjD,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,yBAAyB,CAAC;IACnD,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC;IAChD,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC;IAChD,IAAI,EAAE,wBAAwB;CAC/B,CAAC,CAAC,MAAM,EAAE,CAAA;AAQX,MAAM,wBAAwB,GAA6B,IAAI,CAAA;AAC/D,KAAK,wBAAwB,CAAA;AAE7B;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAwB,IAAI,GAAG,CAAC;IACpE,UAAU;IACV,WAAW;IACX,uBAAuB;IACvB,sBAAsB;IACtB,WAAW;IACX,uBAAuB;IACvB,iBAAiB;IACjB,oBAAoB;IACpB,uBAAuB;IACvB,wBAAwB;IACxB,yBAAyB;IACzB,2BAA2B;IAC3B,MAAM;IACN,kBAAkB;IAClB,0BAA0B;IAC1B,mBAAmB;IACnB,+BAA+B;IAC/B,iCAAiC;IACjC,iBAAiB;IACjB,6BAA6B;IAC7B,wBAAwB;IACxB,4BAA4B;IAC5B,4BAA4B;IAC5B,8BAA8B;IAC9B,iBAAiB;IACjB,yBAAyB;IACzB,uBAAuB;IACvB,8BAA8B;IAC9B,8BAA8B;IAC9B,6BAA6B;IAC7B,eAAe;IACf,2BAA2B;IAC3B,yBAAyB;IACzB,MAAM;IACN,8BAA8B;IAC9B,sEAAsE;IACtE,wEAAwE;IACxE,8DAA8D;IAC9D,yCAAyC;IACzC,6CAA6C;IAC7C,+CAA+C;IAC/C,kDAAkD;IAClD,6CAA6C;IAC7C,gDAAgD;IAChD,qCAAqC;IACrC,sCAAsC;IACtC,6CAA6C;IAC7C,6CAA6C;IAC7C,8CAA8C;IAC9C,gDAAgD;IAChD,+CAA+C;IAC/C,6CAA6C;IAC7C,+CAA+C;CAChD,CAAC,CAAA"}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/sync/mapper/schema.ts"],"names":[],"mappings":"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"}

package/dist/sync/mapper/sleep.d.ts

@@ -1,59 +1,66 @@
 /**
- * Sleep reconstruction mapper (T-06).
+ * Sleep mapping (sleep-correction §3).
  *
- * Firmware `sleep_processed` emits per-block rows tagged with a `start`
- * (session start), `end` (session end), `block_type` (primary / light / deep /
- * rem / awake), `confidence` (0..1), and per-block `timestamp` (block instant).
- * Multiple blocks share the same `start` when they belong to the same session.
+ * Two halves that run at different times:
  *
- * Reconstruction rules (spec.md §Firmware mapper + tasks.md T-06):
- *   - Group rows by `start`.
- *   - A session is included if AT LEAST ONE block in the group has
- *     `block_type === 'primary'` AND `confidence >= 0.7`. This filters
- *     day-time naps and low-confidence noise.
- *   - Session boundaries come from the firmware's own envelope fields:
- *     `ts_start = parse(start)`, `ts_end = parse(end)`. `total_minutes` is
- *     their difference. Deriving the envelope from block instants would
- *     under-report any session whose first/last minutes went unclassified.
- *   - `session_id` = `fnv1a32hex(device_id | user_id | ts_session_start |
- *     ts_session_end)` (principle 25, amended 2026-08-14) — fully
- *     deterministic, so the same night mapped twice yields the same id.
- *   - `night_of` = 6pm-6pm rule applied to `ts_start` (see `time.ts`).
- *   - Stages: one row per classified block, carrying `session_id` and the
- *     DDL's integer `stage` code. `primary` is the session envelope marker,
- *     not a stage, so it produces no `sleep_stage` row — the DDL's stage
- *     enum (1=awake, 2=light, 3=deep, 5=rem) has no code for it. Unknown
- *     block types are likewise skipped; nothing is lost, because...
- *   - Raw: every input row is preserved in `sleep_raw` regardless of the
- *     primary/confidence filter, flattened onto the DDL's columns, so
- *     downstream reprocessing can revisit sessions with new heuristics.
+ *   - `mapSleepRaw`, at ingest: every raw firmware sample → `sleep_raw`,
+ *     verbatim. `quality` stays the FIRMWARE code (1 deep / 2 light / 3 rem /
+ *     5 awake, other codes kept). Nothing is classified here — `sleep_raw` is
+ *     the reprocessing source the correction pipeline reads.
+ *   - `sessionsFromCorrected`, after the batch flushes: one night's Phase 3
+ *     output from `../sleep-correction` → `sleep_session` + `sleep_stage`.
  *
- * Principle 20 boundary: firmware `block_type` strings are translated to our
- * integer codes here and never reach the warehouse.
+ * Until 0.24.0 the mapper built sessions straight from app-classified blocks
+ * (`sleep_processed`) — an admission filter on `primary`, a per-block `end`
+ * read as the session end, and a guessed stage map. All three were wrong on
+ * device (zivaone_app#77, and the stage swap found 2026-09-10). Sessions now
+ * come only from the validated correction pipeline.
+ *
+ * Principle 20: the firmware `quality` code is translated to the DDL's
+ * `stage` code here, and nowhere else. The two enums share integers and mean
+ * different things — `FIRMWARE_QUALITY_TO_STAGE` is the one crossing point.
  */
-import type { FirmwareSleepRow, MapperContext, SleepRawRow, SleepSessionRow, SleepStageRow } from './types';
+import type { ClassifiedRow } from '../sleep-correction/classify';
+import type { FirmwareSleepRawRow, MapperContext, SleepRawRow, SleepSessionRow, SleepStageRow } from './types';
 /**
- * Block width in minutes when the firmware revision omits `unit_length`.
- * Firmware doc §Sleep processing: blocks are 1-min wide by convention.
- */
-export declare const DEFAULT_BLOCK_MINUTES = 1;
-/**
- * Firmware `block_type` → `sleep_stage.stage` code (spec §Table schema:
- * `stage SMALLINT NOT NULL -- 1=awake, 2=light, 3=deep, 5=rem`).
- *
- * `primary` is deliberately absent: it marks the session envelope, not a
- * sleep stage. The enum is intentionally sparse (no 4) to match the DDL
- * comment verbatim.
+ * `sleep_stage.stage` codes (DDL: `1=awake, 2=light, 3=deep, 5=rem`). Sparse
+ * on purpose (no 4) to match the DDL comment verbatim.
  */
 export declare const SLEEP_STAGE_CODES: Readonly<Record<string, number>>;
 /** Reverse lookup for the stage-minute accumulator + diagnostics. */
 export declare const SLEEP_STAGE_NAMES: Readonly<Record<number, string>>;
-export interface ReconstructSleepResult {
+/**
+ * Firmware `quality` → DDL `stage`. The firmware says 1 deep / 2 light /
+ * 3 rem / 5 awake (ziva_app v3.1; the vendor header is silent); the DDL says
+ * 1 awake / 2 light / 3 deep / 5 rem. Copying a predicate across the two
+ * computes deep from awake with no error — this map is the only translation.
+ */
+export declare const FIRMWARE_QUALITY_TO_STAGE: Readonly<Record<number, number>>;
+/** Raw firmware samples → `sleep_raw`, verbatim. */
+export declare function mapSleepRaw(rows: readonly FirmwareSleepRawRow[], ctx: MapperContext): SleepRawRow[];
+export interface SessionsFromCorrectedResult {
     sleep_session: SleepSessionRow[];
     sleep_stage: SleepStageRow[];
-    sleep_raw: SleepRawRow[];
 }
-export declare function reconstructSleepSessions(rows: readonly FirmwareSleepRow[], ctx: MapperContext): ReconstructSleepResult;
+/**
+ * One night's corrected rows → sessions + stages.
+ *
+ * - Only `block_type === 'primary'` rows count (R-A: every primary minute,
+ *   whatever its confidence — confidence is provenance, never a gate).
+ * - Sessions are Phase 2's stitched sessions, identified by `start`. A night
+ *   is normally one; a gap between 20 and 30 minutes inside the primary
+ *   block leaves two.
+ * - `ts_end` is the last primary minute plus its width; `total_minutes` is
+ *   the primary minutes actually present (awake minutes included).
+ * - `settle_min` belongs to the night, measured from bed, so it goes on the
+ *   session that starts at bed — the first. `recovered_min` is per session.
+ * - `session_id` is principle 25's deterministic hash; the caller replaces
+ *   the whole night before writing (principle 66 as amended), because a
+ *   corrected END moves as later data arrives and the id moves with it.
+ */
+export declare function sessionsFromCorrected(rows: readonly ClassifiedRow[], ctx: MapperContext, night?: {
+    settleMin?: number | null;
+}): SessionsFromCorrectedResult;
 /**
  * Session id (principle 25, as amended 2026-08-14):
  *   `fnv1a32hex(device_id | user_id | ts_session_start | ts_session_end)`

package/dist/sync/mapper/sleep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../src/sync/mapper/sleep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,eAAe,EACf,aAAa,EACd,MAAM,SAAS,CAAA;AAOhB;;;GAGG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK7D,CAAA;AAEF,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK7D,CAAA;AAEF,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,eAAe,EAAE,CAAA;IAChC,WAAW,EAAE,aAAa,EAAE,CAAA;IAC5B,SAAS,EAAE,WAAW,EAAE,CAAA;CACzB;AAoBD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,SAAS,gBAAgB,EAAE,EACjC,GAAG,EAAE,aAAa,GACjB,sBAAsB,CAkGxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,aAAa,EAClB,cAAc,EAAE,IAAI,EACpB,YAAY,EAAE,IAAI,GACjB,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOhD"}
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../src/sync/mapper/sleep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACb,WAAW,EACX,eAAe,EACf,aAAa,EACd,MAAM,SAAS,CAAA;AAIhB;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK7D,CAAA;AAEF,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK7D,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAKrE,CAAA;AAEF,oDAAoD;AACpD,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,mBAAmB,EAAE,EAAE,GAAG,EAAE,aAAa,GAAG,WAAW,EAAE,CAWnG;AAED,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,eAAe,EAAE,CAAA;IAChC,WAAW,EAAE,aAAa,EAAE,CAAA;CAC7B;AAKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,SAAS,aAAa,EAAE,EAC9B,GAAG,EAAE,aAAa,EAClB,KAAK,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GACxC,2BAA2B,CAkE7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,aAAa,EAClB,cAAc,EAAE,IAAI,EACpB,YAAY,EAAE,IAAI,GACjB,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOhD"}

package/dist/sync/mapper/sleep.js

@@ -1,52 +1,30 @@
 /**
- * Sleep reconstruction mapper (T-06).
+ * Sleep mapping (sleep-correction §3).
  *
- * Firmware `sleep_processed` emits per-block rows tagged with a `start`
- * (session start), `end` (session end), `block_type` (primary / light / deep /
- * rem / awake), `confidence` (0..1), and per-block `timestamp` (block instant).
- * Multiple blocks share the same `start` when they belong to the same session.
+ * Two halves that run at different times:
  *
- * Reconstruction rules (spec.md §Firmware mapper + tasks.md T-06):
- *   - Group rows by `start`.
- *   - A session is included if AT LEAST ONE block in the group has
- *     `block_type === 'primary'` AND `confidence >= 0.7`. This filters
- *     day-time naps and low-confidence noise.
- *   - Session boundaries come from the firmware's own envelope fields:
- *     `ts_start = parse(start)`, `ts_end = parse(end)`. `total_minutes` is
- *     their difference. Deriving the envelope from block instants would
- *     under-report any session whose first/last minutes went unclassified.
- *   - `session_id` = `fnv1a32hex(device_id | user_id | ts_session_start |
- *     ts_session_end)` (principle 25, amended 2026-08-14) — fully
- *     deterministic, so the same night mapped twice yields the same id.
- *   - `night_of` = 6pm-6pm rule applied to `ts_start` (see `time.ts`).
- *   - Stages: one row per classified block, carrying `session_id` and the
- *     DDL's integer `stage` code. `primary` is the session envelope marker,
- *     not a stage, so it produces no `sleep_stage` row — the DDL's stage
- *     enum (1=awake, 2=light, 3=deep, 5=rem) has no code for it. Unknown
- *     block types are likewise skipped; nothing is lost, because...
- *   - Raw: every input row is preserved in `sleep_raw` regardless of the
- *     primary/confidence filter, flattened onto the DDL's columns, so
- *     downstream reprocessing can revisit sessions with new heuristics.
+ *   - `mapSleepRaw`, at ingest: every raw firmware sample → `sleep_raw`,
+ *     verbatim. `quality` stays the FIRMWARE code (1 deep / 2 light / 3 rem /
+ *     5 awake, other codes kept). Nothing is classified here — `sleep_raw` is
+ *     the reprocessing source the correction pipeline reads.
+ *   - `sessionsFromCorrected`, after the batch flushes: one night's Phase 3
+ *     output from `../sleep-correction` → `sleep_session` + `sleep_stage`.
  *
- * Principle 20 boundary: firmware `block_type` strings are translated to our
- * integer codes here and never reach the warehouse.
+ * Until 0.24.0 the mapper built sessions straight from app-classified blocks
+ * (`sleep_processed`) — an admission filter on `primary`, a per-block `end`
+ * read as the session end, and a guessed stage map. All three were wrong on
+ * device (zivaone_app#77, and the stage swap found 2026-09-10). Sessions now
+ * come only from the validated correction pipeline.
+ *
+ * Principle 20: the firmware `quality` code is translated to the DDL's
+ * `stage` code here, and nowhere else. The two enums share integers and mean
+ * different things — `FIRMWARE_QUALITY_TO_STAGE` is the one crossing point.
  */
+import { parseDateStr } from '../sleep-correction/classify';
 import { computeNightOf, parseTimestamp } from './time';
-const MINUTE_MS = 60000;
-const PRIMARY = 'primary';
-const CONFIDENCE_FLOOR = 0.7;
-/**
- * Block width in minutes when the firmware revision omits `unit_length`.
- * Firmware doc §Sleep processing: blocks are 1-min wide by convention.
- */
-export const DEFAULT_BLOCK_MINUTES = 1;
 /**
- * Firmware `block_type` → `sleep_stage.stage` code (spec §Table schema:
- * `stage SMALLINT NOT NULL -- 1=awake, 2=light, 3=deep, 5=rem`).
- *
- * `primary` is deliberately absent: it marks the session envelope, not a
- * sleep stage. The enum is intentionally sparse (no 4) to match the DDL
- * comment verbatim.
+ * `sleep_stage.stage` codes (DDL: `1=awake, 2=light, 3=deep, 5=rem`). Sparse
+ * on purpose (no 4) to match the DDL comment verbatim.
  */
 export const SLEEP_STAGE_CODES = Object.freeze({
     awake: 1,
@@ -61,88 +39,89 @@ export const SLEEP_STAGE_NAMES = Object.freeze({
     3: 'deep',
     5: 'rem',
 });
-/** Per-block width, honouring a firmware-supplied `unit_length`. */
-function blockMinutes(row) {
-    return typeof row.unit_length === 'number' && row.unit_length > 0
-        ? row.unit_length
-        : DEFAULT_BLOCK_MINUTES;
-}
 /**
- * `sleep_raw.quality` is NOT NULL. Firmware revisions that carry a native
- * `quality` pass it through verbatim; older revisions derive it from the
- * block confidence (0..1 → 0..100) so the column is always populated.
+ * Firmware `quality` → DDL `stage`. The firmware says 1 deep / 2 light /
+ * 3 rem / 5 awake (ziva_app v3.1; the vendor header is silent); the DDL says
+ * 1 awake / 2 light / 3 deep / 5 rem. Copying a predicate across the two
+ * computes deep from awake with no error — this map is the only translation.
  */
-function rawQuality(row) {
-    return typeof row.quality === 'number'
-        ? row.quality
-        : Math.round(row.confidence * 100);
+export const FIRMWARE_QUALITY_TO_STAGE = Object.freeze({
+    1: SLEEP_STAGE_CODES.deep,
+    2: SLEEP_STAGE_CODES.light,
+    3: SLEEP_STAGE_CODES.rem,
+    5: SLEEP_STAGE_CODES.awake,
+});
+/** Raw firmware samples → `sleep_raw`, verbatim. */
+export function mapSleepRaw(rows, ctx) {
+    return rows.map(r => ({
+        ts: parseTimestamp(r.timestamp),
+        ts_session_start: parseTimestamp(r.start),
+        brand: ctx.brand,
+        family_id: ctx.familyId,
+        user_id: ctx.userId,
+        device_id: ctx.deviceId,
+        quality: r.quality,
+        unit_length: typeof r.unitLength === 'number' ? r.unitLength : null,
+    }));
 }
-export function reconstructSleepSessions(rows, ctx) {
-    const sleep_session = [];
-    const sleep_stage = [];
-    const sleep_raw = [];
-    // Raw pass — every input row preserved for reprocessing, including rows
-    // from sessions the primary/confidence filter drops.
-    for (const row of rows) {
-        sleep_raw.push({
-            ts: parseTimestamp(row.timestamp),
-            ts_session_start: parseTimestamp(row.start),
-            brand: ctx.brand,
-            family_id: ctx.familyId,
-            user_id: ctx.userId,
-            device_id: ctx.deviceId,
-            quality: rawQuality(row),
-            unit_length: typeof row.unit_length === 'number' ? row.unit_length : null,
-        });
-    }
-    // Group by `start`.
+/** Width of one Phase 2/3 row. v3.1 emits every row at `unitLength` 1. */
+const ROW_SECONDS = 60;
+/**
+ * One night's corrected rows → sessions + stages.
+ *
+ * - Only `block_type === 'primary'` rows count (R-A: every primary minute,
+ *   whatever its confidence — confidence is provenance, never a gate).
+ * - Sessions are Phase 2's stitched sessions, identified by `start`. A night
+ *   is normally one; a gap between 20 and 30 minutes inside the primary
+ *   block leaves two.
+ * - `ts_end` is the last primary minute plus its width; `total_minutes` is
+ *   the primary minutes actually present (awake minutes included).
+ * - `settle_min` belongs to the night, measured from bed, so it goes on the
+ *   session that starts at bed — the first. `recovered_min` is per session.
+ * - `session_id` is principle 25's deterministic hash; the caller replaces
+ *   the whole night before writing (principle 66 as amended), because a
+ *   corrected END moves as later data arrives and the id moves with it.
+ */
+export function sessionsFromCorrected(rows, ctx, night = {}) {
     const bySession = new Map();
-    for (const row of rows) {
-        const bucket = bySession.get(row.start);
+    for (const r of rows) {
+        if (r.block_type !== 'primary')
+            continue;
+        const bucket = bySession.get(r.start);
         if (bucket)
-            bucket.push(row);
+            bucket.push(r);
         else
-            bySession.set(row.start, [row]);
+            bySession.set(r.start, [r]);
     }
-    for (const [startKey, blocks] of bySession) {
-        // Session must contain a primary block above the confidence floor to be
-        // counted as a real sleep session (as opposed to a nap or noise).
-        const hasQualifyingPrimary = blocks.some(b => b.block_type === PRIMARY && b.confidence >= CONFIDENCE_FLOOR);
-        if (!hasQualifyingPrimary)
-            continue;
-        // Envelope from the firmware's own session fields. `end` is exclusive of
-        // nothing — it is the session end instant, so total is a plain delta.
-        const tsStart = parseTimestamp(startKey);
-        const tsEnd = parseTimestamp(blocks[0].end);
-        const totalMinutes = Math.max(0, Math.round((tsEnd.getTime() - tsStart.getTime()) / MINUTE_MS));
-        const nightOf = computeNightOf(tsStart, ctx.userTimezone);
+    const groups = Array.from(bySession.values(), g => g.map(r => ({ r, e: parseDateStr(r.date) })).sort((a, b) => a.e - b.e))
+        .sort((a, b) => a[0].e - b[0].e);
+    const sleep_session = [];
+    const sleep_stage = [];
+    groups.forEach((group, index) => {
+        const tsStart = new Date(group[0].e * 1000);
+        const tsEnd = new Date((group[group.length - 1].e + ROW_SECONDS) * 1000);
         const sessionId = makeSessionId(ctx, tsStart, tsEnd);
-        // Stage rows + per-stage minute accumulation in one pass.
-        const stageMinutes = {
-            awake: 0,
-            light: 0,
-            deep: 0,
-            rem: 0,
-        };
+        const minutes = { awake: 0, light: 0, deep: 0, rem: 0 };
         let confidenceSum = 0;
-        for (const b of blocks) {
-            confidenceSum += b.confidence;
-            const code = SLEEP_STAGE_CODES[b.block_type];
-            if (code === undefined) {
-                // `primary` (envelope marker) and any unrecognised firmware block
-                // type. Not a stage — preserved in sleep_raw, skipped here.
-                continue;
-            }
-            stageMinutes[SLEEP_STAGE_NAMES[code]] += blockMinutes(b);
+        let recovered = 0;
+        for (const { r, e } of group) {
+            confidenceSum += r.confidence;
+            if (r.source === 'envelope' || r.source === 'gap')
+                recovered++;
+            const stage = FIRMWARE_QUALITY_TO_STAGE[r.quality];
+            if (stage === undefined)
+                continue; // a code the pipeline passed but the DDL has no stage for
+            minutes[SLEEP_STAGE_NAMES[stage]]++;
             sleep_stage.push({
-                ts: parseTimestamp(b.timestamp),
+                ts: new Date(e * 1000),
                 brand: ctx.brand,
                 family_id: ctx.familyId,
                 user_id: ctx.userId,
                 device_id: ctx.deviceId,
                 session_id: sessionId,
-                stage: code,
-                confidence: b.confidence,
+                stage,
+                confidence: r.confidence,
+                source: r.source,
             });
         }
         sleep_session.push({
@@ -153,16 +132,18 @@ export function reconstructSleepSessions(rows, ctx) {
             session_id: sessionId,
             ts_start: tsStart,
             ts_end: tsEnd,
-            total_minutes: totalMinutes,
-            deep_minutes: stageMinutes.deep,
-            rem_minutes: stageMinutes.rem,
-            light_minutes: stageMinutes.light,
-            awake_minutes: stageMinutes.awake,
-            avg_confidence: blocks.length > 0 ? confidenceSum / blocks.length : null,
-            night_of: nightOf,
+            total_minutes: group.length,
+            deep_minutes: minutes.deep,
+            rem_minutes: minutes.rem,
+            light_minutes: minutes.light,
+            awake_minutes: minutes.awake,
+            avg_confidence: confidenceSum / group.length,
+            night_of: computeNightOf(tsStart, ctx.userTimezone),
+            settle_min: index === 0 ? (night.settleMin ?? null) : null,
+            recovered_min: recovered,
         });
-    }
-    return { sleep_session, sleep_stage, sleep_raw };
+    });
+    return { sleep_session, sleep_stage };
 }
 /**
  * Session id (principle 25, as amended 2026-08-14):