@disclosureos/instruments 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,37 @@
+# @disclosureos/instruments
+
+All notable changes to `@disclosureos/instruments` are documented here. The format is
+based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 1.0.0
+
+### Major Changes
+
+- b373962: Initial release: the **UAP Sensor Manifest** standard — the DisclosureOS
+  standard's first standalone document type besides `Observation`.
+
+  A `SensorManifest` catalogs one organization's detection hardware per sensor:
+  modality, records-enum mapping, timing provenance, measurements with GUM
+  uncertainty, raw-data locators, and calibration provenance under a
+  `none → candidate_identified → in_practice → documented` maturity gradient.
+
+  Ships the full DX quintet (labels, constants, guards, factories, formatters),
+  `validateSensorManifest` (schema + unique-id + unflagged-mapping invariants),
+  and a drift-tested JSON Schema artifact at
+  `https://os.disclosure.org/schema/instruments/1.0.0/sensor-manifest.json`.
+
+  Sensor readings in `@disclosureos/records` cite manifest entries through
+  `SensorReading.sensorRef` (`"<org-slug>:<sensor-id>"`), and
+  `@disclosureos/scoring` consumes manifests through the `calibrationTrust`
+  evaluator-weight hook.
+
+  Proposed by [ELDÆON](https://eldaeon.com/)
+  ([#5](https://github.com/disclosurefoundation/disclosureos/pull/5)), the
+  standard's first external contribution, and promoted into the framework as a
+  foundation package.
+
+### Patch Changes
+
+- Updated dependencies [e6ff99c]
+  - @disclosureos/records@1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Disclosure Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,131 @@
+# @disclosureos/instruments
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+The **UAP Sensor Manifest** — a per-sensor specification standard for detection
+hardware in the [DisclosureOS](https://github.com/disclosurefoundation) ecosystem.
+DisclosureOS records describe *what was observed*; a sensor manifest describes
+*the hardware that produced the data*, so field missions and data drops from
+different organizations are comparable, replicable, and verifiable.
+
+Proposed by [ELDÆON](https://github.com/disclosurefoundation/disclosureos/pull/5)
+and promoted into the framework as a foundation package.
+
+DisclosureOS is a **six-part standard**. Each part answers one question about an
+observation; `@disclosureos/schema` binds the package-owned pieces into one portable
+contract (a single TS type + JSON Schema + non-stripping parse).
+
+| Part | Package surface | Question it answers |
+|---|---|---|
+| **Records** | `@disclosureos/records` | *What was observed?* |
+| **Observables** | `@disclosureos/observables` | *What anomalous characteristics did it show?* |
+| **Origins** | `@disclosureos/origins` | *What might explain it?* |
+| **Claims** | `@disclosureos/records/shared` | *Who assessed it, why, and on what evidence?* |
+| **Scoring** | `@disclosureos/scoring` | *How complete / compelling is the case?* |
+| **Instruments** | `@disclosureos/instruments` | *What hardware produced the data?* |
+
+Supporting packages: **`@disclosureos/schema`** (the portable contract that composes the
+package-owned pieces), **`@disclosureos/cli`** (tooling), and
+**`@disclosureos/examples`** (the runnable golden path). *(You are here: **Instruments**.)*
+
+> **See it end to end.** [`examples/golden-path.ts`](../../examples/golden-path.ts)
+> takes one observation through every part — including a sensor manifest cited via
+> `SensorReading.sensorRef` — in a single type-checked file. Run it with
+> `pnpm --filter @disclosureos/examples golden-path`.
+
+## The manifest is a standalone document
+
+Unlike `observables` and `origins`, this package does not add a slot to
+`Observation`. A `SensorManifest` is the standard's first standalone document
+type: each organization publishes its own manifest (a catalog of its sensors),
+and observations point at manifest entries from sensor readings:
+
+```ts
+import { createSensorReading } from '@disclosureos/records/factories';
+import { sensorRef } from '@disclosureos/records/shared';
+
+const reading = createSensorReading('passive_radar', 'radio_frequency', {
+  id: 'r1',
+  sensorRef: sensorRef('eldaeon', 'dionysus-passive-radar'), // "<org-slug>:<sensor-id>"
+});
+```
+
+## What each sensor entry captures
+
+The functional hardware context `SensorReading` deliberately does not carry:
+
+- **Type mapping** — `recordsMapping` bridges each sensor to the
+  `@disclosureos/records` `SensorType`/`DetectionMethod` enums; values outside
+  those enums must carry a `proposedSensorType`/`proposedDetectionMethod` flag.
+- **Timing provenance** — clock source (`atomic_clock`, `gps_disciplined`, …) and
+  timestamp uncertainty. Multi-station correlation requires declared, not
+  assumed, timing.
+- **Measurements + uncertainty** — measured quantities with UCUM-style units and
+  GUM uncertainty (`u_c`, `U`, `k`, type A/B).
+- **Raw-data locators** — format and path convention, supporting a
+  metadata-first architecture (circulate manifests widely, pull raw data on
+  demand).
+- **Calibration provenance** — the package's centerpiece. `currentMethod` (what
+  the operator actually does today) is separated from `traceableReference` +
+  `referenceInUse` (the reference it has identified, and whether it is used),
+  under a maturity gradient:
+
+  `none → candidate_identified → in_practice → documented`
+
+  Declaring "no calibration" is valid and *useful* — the degree of calibration
+  is known, which is the scientific requirement. Honest nulls are first-class
+  throughout the calibration block.
+
+## Install
+
+```bash
+pnpm add @disclosureos/instruments zod
+```
+
+## Usage
+
+```ts
+import {
+  createSensorEntry,
+  createSensorManifest,
+  validateSensorManifest,
+  formatSensorManifest,
+} from '@disclosureos/instruments';
+
+const radar = createSensorEntry('dionysus-passive-radar', 'Passive Bistatic Radar', 'radio_frequency', {
+  recordsMapping: { sensorType: 'passive_radar', detectionMethod: 'radio_frequency' },
+  timing: { timeSource: 'gps_disciplined' },
+  calibration: {
+    status: 'in_practice',
+    currentMethod: 'continuous ADS-B truth association with match residuals recorded',
+    traceableReference: 'ADS-B Exchange',
+    referenceInUse: true,
+  },
+});
+
+const manifest = createSensorManifest('ELDÆON', 'eldaeon', [radar]);
+
+validateSensorManifest(manifest); // [] when valid — flat ValidationIssue[] otherwise
+formatSensorManifest(manifest);   // "ELDÆON — 1 sensor across 1 modality"
+```
+
+Validate manifest files from the command line:
+
+```bash
+pnpm dlx @disclosureos/cli manifest validate ./manifests/eldaeon-sensors.json
+```
+
+## JSON Schema
+
+The package emits a committed, drift-tested JSON Schema artifact
+(`schema/sensor-manifest.schema.json`) hosted at:
+
+```
+https://os.disclosure.org/schema/instruments/1.0.0/sensor-manifest.json
+```
+
+Non-TS toolchains validate manifests against that `$id` directly.
+
+## License
+
+MIT © Disclosure Foundation

package/dist/constants/index.d.ts

@@ -0,0 +1,7 @@
+declare const MODALITIES: ("audio" | "electro_optical" | "radio_frequency" | "quantum" | "environmental" | "biometric")[];
+declare const TIME_SOURCES: ("atomic_clock" | "gps_disciplined" | "ntp" | "system" | "unknown")[];
+declare const CALIBRATION_STATUSES: ("none" | "candidate_identified" | "in_practice" | "documented")[];
+declare const UPGRADE_STATUSES: ("planned" | "evaluating" | "ordered" | "acquired")[];
+declare const UNCERTAINTY_TYPES: ("A" | "B")[];
+
+export { CALIBRATION_STATUSES, MODALITIES, TIME_SOURCES, UNCERTAINTY_TYPES, UPGRADE_STATUSES };

package/dist/constants/index.js

@@ -0,0 +1,111 @@
+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."
+);
+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/constants/index.ts
+var MODALITIES = ModalitySchema.options;
+var TIME_SOURCES = TimeSourceSchema.options;
+var CALIBRATION_STATUSES = CalibrationStatusSchema.options;
+var UPGRADE_STATUSES = UpgradeStatusSchema.options;
+var UNCERTAINTY_TYPES = UncertaintyTypeSchema.options;
+
+export { CALIBRATION_STATUSES, MODALITIES, TIME_SOURCES, UNCERTAINTY_TYPES, UPGRADE_STATUSES };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/manifest/types.ts","../../src/constants/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 {\n  ModalitySchema,\n  TimeSourceSchema,\n  CalibrationStatusSchema,\n  UpgradeStatusSchema,\n  UncertaintyTypeSchema,\n} from '../manifest/types';\n\nexport const MODALITIES = ModalitySchema.options;\nexport const TIME_SOURCES = TimeSourceSchema.options;\nexport const CALIBRATION_STATUSES = CalibrationStatusSchema.options;\nexport const UPGRADE_STATUSES = UpgradeStatusSchema.options;\nexport const UNCERTAINTY_TYPES = UncertaintyTypeSchema.options;\n"]}

package/dist/factories/index.d.ts

@@ -0,0 +1,15 @@
+import { Modality, SensorEntry, SensorManifest } from '../manifest/index.js';
+import 'zod';
+
+/**
+ * Build a sensor entry from the three required fields, with everything else
+ * supplied via `options`.
+ */
+declare function createSensorEntry(id: string, name: string, modality: Modality, options?: Partial<Omit<SensorEntry, 'id' | 'name' | 'modality'>>): SensorEntry;
+/**
+ * Build a sensor manifest. `schemaVersion` defaults to the version of the
+ * schema this package emits.
+ */
+declare function createSensorManifest(org: string, orgSlug: string, sensors: SensorEntry[], options?: Partial<Omit<SensorManifest, 'org' | 'orgSlug' | 'sensors'>>): SensorManifest;
+
+export { createSensorEntry, createSensorManifest };

package/dist/factories/index.js

@@ -0,0 +1,28 @@
+import 'zod';
+import { schemaId } from '@disclosureos/records/shared';
+
+// src/schema.ts
+var INSTRUMENTS_SCHEMA_VERSION = "1.0.0";
+schemaId(
+  "instruments",
+  "sensor-manifest",
+  INSTRUMENTS_SCHEMA_VERSION
+);
+
+// src/factories/index.ts
+function createSensorEntry(id, name, modality, options) {
+  return { id, name, modality, ...options };
+}
+function createSensorManifest(org, orgSlug, sensors, options) {
+  return {
+    schemaVersion: INSTRUMENTS_SCHEMA_VERSION,
+    org,
+    orgSlug,
+    sensors,
+    ...options
+  };
+}
+
+export { createSensorEntry, createSensorManifest };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/factories/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schema.ts","../../src/factories/index.ts"],"names":[],"mappings":";;;;AASO,IAAM,0BAAA,GAA6B,OAAA;AAEL,QAAA;AAAA,EACnC,aAAA;AAAA,EACA,iBAAA;AAAA,EACA;AACF;;;ACRO,SAAS,iBAAA,CACd,EAAA,EACA,IAAA,EACA,QAAA,EACA,OAAA,EACa;AACb,EAAA,OAAO,EAAE,EAAA,EAAI,IAAA,EAAM,QAAA,EAAU,GAAG,OAAA,EAAQ;AAC1C;AAMO,SAAS,oBAAA,CACd,GAAA,EACA,OAAA,EACA,OAAA,EACA,OAAA,EACgB;AAChB,EAAA,OAAO;AAAA,IACL,aAAA,EAAe,0BAAA;AAAA,IACf,GAAA;AAAA,IACA,OAAA;AAAA,IACA,OAAA;AAAA,IACA,GAAG;AAAA,GACL;AACF","file":"index.js","sourcesContent":["import { z } from 'zod';\nimport { jsonSchemaEnvelope, schemaId } from '@disclosureos/records/shared';\nimport { SensorManifestSchema } from './manifest/types';\n\n/**\n * Version of the emitted JSON Schema artifact. Bump on any intentional change\n * to the manifest shape; the committed `schema/sensor-manifest.schema.json` and\n * the drift test (`src/__tests__/schema.test.ts`) keep this honest.\n */\nexport const INSTRUMENTS_SCHEMA_VERSION = '1.0.0';\n\nexport const INSTRUMENTS_SCHEMA_ID = schemaId(\n  'instruments',\n  'sensor-manifest',\n  INSTRUMENTS_SCHEMA_VERSION,\n);\n\n/**\n * Emit the canonical JSON Schema (draft 2020-12) for {@link SensorManifestSchema}.\n * Unlike the satellite slot schemas, this is a standalone document schema — a\n * manifest is published on its own, not composed into `Observation`.\n */\nexport function instrumentsJsonSchema(): Record<string, unknown> {\n  const schema = z.toJSONSchema(SensorManifestSchema, { target: 'draft-2020-12' }) as Record<\n    string,\n    unknown\n  >;\n  return jsonSchemaEnvelope(schema, {\n    id: INSTRUMENTS_SCHEMA_ID,\n    version: INSTRUMENTS_SCHEMA_VERSION,\n  });\n}\n","import type { Modality, SensorEntry, SensorManifest } from '../manifest/types';\nimport { INSTRUMENTS_SCHEMA_VERSION } from '../schema';\n\n/**\n * Build a sensor entry from the three required fields, with everything else\n * supplied via `options`.\n */\nexport function createSensorEntry(\n  id: string,\n  name: string,\n  modality: Modality,\n  options?: Partial<Omit<SensorEntry, 'id' | 'name' | 'modality'>>,\n): SensorEntry {\n  return { id, name, modality, ...options };\n}\n\n/**\n * Build a sensor manifest. `schemaVersion` defaults to the version of the\n * schema this package emits.\n */\nexport function createSensorManifest(\n  org: string,\n  orgSlug: string,\n  sensors: SensorEntry[],\n  options?: Partial<Omit<SensorManifest, 'org' | 'orgSlug' | 'sensors'>>,\n): SensorManifest {\n  return {\n    schemaVersion: INSTRUMENTS_SCHEMA_VERSION,\n    org,\n    orgSlug,\n    sensors,\n    ...options,\n  };\n}\n"]}

package/dist/formatters/index.d.ts

@@ -0,0 +1,11 @@
+import { CalibrationStatus, Modality, SensorEntry, SensorManifest } from '../manifest/index.js';
+import 'zod';
+
+declare function formatModality(modality: Modality): string;
+declare function formatCalibrationStatus(status: CalibrationStatus): string;
+/** One-line sensor summary, e.g. `"Passive Bistatic Radar (Radio Frequency) — calibration: In Practice"`. */
+declare function formatSensorEntry(sensor: SensorEntry): string;
+/** One-line manifest summary, e.g. `"ELDÆON — 28 sensors across 6 modalities, 3 future upgrades"`. */
+declare function formatSensorManifest(manifest: SensorManifest): string;
+
+export { formatCalibrationStatus, formatModality, formatSensorEntry, formatSensorManifest };

package/dist/formatters/index.js

@@ -0,0 +1,38 @@
+// src/labels/index.ts
+var MODALITY_LABELS = {
+  audio: "Audio",
+  electro_optical: "Electro-Optical",
+  radio_frequency: "Radio Frequency",
+  quantum: "Quantum",
+  environmental: "Environmental",
+  biometric: "Biometric"
+};
+var CALIBRATION_STATUS_LABELS = {
+  none: "None",
+  candidate_identified: "Candidate Identified",
+  in_practice: "In Practice",
+  documented: "Documented"
+};
+
+// src/formatters/index.ts
+function formatModality(modality) {
+  return MODALITY_LABELS[modality];
+}
+function formatCalibrationStatus(status) {
+  return CALIBRATION_STATUS_LABELS[status];
+}
+function formatSensorEntry(sensor) {
+  const calibration = sensor.calibration ? ` \u2014 calibration: ${formatCalibrationStatus(sensor.calibration.status)}` : "";
+  return `${sensor.name} (${formatModality(sensor.modality)})${calibration}`;
+}
+function formatSensorManifest(manifest) {
+  const modalityCount = new Set(manifest.sensors.map((sensor) => sensor.modality)).size;
+  const sensorCount = manifest.sensors.length;
+  const upgrades = manifest.futureUpgrades?.length ?? 0;
+  const upgradeSuffix = upgrades > 0 ? `, ${upgrades} future upgrade${upgrades === 1 ? "" : "s"}` : "";
+  return `${manifest.org} \u2014 ${sensorCount} sensor${sensorCount === 1 ? "" : "s"} across ${modalityCount} modalit${modalityCount === 1 ? "y" : "ies"}${upgradeSuffix}`;
+}
+
+export { formatCalibrationStatus, formatModality, formatSensorEntry, formatSensorManifest };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/formatters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/labels/index.ts","../../src/formatters/index.ts"],"names":[],"mappings":";AAEO,IAAM,eAAA,GAA4C;AAAA,EACvD,KAAA,EAAO,OAAA;AAAA,EACP,eAAA,EAAiB,iBAAA;AAAA,EACjB,eAAA,EAAiB,iBAAA;AAAA,EACjB,OAAA,EAAS,SAAA;AAAA,EACT,aAAA,EAAe,eAAA;AAAA,EACf,SAAA,EAAW;AACb,CAAA;AAUO,IAAM,yBAAA,GAA+D;AAAA,EAC1E,IAAA,EAAM,MAAA;AAAA,EACN,oBAAA,EAAsB,sBAAA;AAAA,EACtB,WAAA,EAAa,aAAA;AAAA,EACb,UAAA,EAAY;AACd,CAAA;;;ACrBO,SAAS,eAAe,QAAA,EAA4B;AACzD,EAAA,OAAO,gBAAgB,QAAQ,CAAA;AACjC;AAEO,SAAS,wBAAwB,MAAA,EAAmC;AACzE,EAAA,OAAO,0BAA0B,MAAM,CAAA;AACzC;AAGO,SAAS,kBAAkB,MAAA,EAA6B;AAC7D,EAAA,MAAM,WAAA,GAAc,OAAO,WAAA,GACvB,CAAA,qBAAA,EAAmB,wBAAwB,MAAA,CAAO,WAAA,CAAY,MAAM,CAAC,CAAA,CAAA,GACrE,EAAA;AACJ,EAAA,OAAO,CAAA,EAAG,OAAO,IAAI,CAAA,EAAA,EAAK,eAAe,MAAA,CAAO,QAAQ,CAAC,CAAA,CAAA,EAAI,WAAW,CAAA,CAAA;AAC1E;AAGO,SAAS,qBAAqB,QAAA,EAAkC;AACrE,EAAA,MAAM,aAAA,GAAgB,IAAI,GAAA,CAAI,QAAA,CAAS,OAAA,CAAQ,GAAA,CAAI,CAAC,MAAA,KAAW,MAAA,CAAO,QAAQ,CAAC,CAAA,CAAE,IAAA;AACjF,EAAA,MAAM,WAAA,GAAc,SAAS,OAAA,CAAQ,MAAA;AACrC,EAAA,MAAM,QAAA,GAAW,QAAA,CAAS,cAAA,EAAgB,MAAA,IAAU,CAAA;AACpD,EAAA,MAAM,aAAA,GAAgB,QAAA,GAAW,CAAA,GAAI,CAAA,EAAA,EAAK,QAAQ,kBAAkB,QAAA,KAAa,CAAA,GAAI,EAAA,GAAK,GAAG,CAAA,CAAA,GAAK,EAAA;AAClG,EAAA,OAAO,GAAG,QAAA,CAAS,GAAG,WAAM,WAAW,CAAA,OAAA,EAAU,gBAAgB,CAAA,GAAI,EAAA,GAAK,GAAG,CAAA,QAAA,EAAW,aAAa,CAAA,QAAA,EAAW,aAAA,KAAkB,IAAI,GAAA,GAAM,KAAK,GAAG,aAAa,CAAA,CAAA;AACnK","file":"index.js","sourcesContent":["import type { Modality, TimeSource, CalibrationStatus, UpgradeStatus } from '../manifest/types';\n\nexport const MODALITY_LABELS: Record<Modality, string> = {\n  audio: 'Audio',\n  electro_optical: 'Electro-Optical',\n  radio_frequency: 'Radio Frequency',\n  quantum: 'Quantum',\n  environmental: 'Environmental',\n  biometric: 'Biometric',\n};\n\nexport const TIME_SOURCE_LABELS: Record<TimeSource, string> = {\n  atomic_clock: 'Atomic Clock',\n  gps_disciplined: 'GPS-Disciplined',\n  ntp: 'NTP',\n  system: 'System Clock',\n  unknown: 'Unknown',\n};\n\nexport const CALIBRATION_STATUS_LABELS: Record<CalibrationStatus, string> = {\n  none: 'None',\n  candidate_identified: 'Candidate Identified',\n  in_practice: 'In Practice',\n  documented: 'Documented',\n};\n\n/** What each rung of the calibration maturity gradient means for a data consumer. */\nexport const CALIBRATION_STATUS_DESCRIPTIONS: Record<CalibrationStatus, string> = {\n  none: 'No calibration is performed. Declared honestly, this is itself useful information.',\n  candidate_identified: 'A traceable reference has been named but is not yet part of practice.',\n  in_practice: 'A real calibration method is performed today, but no full uncertainty budget exists.',\n  documented: 'The calibration method and its uncertainty budget are published.',\n};\n\nexport const UPGRADE_STATUS_LABELS: Record<UpgradeStatus, string> = {\n  planned: 'Planned',\n  evaluating: 'Evaluating',\n  ordered: 'Ordered',\n  acquired: 'Acquired',\n};\n","import type { CalibrationStatus, Modality, SensorEntry, SensorManifest } from '../manifest/types';\nimport { MODALITY_LABELS, CALIBRATION_STATUS_LABELS } from '../labels';\n\nexport function formatModality(modality: Modality): string {\n  return MODALITY_LABELS[modality];\n}\n\nexport function formatCalibrationStatus(status: CalibrationStatus): string {\n  return CALIBRATION_STATUS_LABELS[status];\n}\n\n/** One-line sensor summary, e.g. `\"Passive Bistatic Radar (Radio Frequency) — calibration: In Practice\"`. */\nexport function formatSensorEntry(sensor: SensorEntry): string {\n  const calibration = sensor.calibration\n    ? ` — calibration: ${formatCalibrationStatus(sensor.calibration.status)}`\n    : '';\n  return `${sensor.name} (${formatModality(sensor.modality)})${calibration}`;\n}\n\n/** One-line manifest summary, e.g. `\"ELDÆON — 28 sensors across 6 modalities, 3 future upgrades\"`. */\nexport function formatSensorManifest(manifest: SensorManifest): string {\n  const modalityCount = new Set(manifest.sensors.map((sensor) => sensor.modality)).size;\n  const sensorCount = manifest.sensors.length;\n  const upgrades = manifest.futureUpgrades?.length ?? 0;\n  const upgradeSuffix = upgrades > 0 ? `, ${upgrades} future upgrade${upgrades === 1 ? '' : 's'}` : '';\n  return `${manifest.org} — ${sensorCount} sensor${sensorCount === 1 ? '' : 's'} across ${modalityCount} modalit${modalityCount === 1 ? 'y' : 'ies'}${upgradeSuffix}`;\n}\n"]}

package/dist/guards/index.d.ts

@@ -0,0 +1,6 @@
+declare const isModality: (value: unknown) => value is "audio" | "electro_optical" | "radio_frequency" | "quantum" | "environmental" | "biometric";
+declare const isTimeSource: (value: unknown) => value is "atomic_clock" | "gps_disciplined" | "ntp" | "system" | "unknown";
+declare const isCalibrationStatus: (value: unknown) => value is "none" | "candidate_identified" | "in_practice" | "documented";
+declare const isUpgradeStatus: (value: unknown) => value is "planned" | "evaluating" | "ordered" | "acquired";
+
+export { isCalibrationStatus, isModality, isTimeSource, isUpgradeStatus };

package/dist/guards/index.js

@@ -0,0 +1,111 @@
+import { createEnumGuard } from '@disclosureos/records/shared';
+import { z } from 'zod';
+
+// src/guards/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."
+);
+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/guards/index.ts
+var isModality = createEnumGuard(ModalitySchema.options);
+var isTimeSource = createEnumGuard(TimeSourceSchema.options);
+var isCalibrationStatus = createEnumGuard(CalibrationStatusSchema.options);
+var isUpgradeStatus = createEnumGuard(UpgradeStatusSchema.options);
+
+export { isCalibrationStatus, isModality, isTimeSource, isUpgradeStatus };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map