@disclosureos/instruments 1.0.0

package/dist/manifest/index.d.ts

@@ -0,0 +1,289 @@
+import { z } from 'zod';
+
+declare const ModalitySchema: z.ZodEnum<{
+    audio: "audio";
+    electro_optical: "electro_optical";
+    radio_frequency: "radio_frequency";
+    quantum: "quantum";
+    environmental: "environmental";
+    biometric: "biometric";
+}>;
+type Modality = z.infer<typeof ModalitySchema>;
+declare const TimeSourceSchema: z.ZodEnum<{
+    atomic_clock: "atomic_clock";
+    gps_disciplined: "gps_disciplined";
+    ntp: "ntp";
+    system: "system";
+    unknown: "unknown";
+}>;
+type TimeSource = z.infer<typeof TimeSourceSchema>;
+declare const SensorTimingSchema: z.ZodObject<{
+    timeSource: z.ZodEnum<{
+        atomic_clock: "atomic_clock";
+        gps_disciplined: "gps_disciplined";
+        ntp: "ntp";
+        system: "system";
+        unknown: "unknown";
+    }>;
+    timeUncertaintyNs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+type SensorTiming = z.infer<typeof SensorTimingSchema>;
+declare const RecordsMappingSchema: z.ZodObject<{
+    sensorType: z.ZodOptional<z.ZodString>;
+    detectionMethod: z.ZodOptional<z.ZodString>;
+    proposedSensorType: z.ZodOptional<z.ZodBoolean>;
+    proposedDetectionMethod: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type RecordsMapping = z.infer<typeof RecordsMappingSchema>;
+declare const RawDataSpecSchema: z.ZodObject<{
+    format: z.ZodOptional<z.ZodString>;
+    locatorPattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sampleRateHz: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bitDepth: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+type RawDataSpec = z.infer<typeof RawDataSpecSchema>;
+declare const UncertaintyTypeSchema: z.ZodEnum<{
+    A: "A";
+    B: "B";
+}>;
+type UncertaintyType = z.infer<typeof UncertaintyTypeSchema>;
+declare const MeasurementUncertaintySchema: z.ZodObject<{
+    u_c: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    U: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    k: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        A: "A";
+        B: "B";
+    }>>>;
+}, z.core.$strip>;
+type MeasurementUncertainty = z.infer<typeof MeasurementUncertaintySchema>;
+declare const MeasurementSchema: z.ZodObject<{
+    name: z.ZodString;
+    unit: z.ZodString;
+    uncertainty: z.ZodOptional<z.ZodObject<{
+        u_c: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        U: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        k: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            A: "A";
+            B: "B";
+        }>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type Measurement = z.infer<typeof MeasurementSchema>;
+declare const CalibrationStatusSchema: z.ZodEnum<{
+    none: "none";
+    candidate_identified: "candidate_identified";
+    in_practice: "in_practice";
+    documented: "documented";
+}>;
+type CalibrationStatus = z.infer<typeof CalibrationStatusSchema>;
+declare const SensorCalibrationSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        none: "none";
+        candidate_identified: "candidate_identified";
+        in_practice: "in_practice";
+        documented: "documented";
+    }>;
+    calibrated: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    currentMethod: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    traceableReference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    referenceInUse: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    cadence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    uncertaintyBudget: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type SensorCalibration = z.infer<typeof SensorCalibrationSchema>;
+declare const SensorEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    modality: z.ZodEnum<{
+        audio: "audio";
+        electro_optical: "electro_optical";
+        radio_frequency: "radio_frequency";
+        quantum: "quantum";
+        environmental: "environmental";
+        biometric: "biometric";
+    }>;
+    manufacturerModel: z.ZodOptional<z.ZodString>;
+    inHouse: z.ZodOptional<z.ZodBoolean>;
+    compute: z.ZodOptional<z.ZodString>;
+    recordsMapping: z.ZodOptional<z.ZodObject<{
+        sensorType: z.ZodOptional<z.ZodString>;
+        detectionMethod: z.ZodOptional<z.ZodString>;
+        proposedSensorType: z.ZodOptional<z.ZodBoolean>;
+        proposedDetectionMethod: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    timing: z.ZodOptional<z.ZodObject<{
+        timeSource: z.ZodEnum<{
+            atomic_clock: "atomic_clock";
+            gps_disciplined: "gps_disciplined";
+            ntp: "ntp";
+            system: "system";
+            unknown: "unknown";
+        }>;
+        timeUncertaintyNs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    rawData: z.ZodOptional<z.ZodObject<{
+        format: z.ZodOptional<z.ZodString>;
+        locatorPattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sampleRateHz: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        bitDepth: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    measurements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        unit: z.ZodString;
+        uncertainty: z.ZodOptional<z.ZodObject<{
+            u_c: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            U: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            k: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                A: "A";
+                B: "B";
+            }>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    calibration: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            none: "none";
+            candidate_identified: "candidate_identified";
+            in_practice: "in_practice";
+            documented: "documented";
+        }>;
+        calibrated: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        currentMethod: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        traceableReference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        referenceInUse: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        cadence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uncertaintyBudget: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    specs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    specSource: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SensorEntry = z.infer<typeof SensorEntrySchema>;
+declare const UpgradeStatusSchema: z.ZodEnum<{
+    planned: "planned";
+    evaluating: "evaluating";
+    ordered: "ordered";
+    acquired: "acquired";
+}>;
+type UpgradeStatus = z.infer<typeof UpgradeStatusSchema>;
+declare const FutureUpgradeSchema: z.ZodObject<{
+    name: z.ZodString;
+    modality: z.ZodEnum<{
+        audio: "audio";
+        electro_optical: "electro_optical";
+        radio_frequency: "radio_frequency";
+        quantum: "quantum";
+        environmental: "environmental";
+        biometric: "biometric";
+    }>;
+    status: z.ZodOptional<z.ZodEnum<{
+        planned: "planned";
+        evaluating: "evaluating";
+        ordered: "ordered";
+        acquired: "acquired";
+    }>>;
+    specs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    link: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type FutureUpgrade = z.infer<typeof FutureUpgradeSchema>;
+declare const SensorManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodString;
+    org: z.ZodString;
+    orgSlug: z.ZodString;
+    orgUrl: z.ZodOptional<z.ZodString>;
+    generatedAt: z.ZodOptional<z.ZodString>;
+    sensors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        modality: z.ZodEnum<{
+            audio: "audio";
+            electro_optical: "electro_optical";
+            radio_frequency: "radio_frequency";
+            quantum: "quantum";
+            environmental: "environmental";
+            biometric: "biometric";
+        }>;
+        manufacturerModel: z.ZodOptional<z.ZodString>;
+        inHouse: z.ZodOptional<z.ZodBoolean>;
+        compute: z.ZodOptional<z.ZodString>;
+        recordsMapping: z.ZodOptional<z.ZodObject<{
+            sensorType: z.ZodOptional<z.ZodString>;
+            detectionMethod: z.ZodOptional<z.ZodString>;
+            proposedSensorType: z.ZodOptional<z.ZodBoolean>;
+            proposedDetectionMethod: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        timing: z.ZodOptional<z.ZodObject<{
+            timeSource: z.ZodEnum<{
+                atomic_clock: "atomic_clock";
+                gps_disciplined: "gps_disciplined";
+                ntp: "ntp";
+                system: "system";
+                unknown: "unknown";
+            }>;
+            timeUncertaintyNs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        rawData: z.ZodOptional<z.ZodObject<{
+            format: z.ZodOptional<z.ZodString>;
+            locatorPattern: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            sampleRateHz: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            bitDepth: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        measurements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            unit: z.ZodString;
+            uncertainty: z.ZodOptional<z.ZodObject<{
+                u_c: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                U: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                k: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    A: "A";
+                    B: "B";
+                }>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        calibration: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                none: "none";
+                candidate_identified: "candidate_identified";
+                in_practice: "in_practice";
+                documented: "documented";
+            }>;
+            calibrated: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            currentMethod: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            traceableReference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            referenceInUse: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            cadence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            uncertaintyBudget: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        specs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        specSource: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    futureUpgrades: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        modality: z.ZodEnum<{
+            audio: "audio";
+            electro_optical: "electro_optical";
+            radio_frequency: "radio_frequency";
+            quantum: "quantum";
+            environmental: "environmental";
+            biometric: "biometric";
+        }>;
+        status: z.ZodOptional<z.ZodEnum<{
+            planned: "planned";
+            evaluating: "evaluating";
+            ordered: "ordered";
+            acquired: "acquired";
+        }>>;
+        specs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        link: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type SensorManifest = z.infer<typeof SensorManifestSchema>;
+
+export { type CalibrationStatus, CalibrationStatusSchema, type FutureUpgrade, FutureUpgradeSchema, type Measurement, MeasurementSchema, type MeasurementUncertainty, MeasurementUncertaintySchema, type Modality, ModalitySchema, type RawDataSpec, RawDataSpecSchema, type RecordsMapping, RecordsMappingSchema, type SensorCalibration, SensorCalibrationSchema, type SensorEntry, SensorEntrySchema, type SensorManifest, SensorManifestSchema, type SensorTiming, SensorTimingSchema, type TimeSource, TimeSourceSchema, type UncertaintyType, UncertaintyTypeSchema, type UpgradeStatus, UpgradeStatusSchema };

package/dist/manifest/index.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+
+// src/manifest/types.ts
+var KEBAB_CASE_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var ModalitySchema = z.enum(["audio", "electro_optical", "radio_frequency", "quantum", "environmental", "biometric"]).describe("Top-level sensing modality the sensor belongs to.");
+var TimeSourceSchema = z.enum(["atomic_clock", "gps_disciplined", "ntp", "system", "unknown"]).describe("Clock source that timestamps the sensor\u2019s data.");
+var SensorTimingSchema = z.object({
+  timeSource: TimeSourceSchema,
+  timeUncertaintyNs: z.number().nullable().optional().describe("Timestamp uncertainty in nanoseconds. Null = not yet characterized.")
+}).meta({ id: "SensorTiming" }).describe(
+  "Timing provenance. Timestamp error of even a few seconds confounds multi-station correlation, so the clock source must be declared, not assumed."
+);
+var RecordsMappingSchema = z.object({
+  sensorType: z.string().optional().describe("The `@disclosureos/records` SensorType this sensor maps to."),
+  detectionMethod: z.string().optional().describe("The `@disclosureos/records` DetectionMethod this sensor maps to."),
+  proposedSensorType: z.boolean().optional().describe("True = sensorType is not in the records enum yet and is proposed by the publisher."),
+  proposedDetectionMethod: z.boolean().optional().describe("True = detectionMethod is not in the records enum yet and is proposed by the publisher.")
+}).meta({ id: "RecordsMapping" }).describe(
+  "How this sensor maps to the `SensorReading` vocabulary in `@disclosureos/records`. Values outside the records enums must carry the matching proposed* flag."
+);
+var RawDataSpecSchema = z.object({
+  format: z.string().optional().describe('Raw-data file format, e.g. "NDJSON.gz", "WAV", "MJPEG", "FITS", "CSV".'),
+  locatorPattern: z.string().nullable().optional().describe("Storage key pattern or path convention for locating the raw files."),
+  sampleRateHz: z.number().nullable().optional().describe("Sample rate in Hz, where applicable."),
+  bitDepth: z.number().nullable().optional().describe("Sample bit depth, where applicable.")
+}).meta({ id: "RawDataSpec" }).describe(
+  "Raw-data format and locator. Supports a metadata-first architecture: circulate manifests widely, pull raw data on demand."
+);
+var UncertaintyTypeSchema = z.enum(["A", "B"]).describe("GUM uncertainty evaluation type: A (statistical) or B (other means).");
+var MeasurementUncertaintySchema = z.object({
+  u_c: z.number().nullable().optional().describe("Combined standard uncertainty."),
+  U: z.number().nullable().optional().describe("Expanded uncertainty (= k \xD7 u_c)."),
+  k: z.number().nullable().optional().describe("Coverage factor (2 \u2248 95% confidence level)."),
+  type: UncertaintyTypeSchema.nullable().optional()
+}).meta({ id: "MeasurementUncertainty" }).describe(
+  'GUM-style measurement uncertainty. Fields are nullable until an uncertainty budget exists \u2014 declaring "unknown" honestly is itself information.'
+);
+var MeasurementSchema = z.object({
+  name: z.string().min(1).describe('Measured quantity, e.g. "differential_pressure".'),
+  unit: z.string().min(1).describe('UCUM-style unit string, e.g. "Pa", "dB", "uT", "ppm", "/min".'),
+  uncertainty: MeasurementUncertaintySchema.optional()
+}).meta({ id: "Measurement" }).describe("One measured quantity with its unit and uncertainty.");
+var CalibrationStatusSchema = z.enum(["none", "candidate_identified", "in_practice", "documented"]).describe(
+  "Calibration maturity gradient: none = no calibration; candidate_identified = a reference is named but not used; in_practice = a real method is performed but not fully budgeted; documented = method + uncertainty budget published."
+);
+var SensorCalibrationSchema = z.object({
+  status: CalibrationStatusSchema,
+  calibrated: z.boolean().nullable().optional().describe("Coarse calibrated flag, mirroring `SensorReading.calibrated`. Null = undetermined."),
+  currentMethod: z.string().nullable().optional().describe("What the operator actually does today. Null = no calibration currently performed."),
+  traceableReference: z.string().nullable().optional().describe('Traceable reference, in use or identified as a candidate (e.g. "GPS/UTC", "USGS/INTERMAGNET").'),
+  referenceInUse: z.boolean().nullable().optional().describe("True = the traceable reference is part of current practice. False = identified candidate only. Null = undetermined."),
+  cadence: z.string().nullable().optional().describe("How often calibration is performed."),
+  uncertaintyBudget: z.string().nullable().optional().describe("Published uncertainty budget, if any."),
+  notes: z.string().nullable().optional().describe("Open questions or method caveats.")
+}).meta({ id: "SensorCalibration" }).describe(
+  "Calibration provenance. Deliberately separates what an operator actually does today from the reference it has identified; honest nulls are first-class, so calibration gaps stay visible and comparable across operators."
+);
+var SensorEntrySchema = z.object({
+  id: z.string().regex(KEBAB_CASE_PATTERN).describe(
+    'Stable kebab-case id, unique within the manifest; addressable from a record via `SensorReading.sensorRef` ("<org-slug>:<sensor-id>").'
+  ),
+  name: z.string().min(1).describe("Human-readable sensor name."),
+  modality: ModalitySchema,
+  manufacturerModel: z.string().optional().describe(
+    'Hardware class descriptor. Publishers MAY withhold specific make/model identities and publish spec-level class descriptors instead (e.g. "dual GM-tube counter" rather than a product name).'
+  ),
+  inHouse: z.boolean().optional().describe("True if operator-built rather than off-the-shelf."),
+  compute: z.string().optional().describe("The compute unit this sensor is attached to, for platforms with several compute nodes."),
+  recordsMapping: RecordsMappingSchema.optional(),
+  timing: SensorTimingSchema.optional(),
+  rawData: RawDataSpecSchema.optional(),
+  measurements: z.array(MeasurementSchema).optional(),
+  calibration: SensorCalibrationSchema.optional(),
+  specs: z.record(z.string(), z.unknown()).optional().describe(
+    "Free-form hardware specifications from the operator\u2019s spec sheet (resolution, range, sensitivity, interface, \u2026). Keys vary by modality."
+  ),
+  specSource: z.string().optional().describe("Provenance of the spec values.")
+}).meta({ id: "SensorEntry" }).describe("One sensor: its class, spec, timing, raw-data locator, measurements, and calibration provenance.");
+var UpgradeStatusSchema = z.enum(["planned", "evaluating", "ordered", "acquired"]).describe("Acquisition status of a declared future hardware upgrade.");
+var FutureUpgradeSchema = z.object({
+  name: z.string().min(1),
+  modality: ModalitySchema,
+  status: UpgradeStatusSchema.optional(),
+  specs: z.record(z.string(), z.unknown()).optional(),
+  link: z.string().nullable().optional().describe("Public product or reference page, where the publisher chooses to share one."),
+  notes: z.string().nullable().optional()
+}).meta({ id: "FutureUpgrade" }).describe(
+  "Planned hardware declared ahead of deployment so data consumers can anticipate new streams. Not part of the live sensor array."
+);
+var SensorManifestSchema = z.object({
+  schemaVersion: z.string().min(1).describe("Version of the sensor-manifest schema this instance targets (SemVer)."),
+  org: z.string().min(1).describe('Publishing organization, display form (e.g. "ELD\xC6ON").'),
+  orgSlug: z.string().regex(KEBAB_CASE_PATTERN).describe('Stable lowercase slug for the publisher (e.g. "eldaeon"); the org half of a `sensorRef`.'),
+  orgUrl: z.string().optional().describe("URL for the publishing organization."),
+  generatedAt: z.string().optional().describe("ISO date the manifest was generated."),
+  sensors: z.array(SensorEntrySchema).min(1),
+  futureUpgrades: z.array(FutureUpgradeSchema).optional()
+}).meta({ id: "SensorManifest" }).describe(
+  "A published catalog of one organization\u2019s detection hardware. Any operator \u2014 vendor, research group, or institution \u2014 publishes its own manifest against this schema so datasets from different sensor arrays can be compared directly."
+);
+
+export { CalibrationStatusSchema, FutureUpgradeSchema, MeasurementSchema, MeasurementUncertaintySchema, ModalitySchema, RawDataSpecSchema, RecordsMappingSchema, SensorCalibrationSchema, SensorEntrySchema, SensorManifestSchema, SensorTimingSchema, TimeSourceSchema, UncertaintyTypeSchema, UpgradeStatusSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/manifest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/manifest/types.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import { z } from 'zod';\n\n/**\n * The sensor manifest is the instrument layer of the standard: DisclosureOS\n * records describe *what was observed*; a sensor manifest describes *the\n * hardware that produced the data* — per sensor, in enough structured detail\n * that a field mission or data drop from one organization is comparable,\n * replicable, and verifiable by everyone else.\n *\n * Design lineage: proposed by ELDÆON (disclosurefoundation/disclosureos#5) and\n * promoted into the framework as a foundation package. The manifest is the\n * standard's first standalone document type besides `Observation`: it is not a\n * per-observation extension slot — observations point at manifest entries via\n * `SensorReading.sensorRef` (`\"<org-slug>:<sensor-id>\"`).\n */\n\nconst KEBAB_CASE_PATTERN = /^[a-z0-9][a-z0-9-]*$/;\n\nexport const ModalitySchema = z\n  .enum(['audio', 'electro_optical', 'radio_frequency', 'quantum', 'environmental', 'biometric'])\n  .describe('Top-level sensing modality the sensor belongs to.');\n\nexport type Modality = z.infer<typeof ModalitySchema>;\n\nexport const TimeSourceSchema = z\n  .enum(['atomic_clock', 'gps_disciplined', 'ntp', 'system', 'unknown'])\n  .describe('Clock source that timestamps the sensor\\u2019s data.');\n\nexport type TimeSource = z.infer<typeof TimeSourceSchema>;\n\nexport const SensorTimingSchema = z\n  .object({\n    timeSource: TimeSourceSchema,\n    timeUncertaintyNs: z\n      .number()\n      .nullable()\n      .optional()\n      .describe('Timestamp uncertainty in nanoseconds. Null = not yet characterized.'),\n  })\n  .meta({ id: 'SensorTiming' })\n  .describe(\n    'Timing provenance. Timestamp error of even a few seconds confounds multi-station correlation, so the clock source must be declared, not assumed.',\n  );\n\nexport type SensorTiming = z.infer<typeof SensorTimingSchema>;\n\nexport const RecordsMappingSchema = z\n  .object({\n    sensorType: z\n      .string()\n      .optional()\n      .describe('The `@disclosureos/records` SensorType this sensor maps to.'),\n    detectionMethod: z\n      .string()\n      .optional()\n      .describe('The `@disclosureos/records` DetectionMethod this sensor maps to.'),\n    proposedSensorType: z\n      .boolean()\n      .optional()\n      .describe('True = sensorType is not in the records enum yet and is proposed by the publisher.'),\n    proposedDetectionMethod: z\n      .boolean()\n      .optional()\n      .describe('True = detectionMethod is not in the records enum yet and is proposed by the publisher.'),\n  })\n  .meta({ id: 'RecordsMapping' })\n  .describe(\n    'How this sensor maps to the `SensorReading` vocabulary in `@disclosureos/records`. Values outside the records enums must carry the matching proposed* flag.',\n  );\n\nexport type RecordsMapping = z.infer<typeof RecordsMappingSchema>;\n\nexport const RawDataSpecSchema = z\n  .object({\n    format: z\n      .string()\n      .optional()\n      .describe('Raw-data file format, e.g. \"NDJSON.gz\", \"WAV\", \"MJPEG\", \"FITS\", \"CSV\".'),\n    locatorPattern: z\n      .string()\n      .nullable()\n      .optional()\n      .describe('Storage key pattern or path convention for locating the raw files.'),\n    sampleRateHz: z.number().nullable().optional().describe('Sample rate in Hz, where applicable.'),\n    bitDepth: z.number().nullable().optional().describe('Sample bit depth, where applicable.'),\n  })\n  .meta({ id: 'RawDataSpec' })\n  .describe(\n    'Raw-data format and locator. Supports a metadata-first architecture: circulate manifests widely, pull raw data on demand.',\n  );\n\nexport type RawDataSpec = z.infer<typeof RawDataSpecSchema>;\n\nexport const UncertaintyTypeSchema = z\n  .enum(['A', 'B'])\n  .describe('GUM uncertainty evaluation type: A (statistical) or B (other means).');\n\nexport type UncertaintyType = z.infer<typeof UncertaintyTypeSchema>;\n\nexport const MeasurementUncertaintySchema = z\n  .object({\n    u_c: z.number().nullable().optional().describe('Combined standard uncertainty.'),\n    U: z.number().nullable().optional().describe('Expanded uncertainty (= k \\u00d7 u_c).'),\n    k: z.number().nullable().optional().describe('Coverage factor (2 \\u2248 95% confidence level).'),\n    type: UncertaintyTypeSchema.nullable().optional(),\n  })\n  .meta({ id: 'MeasurementUncertainty' })\n  .describe(\n    'GUM-style measurement uncertainty. Fields are nullable until an uncertainty budget exists — declaring \"unknown\" honestly is itself information.',\n  );\n\nexport type MeasurementUncertainty = z.infer<typeof MeasurementUncertaintySchema>;\n\nexport const MeasurementSchema = z\n  .object({\n    name: z.string().min(1).describe('Measured quantity, e.g. \"differential_pressure\".'),\n    unit: z.string().min(1).describe('UCUM-style unit string, e.g. \"Pa\", \"dB\", \"uT\", \"ppm\", \"/min\".'),\n    uncertainty: MeasurementUncertaintySchema.optional(),\n  })\n  .meta({ id: 'Measurement' })\n  .describe('One measured quantity with its unit and uncertainty.');\n\nexport type Measurement = z.infer<typeof MeasurementSchema>;\n\nexport const CalibrationStatusSchema = z\n  .enum(['none', 'candidate_identified', 'in_practice', 'documented'])\n  .describe(\n    'Calibration maturity gradient: none = no calibration; candidate_identified = a reference is named but not used; in_practice = a real method is performed but not fully budgeted; documented = method + uncertainty budget published.',\n  );\n\nexport type CalibrationStatus = z.infer<typeof CalibrationStatusSchema>;\n\nexport const SensorCalibrationSchema = z\n  .object({\n    status: CalibrationStatusSchema,\n    calibrated: z\n      .boolean()\n      .nullable()\n      .optional()\n      .describe('Coarse calibrated flag, mirroring `SensorReading.calibrated`. Null = undetermined.'),\n    currentMethod: z\n      .string()\n      .nullable()\n      .optional()\n      .describe('What the operator actually does today. Null = no calibration currently performed.'),\n    traceableReference: z\n      .string()\n      .nullable()\n      .optional()\n      .describe('Traceable reference, in use or identified as a candidate (e.g. \"GPS/UTC\", \"USGS/INTERMAGNET\").'),\n    referenceInUse: z\n      .boolean()\n      .nullable()\n      .optional()\n      .describe('True = the traceable reference is part of current practice. False = identified candidate only. Null = undetermined.'),\n    cadence: z.string().nullable().optional().describe('How often calibration is performed.'),\n    uncertaintyBudget: z.string().nullable().optional().describe('Published uncertainty budget, if any.'),\n    notes: z.string().nullable().optional().describe('Open questions or method caveats.'),\n  })\n  .meta({ id: 'SensorCalibration' })\n  .describe(\n    'Calibration provenance. Deliberately separates what an operator actually does today from the reference it has identified; honest nulls are first-class, so calibration gaps stay visible and comparable across operators.',\n  );\n\nexport type SensorCalibration = z.infer<typeof SensorCalibrationSchema>;\n\nexport const SensorEntrySchema = z\n  .object({\n    id: z\n      .string()\n      .regex(KEBAB_CASE_PATTERN)\n      .describe(\n        'Stable kebab-case id, unique within the manifest; addressable from a record via `SensorReading.sensorRef` (\"<org-slug>:<sensor-id>\").',\n      ),\n    name: z.string().min(1).describe('Human-readable sensor name.'),\n    modality: ModalitySchema,\n    manufacturerModel: z\n      .string()\n      .optional()\n      .describe(\n        'Hardware class descriptor. Publishers MAY withhold specific make/model identities and publish spec-level class descriptors instead (e.g. \"dual GM-tube counter\" rather than a product name).',\n      ),\n    inHouse: z.boolean().optional().describe('True if operator-built rather than off-the-shelf.'),\n    compute: z\n      .string()\n      .optional()\n      .describe('The compute unit this sensor is attached to, for platforms with several compute nodes.'),\n    recordsMapping: RecordsMappingSchema.optional(),\n    timing: SensorTimingSchema.optional(),\n    rawData: RawDataSpecSchema.optional(),\n    measurements: z.array(MeasurementSchema).optional(),\n    calibration: SensorCalibrationSchema.optional(),\n    specs: z\n      .record(z.string(), z.unknown())\n      .optional()\n      .describe(\n        'Free-form hardware specifications from the operator\\u2019s spec sheet (resolution, range, sensitivity, interface, \\u2026). Keys vary by modality.',\n      ),\n    specSource: z.string().optional().describe('Provenance of the spec values.'),\n  })\n  .meta({ id: 'SensorEntry' })\n  .describe('One sensor: its class, spec, timing, raw-data locator, measurements, and calibration provenance.');\n\nexport type SensorEntry = z.infer<typeof SensorEntrySchema>;\n\nexport const UpgradeStatusSchema = z\n  .enum(['planned', 'evaluating', 'ordered', 'acquired'])\n  .describe('Acquisition status of a declared future hardware upgrade.');\n\nexport type UpgradeStatus = z.infer<typeof UpgradeStatusSchema>;\n\nexport const FutureUpgradeSchema = z\n  .object({\n    name: z.string().min(1),\n    modality: ModalitySchema,\n    status: UpgradeStatusSchema.optional(),\n    specs: z.record(z.string(), z.unknown()).optional(),\n    link: z.string().nullable().optional().describe('Public product or reference page, where the publisher chooses to share one.'),\n    notes: z.string().nullable().optional(),\n  })\n  .meta({ id: 'FutureUpgrade' })\n  .describe(\n    'Planned hardware declared ahead of deployment so data consumers can anticipate new streams. Not part of the live sensor array.',\n  );\n\nexport type FutureUpgrade = z.infer<typeof FutureUpgradeSchema>;\n\nexport const SensorManifestSchema = z\n  .object({\n    schemaVersion: z.string().min(1).describe('Version of the sensor-manifest schema this instance targets (SemVer).'),\n    org: z.string().min(1).describe('Publishing organization, display form (e.g. \"ELD\\u00c6ON\").'),\n    orgSlug: z\n      .string()\n      .regex(KEBAB_CASE_PATTERN)\n      .describe('Stable lowercase slug for the publisher (e.g. \"eldaeon\"); the org half of a `sensorRef`.'),\n    orgUrl: z.string().optional().describe('URL for the publishing organization.'),\n    generatedAt: z.string().optional().describe('ISO date the manifest was generated.'),\n    sensors: z.array(SensorEntrySchema).min(1),\n    futureUpgrades: z.array(FutureUpgradeSchema).optional(),\n  })\n  .meta({ id: 'SensorManifest' })\n  .describe(\n    'A published catalog of one organization\\u2019s detection hardware. Any operator — vendor, research group, or institution — publishes its own manifest against this schema so datasets from different sensor arrays can be compared directly.',\n  );\n\nexport type SensorManifest = z.infer<typeof SensorManifestSchema>;\n"]}

package/dist/validators/index.d.ts

@@ -0,0 +1,17 @@
+import { ValidationIssue } from '@disclosureos/records/shared';
+
+/**
+ * Validate a sensor manifest. Schema validation plus the structural invariants
+ * Zod cannot express portably:
+ *
+ * 1. sensor ids are unique within the manifest;
+ * 2. every `recordsMapping` value either exists in the `@disclosureos/records`
+ *    enums or carries the matching `proposed*` flag — so a manifest can never
+ *    silently claim a mapping the records vocabulary does not have.
+ *
+ * Returns a flat issue list (empty when valid) — the ecosystem's single
+ * validation contract.
+ */
+declare function validateSensorManifest(value: unknown): ValidationIssue[];
+
+export { validateSensorManifest };

package/dist/validators/index.js

@@ -0,0 +1,138 @@
+import { validateWith } from '@disclosureos/records/shared';
+import { SENSOR_TYPES, DETECTION_METHODS } from '@disclosureos/records/constants';
+import { z } from 'zod';
+
+// src/validators/index.ts
+var KEBAB_CASE_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var ModalitySchema = z.enum(["audio", "electro_optical", "radio_frequency", "quantum", "environmental", "biometric"]).describe("Top-level sensing modality the sensor belongs to.");
+var TimeSourceSchema = z.enum(["atomic_clock", "gps_disciplined", "ntp", "system", "unknown"]).describe("Clock source that timestamps the sensor\u2019s data.");
+var SensorTimingSchema = z.object({
+  timeSource: TimeSourceSchema,
+  timeUncertaintyNs: z.number().nullable().optional().describe("Timestamp uncertainty in nanoseconds. Null = not yet characterized.")
+}).meta({ id: "SensorTiming" }).describe(
+  "Timing provenance. Timestamp error of even a few seconds confounds multi-station correlation, so the clock source must be declared, not assumed."
+);
+var RecordsMappingSchema = z.object({
+  sensorType: z.string().optional().describe("The `@disclosureos/records` SensorType this sensor maps to."),
+  detectionMethod: z.string().optional().describe("The `@disclosureos/records` DetectionMethod this sensor maps to."),
+  proposedSensorType: z.boolean().optional().describe("True = sensorType is not in the records enum yet and is proposed by the publisher."),
+  proposedDetectionMethod: z.boolean().optional().describe("True = detectionMethod is not in the records enum yet and is proposed by the publisher.")
+}).meta({ id: "RecordsMapping" }).describe(
+  "How this sensor maps to the `SensorReading` vocabulary in `@disclosureos/records`. Values outside the records enums must carry the matching proposed* flag."
+);
+var RawDataSpecSchema = z.object({
+  format: z.string().optional().describe('Raw-data file format, e.g. "NDJSON.gz", "WAV", "MJPEG", "FITS", "CSV".'),
+  locatorPattern: z.string().nullable().optional().describe("Storage key pattern or path convention for locating the raw files."),
+  sampleRateHz: z.number().nullable().optional().describe("Sample rate in Hz, where applicable."),
+  bitDepth: z.number().nullable().optional().describe("Sample bit depth, where applicable.")
+}).meta({ id: "RawDataSpec" }).describe(
+  "Raw-data format and locator. Supports a metadata-first architecture: circulate manifests widely, pull raw data on demand."
+);
+var UncertaintyTypeSchema = z.enum(["A", "B"]).describe("GUM uncertainty evaluation type: A (statistical) or B (other means).");
+var MeasurementUncertaintySchema = z.object({
+  u_c: z.number().nullable().optional().describe("Combined standard uncertainty."),
+  U: z.number().nullable().optional().describe("Expanded uncertainty (= k \xD7 u_c)."),
+  k: z.number().nullable().optional().describe("Coverage factor (2 \u2248 95% confidence level)."),
+  type: UncertaintyTypeSchema.nullable().optional()
+}).meta({ id: "MeasurementUncertainty" }).describe(
+  'GUM-style measurement uncertainty. Fields are nullable until an uncertainty budget exists \u2014 declaring "unknown" honestly is itself information.'
+);
+var MeasurementSchema = z.object({
+  name: z.string().min(1).describe('Measured quantity, e.g. "differential_pressure".'),
+  unit: z.string().min(1).describe('UCUM-style unit string, e.g. "Pa", "dB", "uT", "ppm", "/min".'),
+  uncertainty: MeasurementUncertaintySchema.optional()
+}).meta({ id: "Measurement" }).describe("One measured quantity with its unit and uncertainty.");
+var CalibrationStatusSchema = z.enum(["none", "candidate_identified", "in_practice", "documented"]).describe(
+  "Calibration maturity gradient: none = no calibration; candidate_identified = a reference is named but not used; in_practice = a real method is performed but not fully budgeted; documented = method + uncertainty budget published."
+);
+var SensorCalibrationSchema = z.object({
+  status: CalibrationStatusSchema,
+  calibrated: z.boolean().nullable().optional().describe("Coarse calibrated flag, mirroring `SensorReading.calibrated`. Null = undetermined."),
+  currentMethod: z.string().nullable().optional().describe("What the operator actually does today. Null = no calibration currently performed."),
+  traceableReference: z.string().nullable().optional().describe('Traceable reference, in use or identified as a candidate (e.g. "GPS/UTC", "USGS/INTERMAGNET").'),
+  referenceInUse: z.boolean().nullable().optional().describe("True = the traceable reference is part of current practice. False = identified candidate only. Null = undetermined."),
+  cadence: z.string().nullable().optional().describe("How often calibration is performed."),
+  uncertaintyBudget: z.string().nullable().optional().describe("Published uncertainty budget, if any."),
+  notes: z.string().nullable().optional().describe("Open questions or method caveats.")
+}).meta({ id: "SensorCalibration" }).describe(
+  "Calibration provenance. Deliberately separates what an operator actually does today from the reference it has identified; honest nulls are first-class, so calibration gaps stay visible and comparable across operators."
+);
+var SensorEntrySchema = z.object({
+  id: z.string().regex(KEBAB_CASE_PATTERN).describe(
+    'Stable kebab-case id, unique within the manifest; addressable from a record via `SensorReading.sensorRef` ("<org-slug>:<sensor-id>").'
+  ),
+  name: z.string().min(1).describe("Human-readable sensor name."),
+  modality: ModalitySchema,
+  manufacturerModel: z.string().optional().describe(
+    'Hardware class descriptor. Publishers MAY withhold specific make/model identities and publish spec-level class descriptors instead (e.g. "dual GM-tube counter" rather than a product name).'
+  ),
+  inHouse: z.boolean().optional().describe("True if operator-built rather than off-the-shelf."),
+  compute: z.string().optional().describe("The compute unit this sensor is attached to, for platforms with several compute nodes."),
+  recordsMapping: RecordsMappingSchema.optional(),
+  timing: SensorTimingSchema.optional(),
+  rawData: RawDataSpecSchema.optional(),
+  measurements: z.array(MeasurementSchema).optional(),
+  calibration: SensorCalibrationSchema.optional(),
+  specs: z.record(z.string(), z.unknown()).optional().describe(
+    "Free-form hardware specifications from the operator\u2019s spec sheet (resolution, range, sensitivity, interface, \u2026). Keys vary by modality."
+  ),
+  specSource: z.string().optional().describe("Provenance of the spec values.")
+}).meta({ id: "SensorEntry" }).describe("One sensor: its class, spec, timing, raw-data locator, measurements, and calibration provenance.");
+var UpgradeStatusSchema = z.enum(["planned", "evaluating", "ordered", "acquired"]).describe("Acquisition status of a declared future hardware upgrade.");
+var FutureUpgradeSchema = z.object({
+  name: z.string().min(1),
+  modality: ModalitySchema,
+  status: UpgradeStatusSchema.optional(),
+  specs: z.record(z.string(), z.unknown()).optional(),
+  link: z.string().nullable().optional().describe("Public product or reference page, where the publisher chooses to share one."),
+  notes: z.string().nullable().optional()
+}).meta({ id: "FutureUpgrade" }).describe(
+  "Planned hardware declared ahead of deployment so data consumers can anticipate new streams. Not part of the live sensor array."
+);
+var SensorManifestSchema = z.object({
+  schemaVersion: z.string().min(1).describe("Version of the sensor-manifest schema this instance targets (SemVer)."),
+  org: z.string().min(1).describe('Publishing organization, display form (e.g. "ELD\xC6ON").'),
+  orgSlug: z.string().regex(KEBAB_CASE_PATTERN).describe('Stable lowercase slug for the publisher (e.g. "eldaeon"); the org half of a `sensorRef`.'),
+  orgUrl: z.string().optional().describe("URL for the publishing organization."),
+  generatedAt: z.string().optional().describe("ISO date the manifest was generated."),
+  sensors: z.array(SensorEntrySchema).min(1),
+  futureUpgrades: z.array(FutureUpgradeSchema).optional()
+}).meta({ id: "SensorManifest" }).describe(
+  "A published catalog of one organization\u2019s detection hardware. Any operator \u2014 vendor, research group, or institution \u2014 publishes its own manifest against this schema so datasets from different sensor arrays can be compared directly."
+);
+
+// src/validators/index.ts
+var KNOWN_SENSOR_TYPES = new Set(SENSOR_TYPES);
+var KNOWN_DETECTION_METHODS = new Set(DETECTION_METHODS);
+function validateSensorManifest(value) {
+  const issues = validateWith(SensorManifestSchema, value);
+  if (issues.length > 0) return issues;
+  const manifest = value;
+  const seenIds = /* @__PURE__ */ new Set();
+  manifest.sensors.forEach((sensor, index) => {
+    const path = `sensors.${index}`;
+    if (seenIds.has(sensor.id)) {
+      issues.push({ path: `${path}.id`, message: `Duplicate sensor id "${sensor.id}".` });
+    }
+    seenIds.add(sensor.id);
+    const mapping = sensor.recordsMapping;
+    if (!mapping) return;
+    if (mapping.sensorType !== void 0 && !KNOWN_SENSOR_TYPES.has(mapping.sensorType) && mapping.proposedSensorType !== true) {
+      issues.push({
+        path: `${path}.recordsMapping.sensorType`,
+        message: `"${mapping.sensorType}" is not a records SensorType; flag it with proposedSensorType: true or use a value from the enum.`
+      });
+    }
+    if (mapping.detectionMethod !== void 0 && !KNOWN_DETECTION_METHODS.has(mapping.detectionMethod) && mapping.proposedDetectionMethod !== true) {
+      issues.push({
+        path: `${path}.recordsMapping.detectionMethod`,
+        message: `"${mapping.detectionMethod}" is not a records DetectionMethod; flag it with proposedDetectionMethod: true or use a value from the enum.`
+      });
+    }
+  });
+  return issues;
+}
+
+export { validateSensorManifest };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/validators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/manifest/types.ts","../../src/validators/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import { z } from 'zod';\n\n/**\n * The sensor manifest is the instrument layer of the standard: DisclosureOS\n * records describe *what was observed*; a sensor manifest describes *the\n * hardware that produced the data* — per sensor, in enough structured detail\n * that a field mission or data drop from one organization is comparable,\n * replicable, and verifiable by everyone else.\n *\n * Design lineage: proposed by ELDÆON (disclosurefoundation/disclosureos#5) and\n * promoted into the framework as a foundation package. The manifest is the\n * standard's first standalone document type besides `Observation`: it is not a\n * per-observation extension slot — observations point at manifest entries via\n * `SensorReading.sensorRef` (`\"<org-slug>:<sensor-id>\"`).\n */\n\nconst KEBAB_CASE_PATTERN = /^[a-z0-9][a-z0-9-]*$/;\n\nexport const ModalitySchema = z\n  .enum(['audio', 'electro_optical', 'radio_frequency', 'quantum', 'environmental', 'biometric'])\n  .describe('Top-level sensing modality the sensor belongs to.');\n\nexport type Modality = z.infer<typeof ModalitySchema>;\n\nexport const TimeSourceSchema = z\n  .enum(['atomic_clock', 'gps_disciplined', 'ntp', 'system', 'unknown'])\n  .describe('Clock source that timestamps the sensor\\u2019s data.');\n\nexport type TimeSource = z.infer<typeof TimeSourceSchema>;\n\nexport const SensorTimingSchema = z\n  .object({\n    timeSource: TimeSourceSchema,\n    timeUncertaintyNs: z\n      .number()\n      .nullable()\n      .optional()\n      .describe('Timestamp uncertainty in nanoseconds. Null = not yet characterized.'),\n  })\n  .meta({ id: 'SensorTiming' })\n  .describe(\n    'Timing provenance. Timestamp error of even a few seconds confounds multi-station correlation, so the clock source must be declared, not assumed.',\n  );\n\nexport type SensorTiming = z.infer<typeof SensorTimingSchema>;\n\nexport const RecordsMappingSchema = z\n  .object({\n    sensorType: z\n      .string()\n      .optional()\n      .describe('The `@disclosureos/records` SensorType this sensor maps to.'),\n    detectionMethod: z\n      .string()\n      .optional()\n      .describe('The `@disclosureos/records` DetectionMethod this sensor maps to.'),\n    proposedSensorType: z\n      .boolean()\n      .optional()\n      .describe('True = sensorType is not in the records enum yet and is proposed by the publisher.'),\n    proposedDetectionMethod: z\n      .boolean()\n      .optional()\n      .describe('True = detectionMethod is not in the records enum yet and is proposed by the publisher.'),\n  })\n  .meta({ id: 'RecordsMapping' })\n  .describe(\n    'How this sensor maps to the `SensorReading` vocabulary in `@disclosureos/records`. Values outside the records enums must carry the matching proposed* flag.',\n  );\n\nexport type RecordsMapping = z.infer<typeof RecordsMappingSchema>;\n\nexport const RawDataSpecSchema = z\n  .object({\n    format: z\n      .string()\n      .optional()\n      .describe('Raw-data file format, e.g. \"NDJSON.gz\", \"WAV\", \"MJPEG\", \"FITS\", \"CSV\".'),\n    locatorPattern: z\n      .string()\n      .nullable()\n      .optional()\n      .describe('Storage key pattern or path convention for locating the raw files.'),\n    sampleRateHz: z.number().nullable().optional().describe('Sample rate in Hz, where applicable.'),\n    bitDepth: z.number().nullable().optional().describe('Sample bit depth, where applicable.'),\n  })\n  .meta({ id: 'RawDataSpec' })\n  .describe(\n    'Raw-data format and locator. Supports a metadata-first architecture: circulate manifests widely, pull raw data on demand.',\n  );\n\nexport type RawDataSpec = z.infer<typeof RawDataSpecSchema>;\n\nexport const UncertaintyTypeSchema = z\n  .enum(['A', 'B'])\n  .describe('GUM uncertainty evaluation type: A (statistical) or B (other means).');\n\nexport type UncertaintyType = z.infer<typeof UncertaintyTypeSchema>;\n\nexport const MeasurementUncertaintySchema = z\n  .object({\n    u_c: z.number().nullable().optional().describe('Combined standard uncertainty.'),\n    U: z.number().nullable().optional().describe('Expanded uncertainty (= k \\u00d7 u_c).'),\n    k: z.number().nullable().optional().describe('Coverage factor (2 \\u2248 95% confidence level).'),\n    type: UncertaintyTypeSchema.nullable().optional(),\n  })\n  .meta({ id: 'MeasurementUncertainty' })\n  .describe(\n    'GUM-style measurement uncertainty. Fields are nullable until an uncertainty budget exists — declaring \"unknown\" honestly is itself information.',\n  );\n\nexport type MeasurementUncertainty = z.infer<typeof MeasurementUncertaintySchema>;\n\nexport const MeasurementSchema = z\n  .object({\n    name: z.string().min(1).describe('Measured quantity, e.g. \"differential_pressure\".'),\n    unit: z.string().min(1).describe('UCUM-style unit string, e.g. \"Pa\", \"dB\", \"uT\", \"ppm\", \"/min\".'),\n    uncertainty: MeasurementUncertaintySchema.optional(),\n  })\n  .meta({ id: 'Measurement' })\n  .describe('One measured quantity with its unit and uncertainty.');\n\nexport type Measurement = z.infer<typeof MeasurementSchema>;\n\nexport const CalibrationStatusSchema = z\n  .enum(['none', 'candidate_identified', 'in_practice', 'documented'])\n  .describe(\n    'Calibration maturity gradient: none = no calibration; candidate_identified = a reference is named but not used; in_practice = a real method is performed but not fully budgeted; documented = method + uncertainty budget published.',\n  );\n\nexport type CalibrationStatus = z.infer<typeof CalibrationStatusSchema>;\n\nexport const SensorCalibrationSchema = z\n  .object({\n    status: CalibrationStatusSchema,\n    calibrated: z\n      .boolean()\n      .nullable()\n      .optional()\n      .describe('Coarse calibrated flag, mirroring `SensorReading.calibrated`. Null = undetermined.'),\n    currentMethod: z\n      .string()\n      .nullable()\n      .optional()\n      .describe('What the operator actually does today. Null = no calibration currently performed.'),\n    traceableReference: z\n      .string()\n      .nullable()\n      .optional()\n      .describe('Traceable reference, in use or identified as a candidate (e.g. \"GPS/UTC\", \"USGS/INTERMAGNET\").'),\n    referenceInUse: z\n      .boolean()\n      .nullable()\n      .optional()\n      .describe('True = the traceable reference is part of current practice. False = identified candidate only. Null = undetermined.'),\n    cadence: z.string().nullable().optional().describe('How often calibration is performed.'),\n    uncertaintyBudget: z.string().nullable().optional().describe('Published uncertainty budget, if any.'),\n    notes: z.string().nullable().optional().describe('Open questions or method caveats.'),\n  })\n  .meta({ id: 'SensorCalibration' })\n  .describe(\n    'Calibration provenance. Deliberately separates what an operator actually does today from the reference it has identified; honest nulls are first-class, so calibration gaps stay visible and comparable across operators.',\n  );\n\nexport type SensorCalibration = z.infer<typeof SensorCalibrationSchema>;\n\nexport const SensorEntrySchema = z\n  .object({\n    id: z\n      .string()\n      .regex(KEBAB_CASE_PATTERN)\n      .describe(\n        'Stable kebab-case id, unique within the manifest; addressable from a record via `SensorReading.sensorRef` (\"<org-slug>:<sensor-id>\").',\n      ),\n    name: z.string().min(1).describe('Human-readable sensor name.'),\n    modality: ModalitySchema,\n    manufacturerModel: z\n      .string()\n      .optional()\n      .describe(\n        'Hardware class descriptor. Publishers MAY withhold specific make/model identities and publish spec-level class descriptors instead (e.g. \"dual GM-tube counter\" rather than a product name).',\n      ),\n    inHouse: z.boolean().optional().describe('True if operator-built rather than off-the-shelf.'),\n    compute: z\n      .string()\n      .optional()\n      .describe('The compute unit this sensor is attached to, for platforms with several compute nodes.'),\n    recordsMapping: RecordsMappingSchema.optional(),\n    timing: SensorTimingSchema.optional(),\n    rawData: RawDataSpecSchema.optional(),\n    measurements: z.array(MeasurementSchema).optional(),\n    calibration: SensorCalibrationSchema.optional(),\n    specs: z\n      .record(z.string(), z.unknown())\n      .optional()\n      .describe(\n        'Free-form hardware specifications from the operator\\u2019s spec sheet (resolution, range, sensitivity, interface, \\u2026). Keys vary by modality.',\n      ),\n    specSource: z.string().optional().describe('Provenance of the spec values.'),\n  })\n  .meta({ id: 'SensorEntry' })\n  .describe('One sensor: its class, spec, timing, raw-data locator, measurements, and calibration provenance.');\n\nexport type SensorEntry = z.infer<typeof SensorEntrySchema>;\n\nexport const UpgradeStatusSchema = z\n  .enum(['planned', 'evaluating', 'ordered', 'acquired'])\n  .describe('Acquisition status of a declared future hardware upgrade.');\n\nexport type UpgradeStatus = z.infer<typeof UpgradeStatusSchema>;\n\nexport const FutureUpgradeSchema = z\n  .object({\n    name: z.string().min(1),\n    modality: ModalitySchema,\n    status: UpgradeStatusSchema.optional(),\n    specs: z.record(z.string(), z.unknown()).optional(),\n    link: z.string().nullable().optional().describe('Public product or reference page, where the publisher chooses to share one.'),\n    notes: z.string().nullable().optional(),\n  })\n  .meta({ id: 'FutureUpgrade' })\n  .describe(\n    'Planned hardware declared ahead of deployment so data consumers can anticipate new streams. Not part of the live sensor array.',\n  );\n\nexport type FutureUpgrade = z.infer<typeof FutureUpgradeSchema>;\n\nexport const SensorManifestSchema = z\n  .object({\n    schemaVersion: z.string().min(1).describe('Version of the sensor-manifest schema this instance targets (SemVer).'),\n    org: z.string().min(1).describe('Publishing organization, display form (e.g. \"ELD\\u00c6ON\").'),\n    orgSlug: z\n      .string()\n      .regex(KEBAB_CASE_PATTERN)\n      .describe('Stable lowercase slug for the publisher (e.g. \"eldaeon\"); the org half of a `sensorRef`.'),\n    orgUrl: z.string().optional().describe('URL for the publishing organization.'),\n    generatedAt: z.string().optional().describe('ISO date the manifest was generated.'),\n    sensors: z.array(SensorEntrySchema).min(1),\n    futureUpgrades: z.array(FutureUpgradeSchema).optional(),\n  })\n  .meta({ id: 'SensorManifest' })\n  .describe(\n    'A published catalog of one organization\\u2019s detection hardware. Any operator — vendor, research group, or institution — publishes its own manifest against this schema so datasets from different sensor arrays can be compared directly.',\n  );\n\nexport type SensorManifest = z.infer<typeof SensorManifestSchema>;\n","import { validateWith } from '@disclosureos/records/shared';\nimport type { ValidationIssue } from '@disclosureos/records/shared';\nimport { SENSOR_TYPES, DETECTION_METHODS } from '@disclosureos/records/constants';\nimport { SensorManifestSchema } from '../manifest/types';\nimport type { SensorManifest } from '../manifest/types';\n\nconst KNOWN_SENSOR_TYPES = new Set<string>(SENSOR_TYPES);\nconst KNOWN_DETECTION_METHODS = new Set<string>(DETECTION_METHODS);\n\n/**\n * Validate a sensor manifest. Schema validation plus the structural invariants\n * Zod cannot express portably:\n *\n * 1. sensor ids are unique within the manifest;\n * 2. every `recordsMapping` value either exists in the `@disclosureos/records`\n *    enums or carries the matching `proposed*` flag — so a manifest can never\n *    silently claim a mapping the records vocabulary does not have.\n *\n * Returns a flat issue list (empty when valid) — the ecosystem's single\n * validation contract.\n */\nexport function validateSensorManifest(value: unknown): ValidationIssue[] {\n  const issues = validateWith(SensorManifestSchema, value);\n  if (issues.length > 0) return issues;\n\n  const manifest = value as SensorManifest;\n  const seenIds = new Set<string>();\n\n  manifest.sensors.forEach((sensor, index) => {\n    const path = `sensors.${index}`;\n\n    if (seenIds.has(sensor.id)) {\n      issues.push({ path: `${path}.id`, message: `Duplicate sensor id \"${sensor.id}\".` });\n    }\n    seenIds.add(sensor.id);\n\n    const mapping = sensor.recordsMapping;\n    if (!mapping) return;\n\n    if (\n      mapping.sensorType !== undefined\n      && !KNOWN_SENSOR_TYPES.has(mapping.sensorType)\n      && mapping.proposedSensorType !== true\n    ) {\n      issues.push({\n        path: `${path}.recordsMapping.sensorType`,\n        message:\n          `\"${mapping.sensorType}\" is not a records SensorType; flag it with proposedSensorType: true or use a value from the enum.`,\n      });\n    }\n\n    if (\n      mapping.detectionMethod !== undefined\n      && !KNOWN_DETECTION_METHODS.has(mapping.detectionMethod)\n      && mapping.proposedDetectionMethod !== true\n    ) {\n      issues.push({\n        path: `${path}.recordsMapping.detectionMethod`,\n        message:\n          `\"${mapping.detectionMethod}\" is not a records DetectionMethod; flag it with proposedDetectionMethod: true or use a value from the enum.`,\n      });\n    }\n  });\n\n  return issues;\n}\n"]}