@xube/kit-aws-data-schema 0.2.8 → 0.2.12

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const DATA_TYPE = "data";
 export declare const DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";
+export declare const READING_VERSION_IDENTIFIER = "v";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,SAAS,CAAC;AAEhC,eAAO,MAAM,uBAAuB,oBAAoB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,SAAS,CAAC;AAEhC,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AAEzD,eAAO,MAAM,0BAA0B,MAAM,CAAC"}

package/dist/constants.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATA_TABLE_NAME_ENV_VAR = exports.DATA_TYPE = void 0;
+exports.READING_VERSION_IDENTIFIER = exports.DATA_TABLE_NAME_ENV_VAR = exports.DATA_TYPE = void 0;
 exports.DATA_TYPE = "data";
 exports.DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";
+exports.READING_VERSION_IDENTIFIER = "v";

package/dist/decode/aggregate.d.ts

@@ -1,118 +1,34 @@
 import { z } from "zod";
 export declare const AggregateMetadataSchema: z.ZodObject<{
     v: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    v: number;
-}, {
-    v: number;
-}>;
+}, z.core.$strip>;
 export type AggregateMetadata = z.infer<typeof AggregateMetadataSchema>;
 export declare const isAggregateMetadata: (obj: unknown) => obj is AggregateMetadata;
 export declare const AggregateMetaDataV1Version: number;
-export declare const AggregateMetadataV1Schema: z.ZodObject<z.objectUtil.extendShape<{
-    v: z.ZodNumber;
-}, {
+export declare const AggregateMetadataV1Schema: z.ZodObject<{
     v: z.ZodLiteral<number>;
     s: z.ZodNumber;
     m: z.ZodArray<z.ZodObject<{
         m: z.ZodObject<{
             s: z.ZodNumber;
             us: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            s: number;
-            us: number;
-        }, {
-            s: number;
-            us: number;
-        }>;
+        }, z.core.$strip>;
         s: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }, {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }>, "many">;
-}>, "strip", z.ZodTypeAny, {
-    s: number;
-    m: {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }[];
-    v: number;
-}, {
-    s: number;
-    m: {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }[];
-    v: number;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type AggregateMetadataV1 = z.infer<typeof AggregateMetadataV1Schema>;
 export declare const isAggregateMetadataV1: (obj: unknown) => obj is AggregateMetadataV1;
-export declare const AggregateMetadataSchemas: z.ZodObject<z.objectUtil.extendShape<{
-    v: z.ZodNumber;
-}, {
+export declare const AggregateMetadataSchemas: z.ZodObject<{
     v: z.ZodLiteral<number>;
     s: z.ZodNumber;
     m: z.ZodArray<z.ZodObject<{
         m: z.ZodObject<{
             s: z.ZodNumber;
             us: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            s: number;
-            us: number;
-        }, {
-            s: number;
-            us: number;
-        }>;
+        }, z.core.$strip>;
         s: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }, {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }>, "many">;
-}>, "strip", z.ZodTypeAny, {
-    s: number;
-    m: {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }[];
-    v: number;
-}, {
-    s: number;
-    m: {
-        m: {
-            s: number;
-            us: number;
-        };
-        s?: number | undefined;
-    }[];
-    v: number;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type AggregateMetadataTypes = z.infer<typeof AggregateMetadataSchemas>;
 export declare const isAggregateMetadataTypes: (obj: unknown) => obj is AggregateMetadataTypes;
 //# sourceMappingURL=aggregate.d.ts.map

package/dist/decode/aggregate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../src/decode/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,eAAO,MAAM,uBAAuB;;;;;;EAGlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,QAAS,OAAO,KAAG,GAAG,IAAI,iBACR,CAAC;AAEnD,eAAO,MAAM,0BAA0B,EAAE,MAAU,CAAA;AACnD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInC,CAAC;AACJ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,eAAO,MAAM,qBAAqB,QAAS,OAAO,KAAG,GAAG,IAAI,mBACV,CAAC;AAEnD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACV,CAAC;AAE5B,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC9E,eAAO,MAAM,wBAAwB,QAAS,OAAO,KAAG,GAAG,IAAI,sBACf,CAAC"}
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../src/decode/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,eAAO,MAAM,uBAAuB;;iBAGlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,QAAS,OAAO,KAAG,GAAG,IAAI,iBACR,CAAC;AAEnD,eAAO,MAAM,0BAA0B,EAAE,MAAU,CAAA;AACnD,eAAO,MAAM,yBAAyB;;;;;;;;;;iBAInC,CAAC;AACJ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,eAAO,MAAM,qBAAqB,QAAS,OAAO,KAAG,GAAG,IAAI,mBACV,CAAC;AAEnD,eAAO,MAAM,wBAAwB;;;;;;;;;;iBACV,CAAC;AAE5B,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC9E,eAAO,MAAM,wBAAwB,QAAS,OAAO,KAAG,GAAG,IAAI,sBACf,CAAC"}

package/dist/decode/reading.d.ts

@@ -1,108 +1,85 @@
 import { z } from "zod";
-export declare const ReadingDataTypesSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
+export declare const READING_VERSION_1 = 1;
+export declare const READING_VERSION_2 = 2;
+export declare const DEFAULT_READING_VERSION = 1;
+export declare const ReadingDataTypesSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
 export declare const DeviceReadingMetadataV1Schema: z.ZodObject<{
     s: z.ZodNumber;
     us: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    s: number;
-    us: number;
-}, {
-    s: number;
-    us: number;
-}>;
+}, z.core.$strip>;
 export type DeviceReadingMetadataV1 = z.infer<typeof DeviceReadingMetadataV1Schema>;
 export declare const isDeviceReadingMetadataV1: (item: unknown) => item is DeviceReadingMetadataV1;
 export declare const DeviceReadingV1Schema: z.ZodObject<{
     m: z.ZodObject<{
         s: z.ZodNumber;
         us: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        s: number;
-        us: number;
-    }, {
-        s: number;
-        us: number;
-    }>;
+    }, z.core.$strip>;
     s: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    m: {
-        s: number;
-        us: number;
-    };
-    s?: number | undefined;
-}, {
-    m: {
-        s: number;
-        us: number;
-    };
-    s?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type DeviceReadingV1 = z.infer<typeof DeviceReadingV1Schema>;
 export declare const isDeviceReadingV1: (item: unknown) => item is DeviceReadingV1;
 export declare const DeviceReadingSchemas: z.ZodObject<{
     m: z.ZodObject<{
         s: z.ZodNumber;
         us: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        s: number;
-        us: number;
-    }, {
-        s: number;
-        us: number;
-    }>;
+    }, z.core.$strip>;
     s: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    m: {
-        s: number;
-        us: number;
-    };
-    s?: number | undefined;
-}, {
-    m: {
-        s: number;
-        us: number;
-    };
-    s?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type DeviceReadingTypes = z.infer<typeof DeviceReadingSchemas>;
 export declare const isDeviceReadingTypes: (item: unknown) => item is DeviceReadingTypes;
 export declare const ReadingMetadataV1Schema: z.ZodObject<{
     s: z.ZodNumber;
     us: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    s: number;
-    us: number;
-}, {
-    s: number;
-    us: number;
-}>;
+}, z.core.$strip>;
 export type ReadingMetadataV1 = z.infer<typeof ReadingMetadataV1Schema>;
 export declare const isReadingMetadataV1: (item: unknown) => item is ReadingMetadataV1;
-export declare const ReadingV1Schema: z.ZodObject<z.objectUtil.extendShape<{
-    data: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
-    component: z.ZodOptional<z.ZodString>;
-}, {
+export declare const ReadingV1Schema: z.ZodObject<{
+    type: z.ZodString;
     s: z.ZodNumber;
     us: z.ZodOptional<z.ZodNumber>;
-    type: z.ZodString;
+    data: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
     id: z.ZodString;
-}>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
-    data: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
     component: z.ZodOptional<z.ZodString>;
-}, {
-    s: z.ZodNumber;
-    us: z.ZodOptional<z.ZodNumber>;
-    type: z.ZodString;
+    v: z.ZodDefault<z.ZodLiteral<1>>;
+}, z.core.$loose>;
+export type ReadingV1 = z.infer<typeof ReadingV1Schema>;
+export declare const isReadingV1: (item: unknown) => item is ReadingV1;
+export declare const ReadingV2MetadataSchema: z.ZodObject<{
+    v: z.ZodLiteral<2>;
+    tm: z.ZodNumber;
+    bo: z.ZodOptional<z.ZodBoolean>;
+    so: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ReadingV2Metadata = z.infer<typeof ReadingV2MetadataSchema>;
+export declare const isReadingV2Metadata: (item: unknown) => item is ReadingV2Metadata;
+export declare const ReadingV2Schema: z.ZodObject<{
+    data: z.ZodUnion<readonly [z.ZodCustom<Uint8Array, Uint8Array>, z.ZodString]>;
     id: z.ZodString;
-}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
-    data: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
     component: z.ZodOptional<z.ZodString>;
-}, {
+    v: z.ZodLiteral<2>;
+    tm: z.ZodNumber;
+    bo: z.ZodOptional<z.ZodBoolean>;
+    so: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type ReadingV2 = z.infer<typeof ReadingV2Schema>;
+export declare const isReadingV2: (item: unknown) => item is ReadingV2;
+export declare const ReadingSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodString;
     s: z.ZodNumber;
     us: z.ZodOptional<z.ZodNumber>;
-    type: z.ZodString;
+    data: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
     id: z.ZodString;
-}>, z.ZodTypeAny, "passthrough">>;
-export type ReadingV1 = z.infer<typeof ReadingV1Schema>;
-export declare const isReadingV1: (item: unknown) => item is ReadingV1;
+    component: z.ZodOptional<z.ZodString>;
+    v: z.ZodDefault<z.ZodLiteral<1>>;
+}, z.core.$loose>, z.ZodObject<{
+    data: z.ZodUnion<readonly [z.ZodCustom<Uint8Array, Uint8Array>, z.ZodString]>;
+    id: z.ZodString;
+    component: z.ZodOptional<z.ZodString>;
+    v: z.ZodLiteral<2>;
+    tm: z.ZodNumber;
+    bo: z.ZodOptional<z.ZodBoolean>;
+    so: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>], "v">>;
+export type Reading = z.infer<typeof ReadingSchema>;
+export declare const isReading: (item: unknown) => item is Reading;
 //# sourceMappingURL=reading.d.ts.map

package/dist/decode/reading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reading.d.ts","sourceRoot":"","sources":["../../src/decode/reading.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB,6MAAyB,CAAC;AAE7D,eAAO,MAAM,6BAA6B;;;;;;;;;EAGxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,eAAO,MAAM,yBAAyB,SAAU,OAAO,KAAG,IAAI,IAAI,uBACX,CAAC;AAExD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,eAAO,MAAM,iBAAiB,SAAU,OAAO,KAAG,IAAI,IAAI,eACX,CAAC;AAEhD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAAwB,CAAC;AAC1D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACtE,eAAO,MAAM,oBAAoB,SAAU,OAAO,KAAG,IAAI,IAAI,kBACf,CAAC;AAE/C,eAAO,MAAM,uBAAuB;;;;;;;;;EAAgC,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,SAAU,OAAO,KAAG,IAAI,IAAI,iBACX,CAAC;AAElD,eAAO,MAAM,eAAe;;;;OA9B6B,EAAG,SAAS;QAEnE,EAAG,WAAW,CAAC,EAAE,SAAS;UAAY,EAAG,SAAS;QAEpD,EAAC,SAAS;;;;;SAJkD,SAAS;UAEhE,WAAW,GAAG,SAAS;YAAe,SAAS;UAEnD,SAAS;;;;;SAJkD,SAAS;UAEhE,WAAW,GAAG,SAAS;YAAe,SAAS;UAEnD,SAAS;iCAgCM,CAAC;AACjB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,eAAO,MAAM,WAAW,SAAU,OAAO,KAAG,IAAI,IAAI,SACX,CAAC"}
+{"version":3,"file":"reading.d.ts","sourceRoot":"","sources":["../../src/decode/reading.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC,eAAO,MAAM,uBAAuB,IAAoB,CAAC;AAEzD,eAAO,MAAM,sBAAsB,+FAAyB,CAAC;AAE7D,eAAO,MAAM,6BAA6B;;;iBAGxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,eAAO,MAAM,yBAAyB,SAC9B,OAAO,KACZ,IAAI,IAAI,uBAC4C,CAAC;AAExD,eAAO,MAAM,qBAAqB;;;;;;iBAGhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,eAAO,MAAM,iBAAiB,SAAU,OAAO,KAAG,IAAI,IAAI,eACX,CAAC;AAEhD,eAAO,MAAM,oBAAoB;;;;;;iBAAwB,CAAC;AAC1D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACtE,eAAO,MAAM,oBAAoB,SACzB,OAAO,KACZ,IAAI,IAAI,kBAAkE,CAAC;AAE9E,eAAO,MAAM,uBAAuB;;;iBAAgC,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,SAAU,OAAO,KAAG,IAAI,IAAI,iBACX,CAAC;AAOlD,eAAO,MAAM,eAAe;;;;;;;;iBAS1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,eAAO,MAAM,WAAW,SAAU,OAAO,KAAG,IAAI,IAAI,SACX,CAAC;AAE1C,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,mBAAmB,SACxB,OAAO,KACZ,IAAI,IAAI,iBACsC,CAAC;AAElD,eAAO,MAAM,eAAe;;;;;;;;iBAI1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,eAAO,MAAM,WAAW,SAAU,OAAO,KAAG,IAAI,IAAI,SACX,CAAC;AAiB1C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;yBAMzB,CAAC;AACF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,eAAO,MAAM,SAAS,SAAU,OAAO,KAAG,IAAI,IAAI,OACX,CAAC"}

package/dist/decode/reading.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReadingV1 = exports.ReadingV1Schema = exports.isReadingMetadataV1 = exports.ReadingMetadataV1Schema = exports.isDeviceReadingTypes = exports.DeviceReadingSchemas = exports.isDeviceReadingV1 = exports.DeviceReadingV1Schema = exports.isDeviceReadingMetadataV1 = exports.DeviceReadingMetadataV1Schema = exports.ReadingDataTypesSchema = void 0;
+exports.isReading = exports.ReadingSchema = exports.isReadingV2 = exports.ReadingV2Schema = exports.isReadingV2Metadata = exports.ReadingV2MetadataSchema = exports.isReadingV1 = exports.ReadingV1Schema = exports.isReadingMetadataV1 = exports.ReadingMetadataV1Schema = exports.isDeviceReadingTypes = exports.DeviceReadingSchemas = exports.isDeviceReadingV1 = exports.DeviceReadingV1Schema = exports.isDeviceReadingMetadataV1 = exports.DeviceReadingMetadataV1Schema = exports.ReadingDataTypesSchema = exports.DEFAULT_READING_VERSION = exports.READING_VERSION_2 = exports.READING_VERSION_1 = void 0;
 const zod_1 = require("zod");
 const kit_schema_1 = require("@xube/kit-schema");
+const constants_1 = require("../constants");
+exports.READING_VERSION_1 = 1;
+exports.READING_VERSION_2 = 2;
+exports.DEFAULT_READING_VERSION = exports.READING_VERSION_1;
 exports.ReadingDataTypesSchema = kit_schema_1.GenericDataTypesSchema;
 exports.DeviceReadingMetadataV1Schema = zod_1.z.object({
     s: zod_1.z.number(), //Seconds,
@@ -22,12 +26,52 @@ exports.isDeviceReadingTypes = isDeviceReadingTypes;
 exports.ReadingMetadataV1Schema = exports.DeviceReadingMetadataV1Schema;
 const isReadingMetadataV1 = (item) => exports.ReadingMetadataV1Schema.safeParse(item).success;
 exports.isReadingMetadataV1 = isReadingMetadataV1;
-exports.ReadingV1Schema = zod_1.z
-    .object({
-    data: exports.ReadingDataTypesSchema,
+const ReadingCommonShape = {
+    id: zod_1.z.string(),
     component: zod_1.z.string().optional(),
-})
-    .merge(kit_schema_1.BaseDataSchema)
-    .passthrough();
+};
+exports.ReadingV1Schema = zod_1.z.looseObject({
+    [constants_1.READING_VERSION_IDENTIFIER]: zod_1.z
+        .literal(exports.READING_VERSION_1)
+        .default(exports.READING_VERSION_1),
+    ...ReadingCommonShape,
+    type: zod_1.z.string(),
+    s: zod_1.z.number(),
+    us: zod_1.z.number().optional(),
+    data: exports.ReadingDataTypesSchema,
+});
 const isReadingV1 = (item) => exports.ReadingV1Schema.safeParse(item).success;
 exports.isReadingV1 = isReadingV1;
+exports.ReadingV2MetadataSchema = zod_1.z.object({
+    [constants_1.READING_VERSION_IDENTIFIER]: zod_1.z.literal(exports.READING_VERSION_2),
+    tm: zod_1.z.number(),
+    bo: zod_1.z.boolean().optional(),
+    so: zod_1.z.boolean().optional(),
+});
+const isReadingV2Metadata = (item) => exports.ReadingV2MetadataSchema.safeParse(item).success;
+exports.isReadingV2Metadata = isReadingV2Metadata;
+exports.ReadingV2Schema = zod_1.z.looseObject({
+    ...exports.ReadingV2MetadataSchema.shape,
+    ...ReadingCommonShape,
+    data: zod_1.z.union([zod_1.z.instanceof(Uint8Array), zod_1.z.string()]),
+});
+const isReadingV2 = (item) => exports.ReadingV2Schema.safeParse(item).success;
+exports.isReadingV2 = isReadingV2;
+const injectDefaultVersionIfMissing = (item) => {
+    if (item === null ||
+        typeof item !== "object" ||
+        Array.isArray(item) ||
+        constants_1.READING_VERSION_IDENTIFIER in item) {
+        return item;
+    }
+    return {
+        ...item,
+        [constants_1.READING_VERSION_IDENTIFIER]: exports.DEFAULT_READING_VERSION,
+    };
+};
+exports.ReadingSchema = zod_1.z.preprocess(injectDefaultVersionIfMissing, zod_1.z.discriminatedUnion(constants_1.READING_VERSION_IDENTIFIER, [
+    exports.ReadingV1Schema,
+    exports.ReadingV2Schema,
+]));
+const isReading = (item) => exports.ReadingSchema.safeParse(item).success;
+exports.isReading = isReading;

package/dist/get/get-data-by-date-range.d.ts

@@ -2,58 +2,20 @@ import { z } from "zod";
 export declare const GetDataByDateRangeRequestSchema: z.ZodObject<{
     devices: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        components: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        components: string[];
-    }, {
-        id: string;
-        components: string[];
-    }>, "many">;
+        components: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
     dateRange: z.ZodObject<{
         start: z.ZodString;
         end: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        start: string;
-        end: string;
-    }, {
-        start: string;
-        end: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    devices: {
-        id: string;
-        components: string[];
-    }[];
-    dateRange: {
-        start: string;
-        end: string;
-    };
-}, {
-    devices: {
-        id: string;
-        components: string[];
-    }[];
-    dateRange: {
-        start: string;
-        end: string;
-    };
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type GetDataByDateRangeRequest = z.infer<typeof GetDataByDateRangeRequestSchema>;
 export declare const isGetDataByDateRangeRequest: (object: unknown) => object is GetDataByDateRangeRequest;
 export declare const ComponentDataEntryResponseSchema: z.ZodObject<{
     seconds: z.ZodNumber;
     microseconds: z.ZodOptional<z.ZodNumber>;
-    readings: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-}, "strip", z.ZodTypeAny, {
-    seconds: number;
-    readings: {};
-    microseconds?: number | undefined;
-}, {
-    seconds: number;
-    readings: {};
-    microseconds?: number | undefined;
-}>;
+    readings: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+}, z.core.$strip>;
 export type ComponentDataEntryResponse = z.infer<typeof ComponentDataEntryResponseSchema>;
 export declare const DeviceDataEntryResponseSchema: z.ZodObject<{
     id: z.ZodString;
@@ -62,52 +24,10 @@ export declare const DeviceDataEntryResponseSchema: z.ZodObject<{
         data: z.ZodArray<z.ZodObject<{
             seconds: z.ZodNumber;
             microseconds: z.ZodOptional<z.ZodNumber>;
-            readings: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-        }, "strip", z.ZodTypeAny, {
-            seconds: number;
-            readings: {};
-            microseconds?: number | undefined;
-        }, {
-            seconds: number;
-            readings: {};
-            microseconds?: number | undefined;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        data: {
-            seconds: number;
-            readings: {};
-            microseconds?: number | undefined;
-        }[];
-        id: string;
-    }, {
-        data: {
-            seconds: number;
-            readings: {};
-            microseconds?: number | undefined;
-        }[];
-        id: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    components: {
-        data: {
-            seconds: number;
-            readings: {};
-            microseconds?: number | undefined;
-        }[];
-        id: string;
-    }[];
-}, {
-    id: string;
-    components: {
-        data: {
-            seconds: number;
-            readings: {};
-            microseconds?: number | undefined;
-        }[];
-        id: string;
-    }[];
-}>;
+            readings: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type DeviceDataEntryResponse = z.infer<typeof DeviceDataEntryResponseSchema>;
 export declare const GetDataByDateRangeResponseSchema: z.ZodObject<{
     devices: z.ZodArray<z.ZodObject<{
@@ -117,76 +37,10 @@ export declare const GetDataByDateRangeResponseSchema: z.ZodObject<{
             data: z.ZodArray<z.ZodObject<{
                 seconds: z.ZodNumber;
                 microseconds: z.ZodOptional<z.ZodNumber>;
-                readings: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-            }, "strip", z.ZodTypeAny, {
-                seconds: number;
-                readings: {};
-                microseconds?: number | undefined;
-            }, {
-                seconds: number;
-                readings: {};
-                microseconds?: number | undefined;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            data: {
-                seconds: number;
-                readings: {};
-                microseconds?: number | undefined;
-            }[];
-            id: string;
-        }, {
-            data: {
-                seconds: number;
-                readings: {};
-                microseconds?: number | undefined;
-            }[];
-            id: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        components: {
-            data: {
-                seconds: number;
-                readings: {};
-                microseconds?: number | undefined;
-            }[];
-            id: string;
-        }[];
-    }, {
-        id: string;
-        components: {
-            data: {
-                seconds: number;
-                readings: {};
-                microseconds?: number | undefined;
-            }[];
-            id: string;
-        }[];
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    devices: {
-        id: string;
-        components: {
-            data: {
-                seconds: number;
-                readings: {};
-                microseconds?: number | undefined;
-            }[];
-            id: string;
-        }[];
-    }[];
-}, {
-    devices: {
-        id: string;
-        components: {
-            data: {
-                seconds: number;
-                readings: {};
-                microseconds?: number | undefined;
-            }[];
-            id: string;
-        }[];
-    }[];
-}>;
+                readings: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, z.core.$loose>]>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type GetDataByDateRangeResponse = z.infer<typeof GetDataByDateRangeResponseSchema>;
 //# sourceMappingURL=get-data-by-date-range.d.ts.map

package/dist/get/get-data-by-date-range.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-data-by-date-range.d.ts","sourceRoot":"","sources":["../../src/get/get-data-by-date-range.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AACF,eAAO,MAAM,2BAA2B,WAC9B,OAAO,KACd,MAAM,IAAI,yBAGZ,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;EAI3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AACF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}
+{"version":3,"file":"get-data-by-date-range.d.ts","sourceRoot":"","sources":["../../src/get/get-data-by-date-range.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,+BAA+B;;;;;;;;;iBAY1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AACF,eAAO,MAAM,2BAA2B,WAC9B,OAAO,KACd,MAAM,IAAI,yBAGZ,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;iBAI3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AACF,eAAO,MAAM,6BAA6B;;;;;;;;;;iBAQxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;iBAE3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}

package/dist/get/get-data-by-date-range.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetDataByDateRangeResponseSchema = exports.DeviceDataEntryResponseSchema = exports.ComponentDataEntryResponseSchema = exports.isGetDataByDateRangeRequest = exports.GetDataByDateRangeRequestSchema = void 0;
+const kit_schema_1 = require("@xube/kit-schema");
 const zod_1 = require("zod");
 exports.GetDataByDateRangeRequestSchema = zod_1.z.object({
     devices: zod_1.z.array(zod_1.z.object({
@@ -21,7 +22,7 @@ exports.isGetDataByDateRangeRequest = isGetDataByDateRangeRequest;
 exports.ComponentDataEntryResponseSchema = zod_1.z.object({
     seconds: zod_1.z.number(),
     microseconds: zod_1.z.number().optional(),
-    readings: zod_1.z.object({}),
+    readings: kit_schema_1.GenericDataTypesSchema,
 });
 exports.DeviceDataEntryResponseSchema = zod_1.z.object({
     id: zod_1.z.string(),

package/dist/message/message.d.ts

@@ -6,21 +6,7 @@ export declare const DataMessageSchema: z.ZodObject<{
     component: z.ZodOptional<z.ZodString>;
     request: z.ZodOptional<z.ZodString>;
     timestamp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    payload: string;
-    account: string;
-    device: string;
-    timestamp: number;
-    component?: string | undefined;
-    request?: string | undefined;
-}, {
-    payload: string;
-    account: string;
-    device: string;
-    timestamp: number;
-    component?: string | undefined;
-    request?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type DataMessage = z.infer<typeof DataMessageSchema>;
 export declare const isDataMessage: (item: unknown) => item is DataMessage;
 //# sourceMappingURL=message.d.ts.map

package/dist/message/message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/message/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,eAAO,MAAM,aAAa,SAAU,OAAO,KAAG,IAAI,IAAI,WACX,CAAC"}
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/message/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,eAAO,MAAM,aAAa,SAAU,OAAO,KAAG,IAAI,IAAI,WACX,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xube/kit-aws-data-schema",
-  "version": "0.2.8",
+  "version": "0.2.12",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -18,15 +18,15 @@
   },
   "homepage": "https://github.com/XubeLtd/dev-kit#readme",
   "devDependencies": {
-    "@xube/kit-build": "^0.2.8"
+    "@xube/kit-build": "^0.2.12"
   },
   "dependencies": {
-    "@xube/kit-aws-schema": "^0.2.8",
-    "@xube/kit-constants": "^0.2.8",
-    "@xube/kit-generator": "^0.2.8",
-    "@xube/kit-log": "^0.2.8",
-    "@xube/kit-schema": "^0.2.8",
-    "zod": "^3.23.8",
-    "zod-validation-error": "^2.0.0"
+    "@xube/kit-aws-schema": "^0.2.12",
+    "@xube/kit-constants": "^0.2.12",
+    "@xube/kit-generator": "^0.2.12",
+    "@xube/kit-log": "^0.2.12",
+    "@xube/kit-schema": "^0.2.12",
+    "zod": "^4.4.3",
+    "zod-validation-error": "^5.0.0"
   }
 }

package/src/constants.ts

@@ -1,3 +1,5 @@
 export const DATA_TYPE = "data";
 
-export const DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";
+export const DATA_TABLE_NAME_ENV_VAR = "DATA_TABLE_NAME";
+
+export const READING_VERSION_IDENTIFIER = "v";

package/src/decode/reading.test.ts

@@ -0,0 +1,181 @@
+import { Buffer } from "buffer";
+import {
+  DEFAULT_READING_VERSION,
+  READING_VERSION_1,
+  READING_VERSION_2,
+  ReadingSchema,
+  ReadingV1,
+  ReadingV1Schema,
+  ReadingV2,
+  ReadingV2Schema,
+  isReading,
+  isReadingV1,
+  isReadingV2,
+} from "./reading";
+
+const legacyV1 = {
+  data: "S,+000.30,+001.74,M,00,33",
+  s: 1697578841,
+  us: 214981,
+  type: "data",
+  id: "dev1",
+  component: "c",
+};
+const explicitV1 = { ...legacyV1, v: READING_VERSION_1 };
+const blobV2Binary = {
+  v: READING_VERSION_2,
+  id: "dev1",
+  component: "c",
+  tm: 1780859506366,
+  bo: false,
+  so: false,
+  data: Buffer.from([0x01, 0x02, 0x03]),
+};
+const blobV2String = {
+  v: READING_VERSION_2,
+  id: "dev1",
+  tm: 1,
+  bo: false,
+  so: false,
+  data: "blob-as-string",
+};
+
+describe("ReadingSchema (discriminated union)", () => {
+  describe("v1 (timestamped)", () => {
+    it("parses a legacy record missing `v` and injects DEFAULT_READING_VERSION", () => {
+      const parsed = ReadingSchema.parse(legacyV1) as ReadingV1;
+      expect(parsed.v).toBe(DEFAULT_READING_VERSION);
+      expect(parsed.v).toBe(READING_VERSION_1);
+      expect(parsed.data).toBe(legacyV1.data);
+      expect(parsed.id).toBe(legacyV1.id);
+    });
+
+    it("parses an explicit v=1 record without mutating other fields", () => {
+      const parsed = ReadingSchema.parse(explicitV1) as ReadingV1;
+      expect(parsed).toEqual(explicitV1);
+    });
+
+    it("preserves passthrough fields", () => {
+      const parsed = ReadingSchema.parse({
+        ...explicitV1,
+        extra: "passthrough",
+      }) as ReadingV1 & { extra: string };
+      expect(parsed.extra).toBe("passthrough");
+    });
+
+    it("does not overwrite an explicit v on a record that already has one", () => {
+      // Preprocess only injects v when missing — must not clobber existing v.
+      const parsed = ReadingSchema.parse(explicitV1) as ReadingV1;
+      expect(parsed.v).toBe(READING_VERSION_1);
+    });
+  });
+
+  describe("v2 (blob)", () => {
+    it("parses a v=2 record with a Uint8Array data payload", () => {
+      const parsed = ReadingSchema.parse(blobV2Binary) as ReadingV2;
+      expect(parsed.v).toBe(READING_VERSION_2);
+      expect(parsed.tm).toBe(blobV2Binary.tm);
+      expect(parsed.data).toBeInstanceOf(Uint8Array);
+      expect((parsed.data as Uint8Array).length).toBe(3);
+    });
+
+    it("parses a v=2 record with a string data payload", () => {
+      expect(ReadingSchema.parse(blobV2String)).toEqual(blobV2String);
+    });
+
+    it("rejects a v=2 record missing the required tm field", () => {
+      const { tm: _tm, ...withoutTm } = blobV2String;
+      expect(ReadingSchema.safeParse(withoutTm).success).toBe(false);
+    });
+
+    it("rejects a v=2 record missing the required data field", () => {
+      const { data: _data, ...withoutData } = blobV2String;
+      expect(ReadingSchema.safeParse(withoutData).success).toBe(false);
+    });
+
+    it("rejects a v=2 record missing the required id field", () => {
+      const { id: _id, ...withoutId } = blobV2String;
+      expect(ReadingSchema.safeParse(withoutId).success).toBe(false);
+    });
+  });
+
+  describe("invalid input", () => {
+    it("rejects an unknown v value", () => {
+      expect(ReadingSchema.safeParse({ v: 99, foo: "bar" }).success).toBe(
+        false,
+      );
+    });
+
+    it.each([
+      ["null", null],
+      ["undefined", undefined],
+      ["string", "not-an-object"],
+      ["number", 42],
+      ["boolean", true],
+      ["array", [1, 2, 3]],
+    ])("rejects %s input without crashing", (_label, input) => {
+      expect(ReadingSchema.safeParse(input).success).toBe(false);
+    });
+
+    it("rejects an empty object (preprocess injects v=1, then required v1 fields fail)", () => {
+      expect(ReadingSchema.safeParse({}).success).toBe(false);
+    });
+  });
+});
+
+describe("ReadingV1Schema (standalone)", () => {
+  it("defaults v to READING_VERSION_1 when missing", () => {
+    const parsed = ReadingV1Schema.parse(legacyV1) as ReadingV1;
+    expect(parsed.v).toBe(READING_VERSION_1);
+  });
+
+  it("rejects an explicit v=2 (literal check)", () => {
+    expect(
+      ReadingV1Schema.safeParse({ ...legacyV1, v: READING_VERSION_2 }).success,
+    ).toBe(false);
+  });
+});
+
+describe("ReadingV2Schema (standalone)", () => {
+  it("requires v=2 explicitly (no default)", () => {
+    expect(
+      ReadingV2Schema.safeParse({ tm: 1, payload: "x" }).success,
+    ).toBe(false);
+  });
+
+  it("accepts a valid v=2 record", () => {
+    expect(ReadingV2Schema.safeParse(blobV2String).success).toBe(true);
+  });
+});
+
+describe("type-narrowing predicates", () => {
+  it("isReadingV1 accepts legacy and explicit v1, rejects v2", () => {
+    expect(isReadingV1(legacyV1)).toBe(true);
+    expect(isReadingV1(explicitV1)).toBe(true);
+    expect(isReadingV1(blobV2Binary)).toBe(false);
+  });
+
+  it("isReadingV2 accepts v2, rejects v1 and legacy", () => {
+    expect(isReadingV2(blobV2Binary)).toBe(true);
+    expect(isReadingV2(blobV2String)).toBe(true);
+    expect(isReadingV2(legacyV1)).toBe(false);
+    expect(isReadingV2(explicitV1)).toBe(false);
+  });
+
+  it("isReading accepts both kinds, rejects garbage", () => {
+    expect(isReading(legacyV1)).toBe(true);
+    expect(isReading(explicitV1)).toBe(true);
+    expect(isReading(blobV2Binary)).toBe(true);
+    expect(isReading(blobV2String)).toBe(true);
+    expect(isReading({ foo: "bar" })).toBe(false);
+    expect(isReading(null)).toBe(false);
+  });
+});
+
+describe("DEFAULT_READING_VERSION", () => {
+  it("currently equals READING_VERSION_1", () => {
+    // If this fails, the preprocess no longer assumes legacy-records-are-v1 —
+    // make sure all consumers and the migration story are aware before flipping.
+    expect(DEFAULT_READING_VERSION).toBe(READING_VERSION_1);
+  });
+});

package/src/decode/reading.ts

@@ -1,5 +1,11 @@
 import { z } from "zod";
-import { BaseDataSchema, GenericDataTypesSchema } from "@xube/kit-schema";
+import { GenericDataTypesSchema } from "@xube/kit-schema";
+import { READING_VERSION_IDENTIFIER } from "../constants";
+
+export const READING_VERSION_1 = 1;
+export const READING_VERSION_2 = 2;
+
+export const DEFAULT_READING_VERSION = READING_VERSION_1;
 
 export const ReadingDataTypesSchema = GenericDataTypesSchema;
 
@@ -7,8 +13,12 @@ export const DeviceReadingMetadataV1Schema = z.object({
   s: z.number(), //Seconds,
   us: z.number(), //Microseconds
 });
-export type DeviceReadingMetadataV1 = z.infer<typeof DeviceReadingMetadataV1Schema>;
-export const isDeviceReadingMetadataV1 = (item: unknown): item is DeviceReadingMetadataV1 =>
+export type DeviceReadingMetadataV1 = z.infer<
+  typeof DeviceReadingMetadataV1Schema
+>;
+export const isDeviceReadingMetadataV1 = (
+  item: unknown,
+): item is DeviceReadingMetadataV1 =>
   DeviceReadingMetadataV1Schema.safeParse(item).success;
 
 export const DeviceReadingV1Schema = z.object({
@@ -21,21 +31,77 @@ export const isDeviceReadingV1 = (item: unknown): item is DeviceReadingV1 =>
 
 export const DeviceReadingSchemas = DeviceReadingV1Schema;
 export type DeviceReadingTypes = z.infer<typeof DeviceReadingSchemas>;
-export const isDeviceReadingTypes = (item: unknown): item is DeviceReadingTypes =>
-  DeviceReadingSchemas.safeParse(item).success;
+export const isDeviceReadingTypes = (
+  item: unknown,
+): item is DeviceReadingTypes => DeviceReadingSchemas.safeParse(item).success;
 
 export const ReadingMetadataV1Schema = DeviceReadingMetadataV1Schema;
 export type ReadingMetadataV1 = z.infer<typeof ReadingMetadataV1Schema>;
 export const isReadingMetadataV1 = (item: unknown): item is ReadingMetadataV1 =>
   ReadingMetadataV1Schema.safeParse(item).success;
 
-export const ReadingV1Schema = z
-  .object({
-    data: ReadingDataTypesSchema,
-    component: z.string().optional(),
-  })
-  .merge(BaseDataSchema)
-  .passthrough();
+const ReadingCommonShape = {
+  id: z.string(),
+  component: z.string().optional(),
+};
+
+export const ReadingV1Schema = z.looseObject({
+  [READING_VERSION_IDENTIFIER]: z
+    .literal(READING_VERSION_1)
+    .default(READING_VERSION_1),
+  ...ReadingCommonShape,
+  type: z.string(),
+  s: z.number(),
+  us: z.number().optional(),
+  data: ReadingDataTypesSchema,
+});
 export type ReadingV1 = z.infer<typeof ReadingV1Schema>;
 export const isReadingV1 = (item: unknown): item is ReadingV1 =>
   ReadingV1Schema.safeParse(item).success;
+
+export const ReadingV2MetadataSchema = z.object({
+  [READING_VERSION_IDENTIFIER]: z.literal(READING_VERSION_2),
+  tm: z.number(),
+  bo: z.boolean().optional(),
+  so: z.boolean().optional(),
+});
+export type ReadingV2Metadata = z.infer<typeof ReadingV2MetadataSchema>;
+export const isReadingV2Metadata = (
+  item: unknown,
+): item is ReadingV2Metadata =>
+  ReadingV2MetadataSchema.safeParse(item).success;
+
+export const ReadingV2Schema = z.looseObject({
+  ...ReadingV2MetadataSchema.shape,
+  ...ReadingCommonShape,
+  data: z.union([z.instanceof(Uint8Array), z.string()]),
+});
+export type ReadingV2 = z.infer<typeof ReadingV2Schema>;
+export const isReadingV2 = (item: unknown): item is ReadingV2 =>
+  ReadingV2Schema.safeParse(item).success;
+
+const injectDefaultVersionIfMissing = (item: unknown): unknown => {
+  if (
+    item === null ||
+    typeof item !== "object" ||
+    Array.isArray(item) ||
+    READING_VERSION_IDENTIFIER in item
+  ) {
+    return item;
+  }
+  return {
+    ...item,
+    [READING_VERSION_IDENTIFIER]: DEFAULT_READING_VERSION,
+  };
+};
+
+export const ReadingSchema = z.preprocess(
+  injectDefaultVersionIfMissing,
+  z.discriminatedUnion(READING_VERSION_IDENTIFIER, [
+    ReadingV1Schema,
+    ReadingV2Schema,
+  ]),
+);
+export type Reading = z.infer<typeof ReadingSchema>;
+export const isReading = (item: unknown): item is Reading =>
+  ReadingSchema.safeParse(item).success;

package/src/get/get-data-by-date-range.ts

@@ -1,4 +1,5 @@
 import { XubeLog } from "@xube/kit-log";
+import { GenericDataTypesSchema } from "@xube/kit-schema";
 import { z } from "zod";
 import { fromZodError } from "zod-validation-error";
 
@@ -28,7 +29,7 @@ export const isGetDataByDateRangeRequest = (
 export const ComponentDataEntryResponseSchema = z.object({
   seconds: z.number(),
   microseconds: z.number().optional(),
-  readings: z.object({}),
+  readings: GenericDataTypesSchema,
 });
 export type ComponentDataEntryResponse = z.infer<
   typeof ComponentDataEntryResponseSchema