@mongrov/analytics 0.6.0 → 0.7.0

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

@@ -0,0 +1,411 @@
+/**
+ * Zod contract for the firmware export payload (principle 60 — firmware
+ * fixture governance).
+ *
+ * Models `FirmwareExport` from `./types.ts` EXACTLY, with `.strict()` on
+ * every object so unknown keys fail parsing. This is the CI gate: when the
+ * firmware team lands a new versioned fixture, any key the mapper doesn't
+ * know about surfaces as a test failure — a PR-blocking event that forces a
+ * deliberate schema + mapper update instead of a silent drop.
+ *
+ * `FIRMWARE_EXPORT_KEY_PATHS` is the same contract expressed as a key-path
+ * set (`heartrate`, `heartrate[].timestamp`, ...) for the fixture key-diff
+ * test in `__tests__/schema.test.ts`. Keep both in lockstep with
+ * `FirmwareExport` — the key-diff test asserts the fixture corpus exercises
+ * exactly this set.
+ */
+import { z } from 'zod';
+export declare const firmwareHRRowSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    singleHR: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    timestamp: string;
+    singleHR: number;
+}, {
+    timestamp: string;
+    singleHR: number;
+}>;
+export declare const firmwareHRVRowSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    hrv: z.ZodOptional<z.ZodNumber>;
+    stress: z.ZodOptional<z.ZodNumber>;
+    heartRate: z.ZodOptional<z.ZodNumber>;
+    systolicBP: z.ZodOptional<z.ZodNumber>;
+    diastolicBP: z.ZodOptional<z.ZodNumber>;
+    vascularAging: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    timestamp: string;
+    hrv?: number | undefined;
+    stress?: number | undefined;
+    heartRate?: number | undefined;
+    systolicBP?: number | undefined;
+    diastolicBP?: number | undefined;
+    vascularAging?: number | undefined;
+}, {
+    timestamp: string;
+    hrv?: number | undefined;
+    stress?: number | undefined;
+    heartRate?: number | undefined;
+    systolicBP?: number | undefined;
+    diastolicBP?: number | undefined;
+    vascularAging?: number | undefined;
+}>;
+export declare const firmwareSpO2RowSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    automaticSpo2Data: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    timestamp: string;
+    automaticSpo2Data: number;
+}, {
+    timestamp: string;
+    automaticSpo2Data: number;
+}>;
+export declare const firmwareTempRowSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    temperature: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    temperature: number;
+    timestamp: string;
+}, {
+    temperature: number;
+    timestamp: string;
+}>;
+export declare const firmwareActivityRowSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    step: z.ZodNumber;
+    calories: z.ZodNumber;
+    distance: z.ZodNumber;
+    arraySteps: z.ZodArray<z.ZodNumber, "many">;
+}, "strict", z.ZodTypeAny, {
+    calories: number;
+    timestamp: string;
+    step: number;
+    distance: number;
+    arraySteps: number[];
+}, {
+    calories: number;
+    timestamp: string;
+    step: number;
+    distance: number;
+    arraySteps: number[];
+}>;
+export declare const firmwareSleepRowSchema: z.ZodObject<{
+    start: z.ZodString;
+    end: z.ZodString;
+    block_type: z.ZodString;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    start: string;
+    timestamp: string;
+    end: string;
+    block_type: string;
+    confidence: number;
+}, {
+    start: string;
+    timestamp: string;
+    end: string;
+    block_type: string;
+    confidence: number;
+}>;
+export declare const firmwareBatteryRowSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    battery: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    timestamp: string;
+    battery: number;
+}, {
+    timestamp: string;
+    battery: number;
+}>;
+export declare const firmwareMonitoringWindowSchema: z.ZodObject<{
+    metric: z.ZodString;
+    interval_minutes: z.ZodNumber;
+    start_hour: z.ZodNumber;
+    end_hour: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    metric: string;
+    interval_minutes: number;
+    start_hour: number;
+    end_hour: number;
+}, {
+    metric: string;
+    interval_minutes: number;
+    start_hour: number;
+    end_hour: number;
+}>;
+export declare const firmwareRingConfigSchema: z.ZodObject<{
+    automaticMonitoringData: z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        interval_minutes: z.ZodNumber;
+        start_hour: z.ZodNumber;
+        end_hour: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        metric: string;
+        interval_minutes: number;
+        start_hour: number;
+        end_hour: number;
+    }, {
+        metric: string;
+        interval_minutes: number;
+        start_hour: number;
+        end_hour: number;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    automaticMonitoringData: {
+        metric: string;
+        interval_minutes: number;
+        start_hour: number;
+        end_hour: number;
+    }[];
+}, {
+    automaticMonitoringData: {
+        metric: string;
+        interval_minutes: number;
+        start_hour: number;
+        end_hour: number;
+    }[];
+}>;
+export declare const firmwareExportSchema: z.ZodObject<{
+    $comment: z.ZodOptional<z.ZodString>;
+    heartrate: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        singleHR: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        timestamp: string;
+        singleHR: number;
+    }, {
+        timestamp: string;
+        singleHR: number;
+    }>, "many">;
+    hrv_table: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        hrv: z.ZodOptional<z.ZodNumber>;
+        stress: z.ZodOptional<z.ZodNumber>;
+        heartRate: z.ZodOptional<z.ZodNumber>;
+        systolicBP: z.ZodOptional<z.ZodNumber>;
+        diastolicBP: z.ZodOptional<z.ZodNumber>;
+        vascularAging: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        timestamp: string;
+        hrv?: number | undefined;
+        stress?: number | undefined;
+        heartRate?: number | undefined;
+        systolicBP?: number | undefined;
+        diastolicBP?: number | undefined;
+        vascularAging?: number | undefined;
+    }, {
+        timestamp: string;
+        hrv?: number | undefined;
+        stress?: number | undefined;
+        heartRate?: number | undefined;
+        systolicBP?: number | undefined;
+        diastolicBP?: number | undefined;
+        vascularAging?: number | undefined;
+    }>, "many">;
+    spo2: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        automaticSpo2Data: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        timestamp: string;
+        automaticSpo2Data: number;
+    }, {
+        timestamp: string;
+        automaticSpo2Data: number;
+    }>, "many">;
+    temperature_table: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        temperature: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        temperature: number;
+        timestamp: string;
+    }, {
+        temperature: number;
+        timestamp: string;
+    }>, "many">;
+    activitydetails: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        step: z.ZodNumber;
+        calories: z.ZodNumber;
+        distance: z.ZodNumber;
+        arraySteps: z.ZodArray<z.ZodNumber, "many">;
+    }, "strict", z.ZodTypeAny, {
+        calories: number;
+        timestamp: string;
+        step: number;
+        distance: number;
+        arraySteps: number[];
+    }, {
+        calories: number;
+        timestamp: string;
+        step: number;
+        distance: number;
+        arraySteps: number[];
+    }>, "many">;
+    sleep_processed: z.ZodArray<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+        block_type: z.ZodString;
+        confidence: z.ZodNumber;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        start: string;
+        timestamp: string;
+        end: string;
+        block_type: string;
+        confidence: number;
+    }, {
+        start: string;
+        timestamp: string;
+        end: string;
+        block_type: string;
+        confidence: number;
+    }>, "many">;
+    battery_table: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        battery: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        timestamp: string;
+        battery: number;
+    }, {
+        timestamp: string;
+        battery: number;
+    }>, "many">;
+    ring: z.ZodObject<{
+        automaticMonitoringData: z.ZodArray<z.ZodObject<{
+            metric: z.ZodString;
+            interval_minutes: z.ZodNumber;
+            start_hour: z.ZodNumber;
+            end_hour: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            metric: string;
+            interval_minutes: number;
+            start_hour: number;
+            end_hour: number;
+        }, {
+            metric: string;
+            interval_minutes: number;
+            start_hour: number;
+            end_hour: number;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        automaticMonitoringData: {
+            metric: string;
+            interval_minutes: number;
+            start_hour: number;
+            end_hour: number;
+        }[];
+    }, {
+        automaticMonitoringData: {
+            metric: string;
+            interval_minutes: number;
+            start_hour: number;
+            end_hour: number;
+        }[];
+    }>;
+}, "strict", z.ZodTypeAny, {
+    spo2: {
+        timestamp: string;
+        automaticSpo2Data: number;
+    }[];
+    heartrate: {
+        timestamp: string;
+        singleHR: number;
+    }[];
+    hrv_table: {
+        timestamp: string;
+        hrv?: number | undefined;
+        stress?: number | undefined;
+        heartRate?: number | undefined;
+        systolicBP?: number | undefined;
+        diastolicBP?: number | undefined;
+        vascularAging?: number | undefined;
+    }[];
+    temperature_table: {
+        temperature: number;
+        timestamp: string;
+    }[];
+    activitydetails: {
+        calories: number;
+        timestamp: string;
+        step: number;
+        distance: number;
+        arraySteps: number[];
+    }[];
+    sleep_processed: {
+        start: string;
+        timestamp: string;
+        end: string;
+        block_type: string;
+        confidence: number;
+    }[];
+    battery_table: {
+        timestamp: string;
+        battery: number;
+    }[];
+    ring: {
+        automaticMonitoringData: {
+            metric: string;
+            interval_minutes: number;
+            start_hour: number;
+            end_hour: number;
+        }[];
+    };
+    $comment?: string | undefined;
+}, {
+    spo2: {
+        timestamp: string;
+        automaticSpo2Data: number;
+    }[];
+    heartrate: {
+        timestamp: string;
+        singleHR: number;
+    }[];
+    hrv_table: {
+        timestamp: string;
+        hrv?: number | undefined;
+        stress?: number | undefined;
+        heartRate?: number | undefined;
+        systolicBP?: number | undefined;
+        diastolicBP?: number | undefined;
+        vascularAging?: number | undefined;
+    }[];
+    temperature_table: {
+        temperature: number;
+        timestamp: string;
+    }[];
+    activitydetails: {
+        calories: number;
+        timestamp: string;
+        step: number;
+        distance: number;
+        arraySteps: number[];
+    }[];
+    sleep_processed: {
+        start: string;
+        timestamp: string;
+        end: string;
+        block_type: string;
+        confidence: number;
+    }[];
+    battery_table: {
+        timestamp: string;
+        battery: number;
+    }[];
+    ring: {
+        automaticMonitoringData: {
+            metric: string;
+            interval_minutes: number;
+            start_hour: number;
+            end_hour: number;
+        }[];
+    };
+    $comment?: string | undefined;
+}>;
+export type FirmwareExportParsed = z.infer<typeof firmwareExportSchema>;
+/**
+ * Every key-path the schema knows about. Array elements are flattened as
+ * `section[].key`. Used by the fixture key-diff test (principle 60).
+ */
+export declare const FIRMWARE_EXPORT_KEY_PATHS: ReadonlySet<string>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/sync/mapper/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,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,8BAA8B;;;;;;;;;;;;;;;EAKhC,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,CAwCxD,CAAA"}

package/dist/sync/mapper/schema.js

@@ -0,0 +1,128 @@
+/**
+ * Zod contract for the firmware export payload (principle 60 — firmware
+ * fixture governance).
+ *
+ * Models `FirmwareExport` from `./types.ts` EXACTLY, with `.strict()` on
+ * every object so unknown keys fail parsing. This is the CI gate: when the
+ * firmware team lands a new versioned fixture, any key the mapper doesn't
+ * know about surfaces as a test failure — a PR-blocking event that forces a
+ * deliberate schema + mapper update instead of a silent drop.
+ *
+ * `FIRMWARE_EXPORT_KEY_PATHS` is the same contract expressed as a key-path
+ * set (`heartrate`, `heartrate[].timestamp`, ...) for the fixture key-diff
+ * test in `__tests__/schema.test.ts`. Keep both in lockstep with
+ * `FirmwareExport` — the key-diff test asserts the fixture corpus exercises
+ * exactly this set.
+ */
+import { z } from 'zod';
+/** Firmware timestamp: `"YYYY.MM.DD HH:MM:SS"` UTC wall-clock (see time.ts). */
+const firmwareTimestamp = z.string().regex(/^\d{4}\.\d{1,2}\.\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}$/, 'expected firmware "YYYY.MM.DD HH:MM:SS" timestamp');
+export const firmwareHRRowSchema = z.object({
+    timestamp: firmwareTimestamp,
+    singleHR: z.number(),
+}).strict();
+export const firmwareHRVRowSchema = z.object({
+    timestamp: firmwareTimestamp,
+    hrv: z.number().optional(),
+    stress: z.number().optional(),
+    heartRate: z.number().optional(),
+    systolicBP: z.number().optional(),
+    diastolicBP: z.number().optional(),
+    vascularAging: z.number().optional(),
+}).strict();
+export const firmwareSpO2RowSchema = z.object({
+    timestamp: firmwareTimestamp,
+    automaticSpo2Data: z.number(),
+}).strict();
+export const firmwareTempRowSchema = z.object({
+    timestamp: firmwareTimestamp,
+    temperature: z.number(),
+}).strict();
+export const firmwareActivityRowSchema = z.object({
+    timestamp: firmwareTimestamp,
+    step: z.number(),
+    calories: z.number(),
+    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(),
+    timestamp: firmwareTimestamp,
+}).strict();
+export const firmwareBatteryRowSchema = z.object({
+    timestamp: firmwareTimestamp,
+    battery: z.number(),
+}).strict();
+export const firmwareMonitoringWindowSchema = z.object({
+    metric: z.string(),
+    interval_minutes: z.number(),
+    start_hour: z.number(),
+    end_hour: z.number(),
+}).strict();
+export const firmwareRingConfigSchema = z.object({
+    automaticMonitoringData: z.array(firmwareMonitoringWindowSchema),
+}).strict();
+export const firmwareExportSchema = z.object({
+    // Fixture files carry a human-readable `$comment`; real device exports
+    // may omit it. Not part of `FirmwareExport` — stripped before mapping.
+    $comment: z.string().optional(),
+    heartrate: z.array(firmwareHRRowSchema),
+    hrv_table: z.array(firmwareHRVRowSchema),
+    spo2: z.array(firmwareSpO2RowSchema),
+    temperature_table: z.array(firmwareTempRowSchema),
+    activitydetails: z.array(firmwareActivityRowSchema),
+    sleep_processed: z.array(firmwareSleepRowSchema),
+    battery_table: z.array(firmwareBatteryRowSchema),
+    ring: firmwareRingConfigSchema,
+}).strict();
+const _assertParsedMatchesType = true;
+void _assertParsedMatchesType;
+/**
+ * Every key-path the schema knows about. Array elements are flattened as
+ * `section[].key`. Used by the fixture key-diff test (principle 60).
+ */
+export const FIRMWARE_EXPORT_KEY_PATHS = new Set([
+    '$comment',
+    'heartrate',
+    'heartrate[].timestamp',
+    'heartrate[].singleHR',
+    'hrv_table',
+    'hrv_table[].timestamp',
+    'hrv_table[].hrv',
+    'hrv_table[].stress',
+    'hrv_table[].heartRate',
+    'hrv_table[].systolicBP',
+    'hrv_table[].diastolicBP',
+    'hrv_table[].vascularAging',
+    'spo2',
+    'spo2[].timestamp',
+    'spo2[].automaticSpo2Data',
+    'temperature_table',
+    'temperature_table[].timestamp',
+    'temperature_table[].temperature',
+    'activitydetails',
+    'activitydetails[].timestamp',
+    'activitydetails[].step',
+    'activitydetails[].calories',
+    'activitydetails[].distance',
+    'activitydetails[].arraySteps',
+    'sleep_processed',
+    'sleep_processed[].start',
+    'sleep_processed[].end',
+    'sleep_processed[].block_type',
+    'sleep_processed[].confidence',
+    'sleep_processed[].timestamp',
+    'battery_table',
+    'battery_table[].timestamp',
+    'battery_table[].battery',
+    'ring',
+    'ring.automaticMonitoringData',
+    'ring.automaticMonitoringData[].metric',
+    'ring.automaticMonitoringData[].interval_minutes',
+    'ring.automaticMonitoringData[].start_hour',
+    'ring.automaticMonitoringData[].end_hour',
+]);
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/sync/mapper/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,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,8BAA8B,GAAG,CAAC,CAAC,MAAM,CAAC;IACrD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE;IAC5B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;CACrB,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,uCAAuC;IACvC,iDAAiD;IACjD,2CAA2C;IAC3C,yCAAyC;CAC1C,CAAC,CAAA"}

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

@@ -2,31 +2,76 @@
  * Sleep reconstruction mapper (T-06).
  *
  * Firmware `sleep_processed` emits per-block rows tagged with a `start`
- * (session start), `end`, `block_type` (primary / light / deep / rem / ...),
- * `confidence` (0..1), and per-block `timestamp` (block instant). Multiple
- * blocks share the same `start` when they belong to the same sleep session.
+ * (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.
  *
  * 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: `start_ts` = earliest block ts in the group;
- *     `end_ts` = latest block ts + 1 minute (block ts marks start of the
- *     1-min block).
- *   - `session_id` = stable hash of `user_id + start_ts.toISOString()`.
- *   - `night_of` = 6pm-6pm rule applied to `start_ts` (see `time.ts`).
- *   - Stages: one row per firmware block that passed the primary+confidence
- *     filter, carrying `session_id`, `block_type`, and `confidence`.
- *   - Raw: every input row is preserved verbatim in `sleep_raw` (payload
- *     column) regardless of the primary/confidence filter, so downstream
- *     reprocessing can revisit sessions with new heuristics.
+ *   - 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` = `nanoid(24) + '_' + fnv1a32hex(device_id | user_id |
+ *     ts_session_start)` (principle 25, locked) — collision-safe even with
+ *     corrupted timestamps.
+ *   - `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.
+ *
+ * Principle 20 boundary: firmware `block_type` strings are translated to our
+ * integer codes here and never reach the warehouse.
  */
 import type { FirmwareSleepRow, 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.
+ */
+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 {
     sleep_session: SleepSessionRow[];
     sleep_stage: SleepStageRow[];
     sleep_raw: SleepRawRow[];
 }
 export declare function reconstructSleepSessions(rows: readonly FirmwareSleepRow[], ctx: MapperContext): ReconstructSleepResult;
+/**
+ * Session id components (principle 25, locked):
+ *   `nanoid(24) + '_' + fnv1a32hex(device_id | user_id | ts_session_start)`
+ *
+ * The random prefix makes ids collision-safe even when the firmware emits
+ * corrupted/duplicated timestamps; the hash suffix is deterministic over the
+ * identifying tuple so ids remain diagnosable (same device+user+start ⇒
+ * same suffix). The random source is injectable via `ctx.idGenerator` to
+ * keep the mapper testable — the suffix is always deterministic.
+ */
+export declare function sessionIdComponents(ctx: MapperContext, tsSessionStart: Date): {
+    random: string;
+    hash: string;
+};
+/**
+ * FNV-1a 32-bit, hex-encoded (8 lowercase hex chars). Implemented inline —
+ * a dependency for 10 lines of arithmetic is not worth the supply-chain
+ * surface, and the mapper only needs a stable non-cryptographic digest.
+ */
+export declare function fnv1a32hex(input: string): string;
 //# sourceMappingURL=sleep.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,eAAe,EACf,aAAa,EACd,MAAM,SAAS,CAAA;AAMhB,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,eAAe,EAAE,CAAA;IAChC,WAAW,EAAE,aAAa,EAAE,CAAA;IAC5B,SAAS,EAAE,WAAW,EAAE,CAAA;CACzB;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,SAAS,gBAAgB,EAAE,EACjC,GAAG,EAAE,aAAa,GACjB,sBAAsB,CAyExB"}
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../src/sync/mapper/sleep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,eAAe,EACf,aAAa,EACd,MAAM,SAAS,CAAA;AAMhB;;;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,CAgGxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,aAAa,EAClB,cAAc,EAAE,IAAI,GACnB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAMlC;AAOD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOhD"}