@disclosureos/records 2.0.0-beta.0 → 2.0.0-beta.1

package/dist/experimental/v2/index.js

@@ -126,9 +126,9 @@ function parsePrimitiveRecord(input) {
         unchecked.add(ref2);
         continue;
       }
-      const target = assertions.get(ref2.slice("assertion:".length));
-      if (!target) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Local assertion does not exist." });
-      else if (target.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Assertion concerns a different field." });
+      const target2 = assertions.get(ref2.slice("assertion:".length));
+      if (!target2) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Local assertion does not exist." });
+      else if (target2.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Assertion concerns a different field." });
     }
     const selection = value.selection;
     if (!selection) continue;
@@ -141,9 +141,9 @@ function parsePrimitiveRecord(input) {
     for (const [index, ref2] of selection.consideredAssertionRefs.entries()) {
       if (refs.has(ref2)) issues.push({ code: "REF.UNIQUE_ID", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion is repeated." });
       refs.add(ref2);
-      const target = assertions.get(ref2.slice("assertion:".length));
-      if (!target) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion does not exist." });
-      else if (target.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion concerns a different field." });
+      const target2 = assertions.get(ref2.slice("assertion:".length));
+      if (!target2) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion does not exist." });
+      else if (target2.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion concerns a different field." });
     }
     const selected = assertions.get(selection.assertionRef.slice("assertion:".length));
     if (!selected) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/assertionRef`, message: "Selected assertion does not exist." });
@@ -383,9 +383,9 @@ function parseExperimentalObservation(input) {
     resolve(value.assertionRef, `${selectionPath}/assertionRef`, owner);
     if (!value.consideredAssertionRefs.includes(value.assertionRef)) problem("SELECTION.INPUTS", `${selectionPath}/assertionRef`, "Selected assertion must be among considered inputs.");
     if (!refs.includes(value.assertionRef)) problem("SELECTION.SOURCE_REF", `${path}/sourceRefs`, "Field must cite the selected assertion.");
-    const target = assertions.get(key(value.assertionRef));
-    if (target && !matchesField(value.assertionRef, field, measurementId)) problem("REF.FIELD_MISMATCH", `${selectionPath}/assertionRef`, "Selected assertion concerns a different field or measurement.");
-    else if (target && JSON.stringify(target.value) !== JSON.stringify(selectedValue)) problem("SELECTION.VALUE_MISMATCH", `${path}/value`, "Selection must copy the cited assertion value exactly; processing is declared separately.");
+    const target2 = assertions.get(key(value.assertionRef));
+    if (target2 && !matchesField(value.assertionRef, field, measurementId)) problem("REF.FIELD_MISMATCH", `${selectionPath}/assertionRef`, "Selected assertion concerns a different field or measurement.");
+    else if (target2 && JSON.stringify(target2.value) !== JSON.stringify(selectedValue)) problem("SELECTION.VALUE_MISMATCH", `${path}/value`, "Selection must copy the cited assertion value exactly; processing is declared separately.");
   }
   instant(data.createdAt, "/createdAt");
   instant(data.updatedAt, "/updatedAt");
@@ -457,10 +457,10 @@ function parseExperimentalObservation(input) {
   }
   if (queue.length !== graph.size) problem("PROCESS.CYCLE", "/processing", "Local processing/provenance dependencies contain a cycle.");
   const checks = { structural: "passed", semantic: issues.length ? "failed" : "passed", profile: "not_checked", external: "not_checked" };
-  const uncheckedRefs = [...sources.keys()].map((id3) => `source:${id3}`).concat(
-    [...products.keys()].map((id3) => `product:${id3}`),
-    [...methods.keys()].map((id3) => `method:${id3}`),
-    [...frames.keys()].map((id3) => `frame:${id3}`)
+  const uncheckedRefs = [...sources.keys()].map((id5) => `source:${id5}`).concat(
+    [...products.keys()].map((id5) => `product:${id5}`),
+    [...methods.keys()].map((id5) => `method:${id5}`),
+    [...frames.keys()].map((id5) => `frame:${id5}`)
   );
   return issues.length ? { success: false, issues, checks, uncheckedRefs } : { success: true, data, issues, checks, uncheckedRefs };
 }
@@ -561,9 +561,9 @@ function parseExperimentalClaimHistory(input) {
     if (!available.has(ref2)) problem("REF.LOCAL_RESOLUTION", path, `Undeclared local reference: ${ref2}`);
     else if (owner && claims.has(ref2)) graph.get(owner)?.add(ref2);
   }
-  function refs(values, path, owner) {
+  function refs(values2, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of values.entries()) {
+    for (const [i, ref2] of values2.entries()) {
       if (seen.has(ref2)) problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
       seen.add(ref2);
       resolve(ref2, `${path}/${i}`, owner);
@@ -639,7 +639,1409 @@ function compareUtcInstants(left, right) {
   const result = comparePoints({ kind: "instant", value: left}, { kind: "instant", value: right});
   return result === -1 || result === 0 || result === 1 ? result : void 0;
 }
+var SourceTypeSchema = z.enum([
+  "foia",
+  "official_report",
+  "official_statement",
+  "congressional_testimony",
+  "congressional_report",
+  "military_document",
+  "intelligence_document",
+  "whistleblower",
+  "firsthand_witness",
+  "secondhand_account",
+  "news_article",
+  "documentary",
+  "interview",
+  "book",
+  "academic_paper",
+  "investigation_report",
+  "database_entry",
+  "social_media",
+  "website",
+  "other"
+]).describe("Kind of source backing an observation (document, testimony, media, etc.).");
+var SourceCredibilitySchema = z.enum(["official", "verified", "credible", "unverified", "questionable", "disputed", "unknown"]).describe("Trust tier of a source \u2014 an orthogonal axis to confidence and temporal certainty.");
 
-export { AssessedClaimSchema, CLAIM_HISTORY_RULESET_VERSION, ClaimSubjectSchema, EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID, EXPERIMENTAL_OBSERVATION_SCHEMA_ID, EventTimeIntervalSchema, EventTimePointSchema, EventTimeSchema, EventTimeValueSchema, ExperimentalClaimHistorySchema, ExperimentalObservationSchema, FramedPositionSchema, HistoricalClaimSchema, MeasuredQuantitySchema, ObservationAssertionSchema, ObservationMeasurementSchema, ObservationMethodSchema, ObservationPositionSchema, ObservationProductSchema, ObservationSourceSchema, ObservationTimeSchema, PRIMITIVES_SCHEMA_ID, PositionSchema, PositionValueSchema, PrimitiveRecordSchema, ProcessingActivitySchema, QuantitativeUncertaintySchema, ReferenceFrameSchema, SourceProvenanceSchema, SourceStatementSchema, UnassessedClaimSchema, ValueAssertionSchema, ValueSelectionSchema, compareUtcInstants, experimentalClaimHistoryJsonSchema, experimentalObservationJsonSchema, parseExperimentalClaimHistory, parseExperimentalObservation, parsePrimitiveRecord, primitivesJsonSchema };
+// src/source/reference.ts
+var SourceReferenceSchema = z.object({
+  sourceId: z.string().describe("Stable unique identifier for this source."),
+  type: SourceTypeSchema,
+  title: z.string().describe("Title of the source document, article, or material."),
+  author: z.string().optional().describe("Author of the source material."),
+  organization: z.string().optional().describe("Organization that produced or published the source."),
+  date: z.string().optional().describe("Publication or creation date of the source (ISO date)."),
+  url: z.string().optional().describe("Link to the source material."),
+  archiveUrl: z.string().optional().describe("Archived copy of the source (e.g. Wayback Machine), in case the original disappears."),
+  reference: z.string().optional().describe("Citation locator within the source (e.g. page number, document section)."),
+  credibility: SourceCredibilitySchema,
+  isPrimarySource: z.boolean().optional().describe("Whether this is a primary source (original document/recording) rather than secondary reporting."),
+  classificationLevel: z.string().optional().describe("Government classification of the source, if it was ever classified."),
+  notes: z.string().optional().describe("Free-text context about the source.")
+}).meta({ id: "SourceReference" }).describe("A citation/source backing an observation, with its credibility tier.");
+var ConfidenceLevelSchema = z.enum(["very_high", "high", "moderate", "low", "very_low", "unassessed"]).describe("Qualitative confidence magnitude.");
+ConfidenceLevelSchema.options;
+
+// src/observation/domains.ts
+var ObjectShapeSchema = z.enum([
+  "sphere",
+  "orb",
+  "disc",
+  "saucer",
+  "oval",
+  "egg",
+  "cylinder",
+  "cigar",
+  "tic_tac",
+  "triangle",
+  "delta",
+  "boomerang",
+  "chevron",
+  "diamond",
+  "rectangle",
+  "square",
+  "cube",
+  "cross",
+  "star",
+  "amorphous",
+  "changing",
+  "light_only",
+  "other",
+  "unknown"
+]).describe("Reported shape of the observed object.");
+z.object({
+  shape: ObjectShapeSchema.optional(),
+  size: z.string().optional().describe('Apparent size as reported (e.g. "size of a commercial airliner").'),
+  sizeMeters: z.number().optional().describe("Estimated size of the object, in meters."),
+  color: z.string().optional().describe("Primary color of the object as reported."),
+  secondaryColors: z.array(z.string()).optional().describe("Additional colors observed on the object."),
+  luminosity: z.string().optional().describe('Light emission as reported (e.g. "glowing white", "self-luminous", "no lights").'),
+  sound: z.string().optional().describe('Whether and what sound the object produced (e.g. "silent", "humming").'),
+  soundDescription: z.string().optional().describe("Fuller free-text description of any sound."),
+  surfaceDetails: z.string().optional().describe('Visible surface features (e.g. "metallic, seamless, no rivets or seams").'),
+  numberObserved: z.number().optional().describe("How many objects were observed."),
+  formation: z.string().optional().describe('Geometric arrangement when multiple objects were observed (e.g. "triangular formation").'),
+  structuralFeatures: z.array(z.string()).optional().describe('Distinct structural elements reported (e.g. "dome", "portholes", "appendages").')
+}).meta({ id: "ObjectCharacteristics" }).describe("Physical description of the observed object(s).");
+var ManeuverTypeSchema = z.enum([
+  "hover",
+  "instant_acceleration",
+  "instant_stop",
+  "right_angle_turn",
+  "zigzag",
+  "pendulum",
+  "split",
+  "merge",
+  "disappear",
+  "appear",
+  "transmedium_entry",
+  "transmedium_exit",
+  "vertical_ascent",
+  "vertical_descent",
+  "rotation",
+  "wobble",
+  "other"
+]).describe("A distinctive movement/maneuver exhibited by the object.");
+z.object({
+  speed: z.string().optional().describe('Speed as reported (e.g. "faster than any known aircraft").'),
+  speedKmh: z.number().optional().describe("Estimated speed, in kilometers per hour."),
+  altitude: z.string().optional().describe('Altitude as reported (e.g. "treetop level", "very high").'),
+  altitudeMeters: z.number().optional().describe("Estimated altitude of the object, in meters."),
+  heading: z.number().optional().describe("Direction of travel, in compass degrees (0\u2013360)."),
+  flightPath: z.string().optional().describe('Narrative of the object\u2019s path through the encounter (e.g. "descended from 80,000 ft to sea level").'),
+  maneuvers: z.array(ManeuverTypeSchema).optional().describe("Distinctive maneuvers exhibited, from the typed vocabulary."),
+  maneuverDescriptions: z.array(z.string()).optional().describe("Free-text descriptions elaborating on the typed maneuvers."),
+  radarData: z.boolean().optional().describe("Whether the movement was tracked on radar."),
+  infraredSignature: z.boolean().optional().describe("Whether the object showed an infrared signature."),
+  trajectory: z.string().optional().describe('Overall trajectory summary (e.g. "erratic", "straight and level").')
+}).meta({ id: "Movement" }).describe("How the object moved \u2014 kinematics and notable maneuvers.");
+z.object({
+  investigatingBody: z.string().optional().describe('Primary organization that investigated (e.g. "AARO", "Project Blue Book").'),
+  investigatingBodies: z.array(z.string()).optional().describe("All organizations that investigated, when more than one."),
+  caseNumber: z.string().optional().describe("Case or file number assigned by the investigating body."),
+  investigationDate: z.string().optional().describe("When the investigation was conducted (ISO date)."),
+  conclusion: z.string().optional().describe('Official conclusion reached (e.g. "unidentified", "weather balloon").'),
+  confidence: ConfidenceLevelSchema.optional(),
+  methodologies: z.array(z.string()).optional().describe('Methods used (e.g. "witness interviews", "radar data analysis").'),
+  findings: z.string().optional().describe("Summary of what the investigation found."),
+  recommendations: z.string().optional().describe("Recommendations issued by the investigation.")
+}).meta({ id: "Investigation" }).describe("Official/independent investigation of the observation.");
+z.object({
+  count: z.number().optional().describe("Total number of witnesses."),
+  categories: z.array(z.string()).optional().describe('Kinds of witnesses present (e.g. "military pilots", "radar operators", "civilians").'),
+  militaryWitnesses: z.boolean().optional().describe("Whether any witnesses were military personnel."),
+  aviationWitnesses: z.boolean().optional().describe("Whether any witnesses were pilots or aviation professionals."),
+  multipleIndependent: z.boolean().optional().describe("Whether independent witnesses observed from separate vantage points."),
+  professionalObservers: z.boolean().optional().describe("Whether any witnesses were trained observers (pilots, astronomers, military)."),
+  descriptions: z.array(z.string()).optional().describe("Brief summaries of individual witness accounts.")
+}).meta({ id: "Witnesses" }).describe("Aggregate summary of who witnessed the observation.");
+z.object({
+  officialResponse: z.string().optional().describe("How officials responded (statements, denials, acknowledgments)."),
+  mediaAttention: z.boolean().optional().describe("Whether the observation received media coverage."),
+  publicImpact: z.string().optional().describe("Effect on public awareness or discourse."),
+  policyImpact: z.string().optional().describe("Policy consequences (e.g. hearings, legislation, reporting-process changes)."),
+  militaryResponse: z.string().optional().describe("Military actions taken (e.g. intercept scrambled, alert status changed)."),
+  coverUpAlleged: z.boolean().optional().describe("Whether suppression or concealment of the event has been alleged.")
+}).meta({ id: "ResponseImpact" }).describe("Official, media, and public response to the observation.");
+z.object({
+  weather: z.string().optional().describe('General weather conditions (e.g. "clear", "overcast").'),
+  visibility: z.string().optional().describe('Visibility conditions (e.g. "unlimited", "10 miles", "hazy").'),
+  cloudCover: z.string().optional().describe('Cloud cover description (e.g. "scattered at 5,000 ft").'),
+  windSpeed: z.string().optional().describe("Wind conditions as reported."),
+  temperature: z.number().optional().describe("Air temperature, in degrees Celsius."),
+  humidity: z.number().optional().describe("Relative humidity, as a percentage (0\u2013100)."),
+  celestialConditions: z.string().optional().describe("Sky conditions relevant to identification (e.g. visible planets, meteor showers, satellites)."),
+  moonPhase: z.string().optional().describe("Moon phase description at the time of observation."),
+  precipitation: z.string().optional().describe("Precipitation at the time of observation, if any.")
+}).meta({ id: "Environment" }).describe("Environmental and weather conditions at the time of observation.");
+var RelationKindSchema = z.enum([
+  "corroborates",
+  "contradicts",
+  "duplicate_of",
+  "same_object",
+  "supersedes",
+  "superseded_by",
+  "re_analysis_of",
+  "part_of"
+]).describe("How one observation relates to another (typed edge vocabulary).");
+var RelationEdgeSchema = z.object({
+  kind: RelationKindSchema,
+  targetId: z.string().min(1).describe("The `Observation.id` this edge points at."),
+  note: z.string().optional().describe("Free-text context for why the link exists.")
+}).meta({ id: "RelationEdge" }).describe("A typed link from this observation to another.");
+z.object({
+  /** Typed edges to other observations — the standardized way to link records. */
+  edges: z.array(RelationEdgeSchema).optional().describe("Typed edges to other observations \u2014 the standardized way to link records."),
+  /** Named grouping into a flap (a localized cluster of sightings). */
+  flap: z.string().optional().describe("Named grouping into a flap (a localized cluster of sightings)."),
+  /** Named grouping into a wave (a broad temporal surge of sightings). */
+  wave: z.string().optional().describe("Named grouping into a wave (a broad temporal surge of sightings)."),
+  /** Named grouping into an ad-hoc cluster. */
+  cluster: z.string().optional().describe("Named grouping into an ad-hoc cluster."),
+  /** @deprecated Use typed `edges` with `kind: 'corroborates' | 'same_object' | …`. */
+  relatedObservationIds: z.array(z.string()).optional().describe('Deprecated \u2014 use typed `edges` with `kind: "corroborates" | "same_object" | \u2026`.'),
+  /** @deprecated Use typed `edges` with `kind: 'supersedes' | 're_analysis_of' | …`. */
+  precedingEvents: z.array(z.string()).optional().describe('Deprecated \u2014 use typed `edges` with `kind: "supersedes" | "re_analysis_of" | \u2026`.'),
+  /** @deprecated Use typed `edges`. */
+  followingEvents: z.array(z.string()).optional().describe("Deprecated \u2014 use typed `edges`.")
+}).meta({ id: "Relations" }).describe("Typed links to related observations, plus flap/wave/cluster groupings.");
+z.object({
+  aircraftType: z.string().optional().describe('Type of aircraft involved (e.g. "F/A-18F Super Hornet").'),
+  aircraftDesignation: z.string().optional().describe("Military designation or tail number of the aircraft."),
+  squadron: z.string().optional().describe("Squadron or unit the aircraft belonged to."),
+  flightMission: z.string().optional().describe('Mission being flown at the time (e.g. "training exercise", "combat air patrol").'),
+  altitude: z.number().optional().describe("Aircraft altitude during the encounter, in meters."),
+  speed: z.number().optional().describe("Aircraft speed during the encounter, in kilometers per hour."),
+  heading: z.number().optional().describe("Aircraft heading during the encounter, in compass degrees (0\u2013360)."),
+  radarContact: z.boolean().optional().describe("Whether the aircraft\u2019s radar held contact with the object."),
+  weaponsSystemEngaged: z.boolean().optional().describe("Whether a weapons system locked onto or tracked the object."),
+  interceptAttempted: z.boolean().optional().describe("Whether an intercept of the object was attempted.")
+}).meta({ id: "Aviation" }).describe("Aviation context when the observation involved aircraft.");
+z.object({
+  primarySource: SourceReferenceSchema.optional(),
+  sources: z.array(SourceReferenceSchema).optional(),
+  originalClassification: z.string().optional().describe('Original government classification of the source material (e.g. "SECRET").'),
+  declassificationDate: z.string().optional().describe("When the source material was declassified (ISO date)."),
+  foiaRequestId: z.string().optional().describe("FOIA request number that produced the source material."),
+  archiveLocation: z.string().optional().describe("Physical or digital archive where the source material resides.")
+}).meta({ id: "SourceData" }).describe(
+  "Where the observation data came from. Forensic custody/authenticity now lives in the optional `Observation.provenance` slot (@disclosureos/records/extensions/provenance)."
+);
+var CoordinatePrecisionSchema = z.enum(["exact", "address", "locality", "region", "approximate", "unknown"]).describe("How precisely a coordinate is known.");
+var SiteTypeSchema = z.enum([
+  "military_air_base",
+  "military_naval_base",
+  "military_army_base",
+  "military_missile_site",
+  "military_radar_station",
+  "military_research_facility",
+  "military_training_area",
+  "military_other",
+  "nuclear_power_plant",
+  "nuclear_weapons_storage",
+  "nuclear_research_facility",
+  "nuclear_waste_storage",
+  "nuclear_other",
+  "civilian_airport",
+  "private_airfield",
+  "heliport",
+  "seaport",
+  "offshore_platform",
+  "naval_vessel",
+  "government_facility",
+  "embassy",
+  "intelligence_facility",
+  "power_plant",
+  "dam",
+  "telecommunications",
+  "water_treatment",
+  "research_facility",
+  "test_range",
+  "space_station",
+  "archaeological_site",
+  "volcano",
+  "command_center",
+  "residential",
+  "commercial",
+  "industrial",
+  "agricultural",
+  "wilderness",
+  "ocean",
+  "lake",
+  "mountain",
+  "desert",
+  "forest",
+  "urban",
+  "suburban",
+  "rural",
+  "other",
+  "unknown"
+]).describe("Category of site at or near the observation location (military, nuclear, civilian, natural, etc.).");
+var TerrainTypeSchema = z.enum([
+  "ocean",
+  "coastal",
+  "lake",
+  "river",
+  "wetland",
+  "plains",
+  "hills",
+  "mountains",
+  "desert",
+  "forest",
+  "jungle",
+  "tundra",
+  "arctic",
+  "urban",
+  "suburban",
+  "rural",
+  "underground",
+  "underwater",
+  "airborne",
+  "space",
+  "unknown"
+]).describe("Physical terrain at the observation location.");
+var AirspaceClassSchema = z.enum([
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "G",
+  "restricted",
+  "prohibited",
+  "warning",
+  "moa",
+  "alert",
+  "cfa",
+  "national_security",
+  "tfr",
+  "international",
+  "unknown"
+]).describe("Airspace classification over the location (ICAO classes plus special-use airspace).");
+var LocationSensitivitySchema = z.enum(["critical", "high", "moderate", "standard", "none"]).describe("How sensitive the location is (e.g. proximity to critical infrastructure).");
+var ProximitySiteSchema = z.object({
+  siteType: SiteTypeSchema,
+  siteName: z.string().optional().describe('Name of the nearby site (e.g. "Naval Air Station Oceana").'),
+  distanceKm: z.number().describe("Distance from the observation location, in kilometers."),
+  bearing: z.number().optional().describe("Compass bearing from the observation location to the site, in degrees (0\u2013360).")
+}).meta({ id: "ProximitySite" }).describe("A site of interest near the observation and its distance/bearing.");
+z.object({
+  id: z.string().min(1).describe("Stable unique identifier for this location."),
+  name: z.string().min(1).describe('Human-readable place name (e.g. "Off the coast of San Diego").'),
+  country: z.string().min(1).describe("Country where the observation occurred."),
+  countryCode: z.string().optional().describe('ISO 3166-1 alpha-2 country code (e.g. "US").'),
+  region: z.string().optional().describe("State, province, or administrative region."),
+  city: z.string().optional().describe("Nearest city or town."),
+  address: z.string().optional().describe("Street address, when the location is that precise."),
+  longitude: z.number().min(-180).max(180).describe("Longitude in decimal degrees (WGS 84)."),
+  latitude: z.number().min(-90).max(90).describe("Latitude in decimal degrees (WGS 84)."),
+  coordinatePrecision: CoordinatePrecisionSchema.optional(),
+  coordinatePrecisionMeters: z.number().optional().describe("Numeric uncertainty radius of the coordinates, in meters."),
+  coordinatesApproximate: z.boolean().optional().describe("Whether the coordinates are an approximation rather than a measured fix."),
+  elevationMeters: z.number().optional().describe("Ground elevation at the location, in meters above sea level."),
+  elevationSource: z.enum(["gps", "map", "estimated", "unknown"]).optional().describe("How the elevation value was obtained."),
+  siteType: SiteTypeSchema,
+  secondarySiteTypes: z.array(SiteTypeSchema).optional().describe("Additional site categories that also apply to the location."),
+  terrain: TerrainTypeSchema.optional(),
+  airspaceClass: AirspaceClassSchema.optional(),
+  locationSensitivity: LocationSensitivitySchema.optional(),
+  proximitySites: z.array(ProximitySiteSchema).optional().describe("Named sites of interest near the observation, with distance and bearing."),
+  nearestMilitaryKm: z.number().optional().describe("Distance to the nearest military installation, in kilometers."),
+  nearestNuclearKm: z.number().optional().describe("Distance to the nearest nuclear facility, in kilometers."),
+  nearestAirportKm: z.number().optional().describe("Distance to the nearest airport, in kilometers."),
+  waterDepthMeters: z.number().optional().describe("Water depth at the location for maritime observations, in meters."),
+  vesselName: z.string().optional().describe("Name of the vessel the observer was aboard, if any."),
+  vesselType: z.string().optional().describe('Type of vessel (e.g. "aircraft carrier", "fishing trawler").'),
+  aircraftType: z.string().optional().describe("Type of aircraft the observer was aboard, if any."),
+  aircraftCallsign: z.string().optional().describe("Callsign of the observer\u2019s aircraft."),
+  flightNumber: z.string().optional().describe("Commercial flight number, for airline observations."),
+  observerAltitudeMeters: z.number().optional().describe("Altitude of an airborne observer at the time of observation, in meters.")
+}).meta({ id: "LocationData" }).describe("Where an observation occurred \u2014 identity, coordinates, site classification, and proximity context.");
+var DetectionMethodSchema = z.enum([
+  "radar_primary",
+  "radar_secondary",
+  "radar_doppler",
+  "radar_phased_array",
+  "infrared_flir",
+  "infrared_other",
+  "electro_optical",
+  "visual_camera",
+  "satellite_imagery",
+  "sonar_active",
+  "sonar_passive",
+  "electromagnetic",
+  "radiation_detector",
+  "magnetometer",
+  "gravimeter",
+  "acoustic",
+  "seismic",
+  "lidar",
+  "spectroscopic",
+  "radio_frequency",
+  "particle",
+  "gnss",
+  "time_reference",
+  "chemical",
+  "inertial",
+  "physiological",
+  "pressure",
+  "multiple",
+  "other",
+  "unknown"
+]).describe("How a sensor detected the object.");
+var SensorTypeSchema = z.enum([
+  "military_radar",
+  "civilian_radar",
+  "airborne_radar",
+  "shipborne_radar",
+  "ground_radar",
+  "flir",
+  "eo_sensor",
+  "satellite",
+  "sonar",
+  "electromagnetic_sensor",
+  "radiation_sensor",
+  "civilian_camera",
+  "security_camera",
+  "dashcam",
+  "phone_camera",
+  "infrasonic_sensor",
+  "ultrasonic_sensor",
+  "adsb_receiver",
+  "rf_spectrum_analyzer",
+  "passive_radar",
+  "particle_detector",
+  "atomic_clock",
+  "gnss_receiver",
+  "fluxgate_magnetometer",
+  "air_quality_sensor",
+  "barometer",
+  "lightning_detector",
+  "imu",
+  "eeg",
+  "gsr",
+  "pulse_oximeter",
+  "pupillometer",
+  "hardware_rng",
+  "other"
+]).describe("Class of sensor that produced a reading.");
+var SensorReadingSchema = z.object({
+  id: z.string().min(1).describe('Stable id, addressable by a claim `evidenceRef` ("sensor:<id>").'),
+  sensorType: SensorTypeSchema,
+  detectionMethod: DetectionMethodSchema,
+  sensorRef: z.string().optional().describe(
+    'Reference to a published sensor-manifest entry ("<org-slug>:<sensor-id>", e.g. "eldaeon:dionysus-passive-radar") carrying the instrument\u2019s full spec, timing, and calibration provenance.'
+  ),
+  platform: z.string().optional().describe('Platform carrying the sensor (e.g. "USS Princeton", "F/A-18F").'),
+  operator: z.string().optional().describe("Person or unit operating the sensor."),
+  timestamp: z.string().optional().describe("When the reading was recorded (ISO timestamp)."),
+  duration: z.number().optional().describe("How long the sensor held contact, in seconds."),
+  rawDataAvailable: z.boolean().optional().describe("Whether the raw sensor data still exists and is obtainable."),
+  calibrated: z.boolean().optional().describe("Whether the sensor was calibrated at the time of the reading."),
+  readings: z.record(z.string(), z.unknown()).optional().describe("Sensor-specific measured values, keyed by measurement name."),
+  notes: z.string().optional().describe("Free-text context about the reading.")
+}).meta({ id: "SensorReading" }).describe("A single sensor reading and its provenance.");
+var SensorEvidenceDataSchema = z.object({
+  sensors: z.array(SensorReadingSchema),
+  multiSensorCorrelation: z.boolean().optional().describe("Whether independent sensors corroborated the same object."),
+  dataRetentionStatus: z.enum(["available", "archived", "destroyed", "classified", "unknown"]).optional().describe("Current status of the underlying sensor data."),
+  anomalies: z.array(z.string()).optional().describe('Anomalies in the sensor data itself (e.g. "jamming indications", "signal dropout").')
+}).meta({ id: "SensorEvidenceData" }).describe("Instrument-recorded evidence for an observation (radar, FLIR, EO, etc.).");
+var TimeOfDaySchema = z.enum([
+  "astronomical_dawn",
+  "nautical_dawn",
+  "civil_dawn",
+  "sunrise",
+  "morning",
+  "noon",
+  "afternoon",
+  "sunset",
+  "civil_dusk",
+  "nautical_dusk",
+  "astronomical_dusk",
+  "night",
+  "unknown"
+]).describe("Twilight-aware time-of-day bucket for an observation.");
+
+// src/experimental/v2/context-schema.ts
+var text4 = z.string().min(1).regex(/\S/);
+var id3 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var sourceRef2 = z.string().regex(/^(source|product):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var OBSERVATION_CONTEXT_SCHEMA_ID = "urn:disclosureos:experimental:observation-context:0.1.0";
+var DocumentSnapshotRefSchema = z.strictObject({
+  documentId: id3.describe("ID inside the supplied document; not a URL."),
+  schemaId: text4.describe("Exact document contract identity."),
+  sha256: z.string().regex(/^[a-f0-9]{64}(?![\s\S])/).describe("SHA-256 of exact supplied document bytes.")
+});
+var ObservationSnapshotRefSchema = DocumentSnapshotRefSchema.extend({
+  schemaId: z.literal(EXPERIMENTAL_OBSERVATION_SCHEMA_ID)
+});
+var provenance2 = SourceProvenanceSchema.extend({ sourceRef: sourceRef2 });
+function values(schema) {
+  return z.array(
+    z.strictObject({
+      id: id3.describe(
+        "Assertion identity within this entity, independent of array order."
+      ),
+      content: z.union([
+        z.strictObject({
+          state: z.literal("known"),
+          value: schema,
+          provenance: provenance2,
+          originalWording: text4.optional()
+        }),
+        z.strictObject({
+          state: z.literal("approximate"),
+          value: schema,
+          precision: text4,
+          provenance: provenance2,
+          originalWording: text4.optional()
+        }),
+        z.strictObject({
+          state: z.literal("unknown"),
+          reason: z.enum(["not_recorded", "not_collected", "unavailable"])
+        }),
+        z.strictObject({ state: z.literal("redacted"), reason: text4 }),
+        z.strictObject({
+          state: z.literal("unmapped"),
+          originalWording: text4,
+          provenance: provenance2
+        })
+      ])
+    })
+  ).min(1).optional();
+}
+var strings = z.array(text4).min(1);
+var localTime = z.strictObject({
+  clock: z.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$/),
+  timezone: text4.optional(),
+  utcOffset: z.string().regex(/^[+-](0[0-9]|1[0-4]):[0-5][0-9]$/).optional(),
+  daylightSaving: z.boolean().optional()
+});
+var period = z.union([
+  z.strictObject({
+    kind: z.literal("quarter"),
+    year: z.number().int().min(1).max(9999),
+    quarter: z.number().int().min(1).max(4)
+  }),
+  z.strictObject({
+    kind: z.enum(["decade", "century"]),
+    startYear: z.number().int().min(1).max(9999),
+    endYear: z.number().int().min(1).max(9999)
+  })
+]);
+var calendarEndpoint = z.strictObject({
+  value: z.union([EventTimePointSchema, period]),
+  certainty: z.enum(["exact", "approximate", "estimated", "unknown"]),
+  display: text4.optional(),
+  notes: text4.optional()
+});
+var calendarRange = z.strictObject({
+  start: calendarEndpoint,
+  end: calendarEndpoint,
+  type: z.enum([
+    "span",
+    "uncertainty",
+    "active_period",
+    "investigation_period",
+    "observation_window"
+  ]),
+  inclusiveEnd: z.boolean(),
+  display: text4.optional()
+});
+var relative = z.strictObject({
+  anchorTemporalId: id3,
+  relation: z.enum(["before", "after", "during", "around"]),
+  offset: z.strictObject({
+    value: z.number().min(0),
+    unit: z.enum([
+      "seconds",
+      "minutes",
+      "hours",
+      "days",
+      "weeks",
+      "months",
+      "years"
+    ]),
+    approximate: z.boolean()
+  }).optional(),
+  wording: text4
+});
+var ContextEventFields = {
+  eventType: values(
+    text4.describe("Sourced event descriptor; not an origin hypothesis.")
+  ),
+  description: values(text4),
+  temporalId: values(id3),
+  placeIds: values(z.array(id3).min(1))
+};
+var ContextObjectFields = {
+  shape: values(ObjectShapeSchema),
+  sizeDescription: values(text4),
+  color: values(text4),
+  secondaryColors: values(strings),
+  luminosity: values(text4),
+  sound: values(text4),
+  soundDescription: values(text4),
+  surfaceDetails: values(text4),
+  formation: values(text4),
+  structuralFeatures: values(strings),
+  countDescription: values(text4),
+  speedDescription: values(text4),
+  altitudeDescription: values(text4),
+  flightPath: values(text4),
+  maneuvers: values(z.array(ManeuverTypeSchema).min(1)),
+  maneuverDescriptions: values(strings),
+  trajectoryDescription: values(text4),
+  radarContactReported: values(z.boolean()),
+  infraredSignatureReported: values(z.boolean())
+};
+var ContextPlaceFields = {
+  name: values(text4),
+  country: values(text4),
+  countryCode: values(text4),
+  region: values(text4),
+  city: values(text4),
+  address: values(text4),
+  position: values(FramedPositionSchema),
+  coordinatePrecision: values(CoordinatePrecisionSchema),
+  coordinatesApproximate: values(z.boolean()),
+  elevationSource: values(text4),
+  siteType: values(SiteTypeSchema),
+  secondarySiteTypes: values(z.array(SiteTypeSchema).min(1)),
+  terrain: values(z.array(TerrainTypeSchema).min(1)),
+  airspaceClass: values(AirspaceClassSchema),
+  proximity: values(
+    z.strictObject({
+      targetPlaceId: id3,
+      relation: z.enum([
+        "nearby",
+        "nearest_military",
+        "nearest_nuclear",
+        "nearest_airport"
+      ]),
+      distanceMeasurementId: id3.optional(),
+      bearingMeasurementId: id3.optional(),
+      note: text4.optional()
+    })
+  ),
+  infrastructureSensitivity: values(LocationSensitivitySchema),
+  sensitivity: values(
+    z.enum(["public", "approximate_only", "withheld"]).describe(
+      "Publication instruction only; does not enforce access control."
+    )
+  )
+};
+var ContextPlatformFields = {
+  role: values(z.enum(["observer", "station", "aircraft", "vessel"])),
+  placeId: values(id3),
+  name: values(text4),
+  type: values(text4),
+  designation: values(text4),
+  callsign: values(text4),
+  flightNumber: values(text4),
+  squadron: values(text4),
+  mission: values(text4),
+  operator: values(text4),
+  radarContact: values(z.boolean()),
+  weaponsSystemEngaged: values(z.boolean()),
+  interceptAttempted: values(z.boolean())
+};
+var ContextEnvironmentFields = {
+  placeId: values(id3),
+  platformId: values(id3),
+  temporalId: values(id3),
+  observedAt: values(EventTimeValueSchema),
+  weather: values(text4),
+  visibility: values(text4),
+  cloudCover: values(text4),
+  windDescription: values(text4),
+  celestialConditions: values(text4),
+  moonPhase: values(text4),
+  precipitation: values(text4)
+};
+var ContextTemporalFields = {
+  eventTime: values(EventTimeValueSchema),
+  calendarPeriod: values(period),
+  relativeDate: values(relative),
+  calendarRange: values(calendarRange),
+  localTime: values(localTime),
+  dateCertainty: values(
+    z.enum(["exact", "approximate", "estimated", "unknown"])
+  ),
+  timeCertainty: values(
+    z.enum(["exact", "approximate", "estimated", "unknown"])
+  ),
+  timeOfDay: values(TimeOfDaySchema),
+  durationDescription: values(text4),
+  display: values(text4),
+  notes: values(text4),
+  rangeInclusivity: values(
+    z.enum(["both", "start", "end", "neither", "unknown"])
+  )
+};
+var ContextCollectionFields = {
+  sensorType: values(SensorTypeSchema),
+  detectionMethod: values(DetectionMethodSchema),
+  productRefs: values(z.array(sourceRef2).min(1)),
+  acquisitionIds: values(z.array(id3).min(1)),
+  retentionStatus: values(
+    SensorEvidenceDataSchema.shape.dataRetentionStatus.unwrap()
+  ),
+  rawDataAvailable: values(z.boolean()),
+  anomalies: values(strings),
+  correlationDescription: values(text4),
+  alignmentDescription: values(text4),
+  notes: values(text4)
+};
+for (const fields of [
+  ContextEventFields,
+  ContextObjectFields,
+  ContextPlaceFields,
+  ContextPlatformFields,
+  ContextEnvironmentFields,
+  ContextTemporalFields,
+  ContextCollectionFields
+]) {
+  for (const [key2, schema] of Object.entries(fields)) {
+    const label = key2.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+    fields[key2] = schema.describe(
+      `Sourced ${label} assertions. Keep alternatives and missingness explicit; no assertion is selected by default.`
+    );
+  }
+}
+var role = z.enum([
+  "size",
+  "count",
+  "speed",
+  "altitude",
+  "heading",
+  "ambient_temperature",
+  "relative_humidity",
+  "wind_speed",
+  "moon_illumination",
+  "duration",
+  "distance",
+  "bearing",
+  "water_depth",
+  "coordinate_precision",
+  "time_alignment"
+]);
+var ContextMeasurementLinkSchema = z.strictObject({
+  id: id3,
+  role,
+  measurementId: id3,
+  relatedPlaceId: id3.optional()
+}).describe(
+  "Association to an Observation measurement. No copied numeric value."
+);
+function entity(kind, fields) {
+  const keys = Object.keys(fields);
+  return z.strictObject({
+    kind: z.literal(kind),
+    id: id3,
+    fields: z.strictObject(fields),
+    measurements: z.array(ContextMeasurementLinkSchema).optional(),
+    selections: z.array(
+      z.strictObject({
+        field: z.enum(keys),
+        assertionId: id3,
+        consideredAssertionIds: z.array(id3).min(1),
+        evaluatedBy: text4,
+        evaluatedAt: instantString,
+        methodRef: z.string().regex(/^method:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/),
+        methodVersion: text4,
+        rationale: text4
+      })
+    ).optional()
+  });
+}
+var ContextEntitySchema = z.discriminatedUnion("kind", [
+  entity("event", ContextEventFields),
+  entity("reported_object", ContextObjectFields),
+  entity("place", ContextPlaceFields),
+  entity("platform", ContextPlatformFields),
+  entity("environment", ContextEnvironmentFields),
+  entity("temporal", ContextTemporalFields),
+  entity("collection", ContextCollectionFields)
+]);
+var ObservationContextSchema = z.strictObject({
+  kind: z.literal("observation_context"),
+  schemaVersion: z.literal("0.1.0"),
+  id: id3,
+  observationRef: ObservationSnapshotRefSchema,
+  acquisitionRef: DocumentSnapshotRefSchema.extend({
+    schemaId: z.literal(
+      "urn:disclosureos:experimental:acquisition-context:0.1.0"
+    )
+  }).optional(),
+  recordedAt: instantString,
+  recordedBy: text4,
+  entities: z.array(ContextEntitySchema).min(1)
+}).describe(
+  "Typed descriptions of an observation. Supplied values remain sourced declarations, not verified facts."
+);
+function target(kind, fields) {
+  const keys = Object.keys(fields);
+  return z.strictObject({
+    kind: z.literal(kind),
+    id: id3,
+    field: z.enum(keys).optional()
+  });
+}
+var ContextTargetSchema = z.discriminatedUnion("kind", [
+  target("event", ContextEventFields),
+  target("reported_object", ContextObjectFields),
+  target("place", ContextPlaceFields),
+  target("platform", ContextPlatformFields),
+  target("environment", ContextEnvironmentFields),
+  target("temporal", ContextTemporalFields),
+  target("collection", ContextCollectionFields)
+]);
+var ContextReferenceSchema = z.strictObject({
+  document: DocumentSnapshotRefSchema.extend({
+    schemaId: z.literal(OBSERVATION_CONTEXT_SCHEMA_ID)
+  }),
+  target: ContextTargetSchema
+});
+var ContextAssertionReferenceSchema = ContextReferenceSchema.extend({
+  assertionId: id3
+});
+function observationContextJsonSchema() {
+  return {
+    ...z.toJSONSchema(ObservationContextSchema, {
+      target: "draft-2020-12",
+      reused: "ref"
+    }),
+    $id: OBSERVATION_CONTEXT_SCHEMA_ID
+  };
+}
+
+// src/experimental/v2/context.ts
+function contextAssertions(entity2) {
+  return Object.entries(entity2.fields).flatMap(
+    ([field, assertions]) => (assertions ?? []).map((assertion) => ({
+      field,
+      assertion
+    }))
+  );
+}
+function parseObservationContext(input) {
+  const parsed = ObservationContextSchema.safeParse(input);
+  const contract = {
+    schemaId: OBSERVATION_CONTEXT_SCHEMA_ID,
+    rulesetVersion: "0.1.0"
+  };
+  const issues = [];
+  const error = (code, pointer5, message) => issues.push({ code, stage: "semantic", pointer: pointer5, message });
+  if (!parsed.success)
+    return {
+      success: false,
+      contract,
+      checks: {
+        structural: "failed",
+        semantic: "not_checked",
+        profile: "not_checked",
+        external: "not_checked"
+      },
+      issues: parsed.error.issues.map((i) => ({
+        code: "STRUCT.VALUE",
+        stage: "structural",
+        pointer: "/" + i.path.join("/"),
+        message: i.message
+      })),
+      uncheckedRefs: []
+    };
+  const data = parsed.data;
+  const entities = /* @__PURE__ */ new Map();
+  const relativeGraph = /* @__PURE__ */ new Map();
+  for (const [i, entity2] of data.entities.entries()) {
+    const key2 = `${entity2.kind}:${entity2.id}`;
+    if (entities.has(key2))
+      error("REF.UNIQUE_ID", `/entities/${i}/id`, "Duplicate entity identity.");
+    entities.set(key2, entity2);
+    if (entity2.kind === "temporal") relativeGraph.set(entity2.id, /* @__PURE__ */ new Set());
+  }
+  function time(value, path) {
+    const found = [];
+    checkTime(value, path, found);
+    found.forEach((i) => error(i.code, i.pointer, i.message));
+  }
+  time(
+    { kind: "instant", value: data.recordedAt},
+    "/recordedAt"
+  );
+  const unchecked = /* @__PURE__ */ new Set([data.observationRef.sha256]);
+  if (data.acquisitionRef) unchecked.add(data.acquisitionRef.sha256);
+  for (const [i, entity2] of data.entities.entries()) {
+    const path = `/entities/${i}`;
+    const assertions = contextAssertions(entity2);
+    const ids = /* @__PURE__ */ new Set();
+    for (const { field, assertion } of assertions) {
+      const p = `${path}/fields/${field}`;
+      if (ids.has(assertion.id))
+        error(
+          "REF.UNIQUE_ID",
+          p,
+          "Assertion IDs must be unique across fields within an entity."
+        );
+      ids.add(assertion.id);
+      const { content } = assertion;
+      const prov = content.provenance;
+      if (prov) {
+        unchecked.add(prov.sourceRef);
+        if (prov.locator?.kind === "time_range" && prov.locator.endSeconds < prov.locator.startSeconds)
+          error("TIME.INTERVAL", p, "Source locator end precedes start.");
+      }
+      if (!("value" in content)) continue;
+      if (field === "eventTime" || field === "observedAt")
+        time(content.value, p);
+      const linkKind = {
+        placeId: "place",
+        platformId: "platform",
+        temporalId: "temporal"
+      }[field];
+      if (linkKind && !entities.has(`${linkKind}:${content.value}`))
+        error(
+          "REF.LOCAL_RESOLUTION",
+          p,
+          "Context entity reference does not resolve."
+        );
+      if (field === "placeIds") {
+        for (const id5 of content.value)
+          if (!entities.has(`place:${id5}`))
+            error(
+              "REF.LOCAL_RESOLUTION",
+              p,
+              "Place reference does not resolve."
+            );
+      }
+      if (field === "proximity" && !entities.has(
+        `place:${content.value.targetPlaceId}`
+      ))
+        error(
+          "REF.LOCAL_RESOLUTION",
+          p,
+          "Proximity target place does not resolve."
+        );
+      if (field === "relativeDate") {
+        const relative2 = content.value;
+        if (!entities.has(`temporal:${relative2.anchorTemporalId}`))
+          error(
+            "REF.LOCAL_RESOLUTION",
+            p,
+            "Relative date anchor does not resolve."
+          );
+        relativeGraph.get(entity2.id)?.add(relative2.anchorTemporalId);
+        if (relative2.relation === "during" && relative2.offset)
+          error(
+            "TIME.RELATIVE_OFFSET",
+            p,
+            "A during relation cannot carry an offset."
+          );
+      }
+      if (field === "calendarPeriod") {
+        const period2 = content.value;
+        if (period2.kind !== "quarter" && period2.endYear - period2.startYear !== (period2.kind === "decade" ? 9 : 99))
+          error(
+            "TIME.CALENDAR_PERIOD",
+            p,
+            "Declared period must cover exactly ten or one hundred years."
+          );
+      }
+      if (field === "calendarRange") {
+        const range = content.value;
+        for (const endpoint of [range.start.value, range.end.value]) {
+          if (["year", "month", "date", "instant"].includes(endpoint.kind))
+            time(endpoint, p);
+          if (["decade", "century"].includes(endpoint.kind) && endpoint.endYear - endpoint.startYear !== (endpoint.kind === "decade" ? 9 : 99))
+            error(
+              "TIME.CALENDAR_PERIOD",
+              p,
+              "Endpoint period has invalid width."
+            );
+        }
+        const a = range.start.value, b = range.end.value;
+        if (a.kind === b.kind) {
+          const reversed = ["year", "month", "date", "instant"].includes(a.kind) ? comparePoints(
+            a,
+            b
+          ) > 0 : a.kind === "quarter" ? a.year * 4 + a.quarter > b.year * 4 + b.quarter : a.startYear > b.startYear;
+          if (reversed)
+            error("TIME.INTERVAL", p, "Calendar range end precedes start.");
+        }
+      }
+      if (field === "localTime") {
+        const clock = content.value;
+        if (clock.timezone)
+          try {
+            new Intl.DateTimeFormat("en", { timeZone: clock.timezone });
+          } catch {
+            error(
+              "TIME.TIMEZONE",
+              p,
+              "Unknown timezone; no offset has been inferred."
+            );
+          }
+        if (clock.utcOffset?.slice(1, 3) === "14" && !clock.utcOffset.endsWith(":00"))
+          error("TIME.OFFSET", p, "UTC offset must not exceed fourteen hours.");
+      }
+    }
+    const selectedFields = /* @__PURE__ */ new Set();
+    for (const selection of entity2.selections ?? []) {
+      const p = `${path}/selections`;
+      if (selectedFields.has(selection.field))
+        error(
+          "SELECTION.DUPLICATE_FIELD",
+          p,
+          "One selection is allowed per field."
+        );
+      selectedFields.add(selection.field);
+      if (!selection.consideredAssertionIds.includes(selection.assertionId))
+        error(
+          "SELECTION.INPUTS",
+          p,
+          "Selected assertion must be a considered input."
+        );
+      if (new Set(selection.consideredAssertionIds).size !== selection.consideredAssertionIds.length)
+        error("REF.UNIQUE_ID", p, "Considered assertions are repeated.");
+      for (const id5 of selection.consideredAssertionIds)
+        if (!assertions.some(
+          (a) => a.field === selection.field && a.assertion.id === id5
+        ))
+          error(
+            "REF.FIELD_MISMATCH",
+            p,
+            "Considered assertion must exist on the selected field."
+          );
+      const chosen = assertions.find(
+        (a) => a.field === selection.field && a.assertion.id === selection.assertionId
+      );
+      if (!chosen || !["known", "approximate", "unmapped"].includes(
+        chosen.assertion.content.state
+      ))
+        error(
+          "SELECTION.VALUE",
+          p,
+          "Select a sourced assertion, not an unknown or redacted value."
+        );
+      time(
+        { kind: "instant", value: selection.evaluatedAt},
+        p
+      );
+      if (comparePoints(
+        { kind: "instant", value: selection.evaluatedAt},
+        { kind: "instant", value: data.recordedAt}
+      ) > 0)
+        error(
+          "SELECTION.ORDER",
+          p,
+          "Selection evaluation cannot follow its recording."
+        );
+      unchecked.add(selection.methodRef);
+    }
+    const measurements = /* @__PURE__ */ new Set();
+    for (const link of entity2.measurements ?? []) {
+      if (measurements.has(link.id))
+        error(
+          "REF.UNIQUE_ID",
+          `${path}/measurements`,
+          "Measurement link IDs repeat."
+        );
+      measurements.add(link.id);
+      unchecked.add(`measurement:${link.measurementId}`);
+      if (link.relatedPlaceId && !entities.has(`place:${link.relatedPlaceId}`))
+        error(
+          "REF.LOCAL_RESOLUTION",
+          `${path}/measurements`,
+          "Related place does not resolve."
+        );
+    }
+  }
+  const degree = new Map([...relativeGraph.keys()].map((k) => [k, 0]));
+  for (const edges of relativeGraph.values())
+    for (const to of edges)
+      if (degree.has(to)) degree.set(to, degree.get(to) + 1);
+  const queue = [...degree].filter(([, n]) => n === 0).map(([key2]) => key2);
+  for (let i = 0; i < queue.length; i++)
+    for (const to of relativeGraph.get(queue[i]) ?? [])
+      if (degree.has(to)) {
+        degree.set(to, degree.get(to) - 1);
+        if (degree.get(to) === 0) queue.push(to);
+      }
+  if (queue.length !== degree.size)
+    error(
+      "TIME.RELATIVE_CYCLE",
+      "/entities",
+      "Relative dates must be acyclic."
+    );
+  const validation = {
+    contract,
+    issues,
+    uncheckedRefs: [...unchecked],
+    checks: {
+      structural: "passed",
+      semantic: issues.length ? "failed" : "passed",
+      profile: "not_checked",
+      external: "not_checked"
+    }
+  };
+  return issues.length ? { ...validation, success: false } : { ...validation, success: true, data };
+}
+var text5 = z.string().min(1).regex(/\S/, "must contain non-whitespace text");
+var id4 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var claimRef2 = z.string().regex(/^claim:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var inputRef2 = z.string().regex(
+  /^(?:claim|source|product|assertion|measurement):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/
+);
+var ContextClaimSubjectSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("observation") }),
+  z.strictObject({
+    kind: z.literal("context"),
+    reference: ContextReferenceSchema
+  }),
+  z.strictObject({ kind: z.literal("measurement"), measurementId: id4 })
+]);
+var common2 = {
+  id: id4,
+  recordedAt: instantString,
+  topic: text5,
+  subject: ContextClaimSubjectSchema,
+  supersedes: z.array(claimRef2).min(1).optional()
+};
+var ContextSourceStatementSchema = z.strictObject({
+  ...common2,
+  kind: z.literal("source_assertion"),
+  text: text5,
+  reportedLevel: text5.optional(),
+  provenance: ObservationAssertionSchema.options[0].shape.provenance
+});
+var assessment2 = {
+  ...common2,
+  kind: z.literal("assessment"),
+  inputRefs: z.array(inputRef2),
+  contextInputRefs: z.array(ContextAssertionReferenceSchema).optional(),
+  rationale: text5
+};
+var ContextUnassessedClaimSchema = z.strictObject({
+  ...assessment2,
+  status: z.literal("unassessed")
+});
+var ContextAssessedClaimSchema = z.strictObject({
+  ...assessment2,
+  status: z.literal("assessed"),
+  outcome: z.enum(["reported", "confirmed", "absent", "inconclusive"]),
+  evaluatedBy: text5,
+  evaluatedAt: instantString,
+  methodRef: z.string().regex(/^method:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/),
+  methodVersion: text5,
+  confidence: z.number().min(0).max(1).optional()
+});
+var ContextHistoricalClaimSchema = z.union([
+  ContextSourceStatementSchema,
+  ContextUnassessedClaimSchema,
+  ContextAssessedClaimSchema
+]);
+var CONTEXT_CLAIM_HISTORY_SCHEMA_ID = "urn:disclosureos:experimental:claim-history:0.2.0";
+var CONTEXT_CLAIM_HISTORY_RULESET_VERSION = "0.2.0";
+var ContextClaimHistorySchema = z.strictObject({
+  kind: z.literal("claim_history"),
+  schemaVersion: z.literal("0.2.0"),
+  id: id4,
+  contextRefs: z.array(
+    DocumentSnapshotRefSchema.extend({
+      schemaId: z.literal(OBSERVATION_CONTEXT_SCHEMA_ID)
+    })
+  ),
+  observation: ExperimentalObservationSchema,
+  claims: z.array(ContextHistoricalClaimSchema),
+  extensions: ExperimentalObservationSchema.shape.extensions
+});
+function contextClaimHistoryJsonSchema() {
+  return {
+    ...z.toJSONSchema(ContextClaimHistorySchema, {
+      target: "draft-2020-12",
+      reused: "ref"
+    }),
+    $id: CONTEXT_CLAIM_HISTORY_SCHEMA_ID
+  };
+}
+
+// src/experimental/v2/context-claim-history.ts
+var point2 = (value) => ({
+  kind: "instant",
+  value,
+  timeScale: "UTC"
+});
+var pointer4 = (path) => path.map((p) => `/${String(p).replace(/~/g, "~0").replace(/\//g, "~1")}`).join("");
+function parseContextClaimHistory(input) {
+  const contract = {
+    kind: "claim_history",
+    schemaId: CONTEXT_CLAIM_HISTORY_SCHEMA_ID,
+    rulesetVersion: CONTEXT_CLAIM_HISTORY_RULESET_VERSION
+  };
+  const parsed = ContextClaimHistorySchema.safeParse(input);
+  if (!parsed.success)
+    return {
+      success: false,
+      contract,
+      checks: {
+        structural: "failed",
+        semantic: "not_checked",
+        profile: "not_checked",
+        external: "not_checked"
+      },
+      uncheckedRefs: [],
+      issues: parsed.error.issues.map((issue) => ({
+        code: "STRUCT.VALUE",
+        stage: "structural",
+        severity: "error",
+        pointer: pointer4(issue.path),
+        message: issue.message
+      }))
+    };
+  const data = parsed.data;
+  const observationResult = parseExperimentalObservation(data.observation);
+  const issues = observationResult.issues.map(
+    (issue) => ({ ...issue, pointer: `/observation${issue.pointer}` })
+  );
+  const problem = (code, path, message) => issues.push({
+    code,
+    stage: "semantic",
+    severity: "error",
+    pointer: path,
+    message
+  });
+  const claims = /* @__PURE__ */ new Map();
+  const graph = /* @__PURE__ */ new Map();
+  const superseded = /* @__PURE__ */ new Set();
+  const sources = new Map(
+    data.observation.sources.map((item) => [`source:${item.id}`, item])
+  );
+  const products = new Map(
+    data.observation.products.map((item) => [`product:${item.id}`, item])
+  );
+  const methods = new Map(
+    data.observation.methods.map((item) => [`method:${item.id}`, item])
+  );
+  const measurements = new Set(
+    data.observation.measurements.map((item) => `measurement:${item.id}`)
+  );
+  const available = /* @__PURE__ */ new Set([
+    ...sources.keys(),
+    ...products.keys(),
+    ...measurements,
+    ...data.observation.assertions.map((item) => `assertion:${item.id}`)
+  ]);
+  for (const [i, claim] of data.claims.entries()) {
+    const ref2 = `claim:${claim.id}`;
+    if (claims.has(ref2))
+      problem(
+        "REF.UNIQUE_ID",
+        `/claims/${i}/id`,
+        "Duplicate claim ID; each revision must have its own ID."
+      );
+    else {
+      claims.set(ref2, claim);
+      graph.set(ref2, /* @__PURE__ */ new Set());
+      available.add(ref2);
+    }
+  }
+  function instant(value, path) {
+    const local = [];
+    checkTime(point2(value), path, local);
+    for (const issue of local)
+      problem(issue.code, issue.pointer, issue.message);
+  }
+  function resolve(ref2, path, owner) {
+    if (!available.has(ref2))
+      problem(
+        "REF.LOCAL_RESOLUTION",
+        path,
+        `Undeclared local reference: ${ref2}`
+      );
+    else if (owner && claims.has(ref2)) graph.get(owner)?.add(ref2);
+  }
+  function refs(values2, path, owner) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [i, ref2] of values2.entries()) {
+      if (seen.has(ref2))
+        problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
+      seen.add(ref2);
+      resolve(ref2, `${path}/${i}`, owner);
+    }
+  }
+  const snapshots = new Set(data.contextRefs.map((r) => JSON.stringify(r)));
+  if (snapshots.size !== data.contextRefs.length)
+    problem(
+      "REF.UNIQUE_ID",
+      "/contextRefs",
+      "Context snapshot references repeat."
+    );
+  for (const [i, claim] of data.claims.entries()) {
+    const contextRefs = [
+      ...claim.subject.kind === "context" ? [claim.subject.reference] : [],
+      ...claim.kind === "assessment" ? claim.contextInputRefs ?? [] : []
+    ];
+    for (const ref2 of contextRefs)
+      if (!snapshots.has(JSON.stringify(ref2.document)))
+        problem(
+          "REF.LOCAL_RESOLUTION",
+          `/claims/${i}`,
+          "Context reference must select a declared snapshot."
+        );
+    if (claim.kind === "assessment" && new Set((claim.contextInputRefs ?? []).map((r) => JSON.stringify(r))).size !== (claim.contextInputRefs ?? []).length)
+      problem(
+        "REF.UNIQUE_ID",
+        `/claims/${i}/contextInputRefs`,
+        "Context inputs repeat."
+      );
+  }
+  for (const [i, claim] of data.claims.entries()) {
+    const path = `/claims/${i}`;
+    const owner = `claim:${claim.id}`;
+    instant(claim.recordedAt, `${path}/recordedAt`);
+    if (claim.subject.kind === "measurement")
+      resolve(
+        `measurement:${claim.subject.measurementId}`,
+        `${path}/subject/measurementId`
+      );
+    if (claim.supersedes) {
+      refs(claim.supersedes, `${path}/supersedes`, owner);
+      for (const [j, ref2] of claim.supersedes.entries()) {
+        const previous = claims.get(ref2);
+        if (!previous) continue;
+        superseded.add(ref2);
+        if (previous.kind !== claim.kind || previous.topic !== claim.topic || JSON.stringify(previous.subject) !== JSON.stringify(claim.subject)) {
+          problem(
+            "CLAIM.SUPERSESSION_SCOPE",
+            `${path}/supersedes/${j}`,
+            "A revision must retain the claim kind, topic, and subject. Record a different claim separately."
+          );
+        }
+        if (previous.kind === "assessment" && previous.status === "assessed" && claim.kind === "assessment" && (claim.status !== "assessed" || previous.evaluatedBy !== claim.evaluatedBy)) {
+          problem(
+            "CLAIM.REVISION_ATTRIBUTION",
+            `${path}/supersedes/${j}`,
+            "An assessed revision must retain its evaluator; other evaluators record independent assessments."
+          );
+        }
+        if (comparePoints(point2(previous.recordedAt), point2(claim.recordedAt)) > 0) {
+          problem(
+            "CLAIM.REVISION_ORDER",
+            `${path}/recordedAt`,
+            "A revision cannot be recorded before the statement it supersedes."
+          );
+        }
+      }
+    }
+    if (claim.kind === "source_assertion") {
+      resolve(claim.provenance.sourceRef, `${path}/provenance/sourceRef`);
+      const source = sources.get(claim.provenance.sourceRef) ?? products.get(claim.provenance.sourceRef);
+      if (source?.digest && claim.provenance.sourceDigest && source.digest.value !== claim.provenance.sourceDigest.value) {
+        problem(
+          "SOURCE.DIGEST_MISMATCH",
+          `${path}/provenance/sourceDigest`,
+          "Digest differs from the inventory declaration; neither is verified against bytes."
+        );
+      }
+      const locator = claim.provenance.locator;
+      if (locator?.kind === "time_range" && locator.endSeconds < locator.startSeconds)
+        problem(
+          "TIME.INTERVAL",
+          `${path}/provenance/locator/endSeconds`,
+          "Locator end precedes its start."
+        );
+    } else {
+      refs(claim.inputRefs, `${path}/inputRefs`, owner);
+      if (claim.status === "assessed") {
+        instant(claim.evaluatedAt, `${path}/evaluatedAt`);
+        if (comparePoints(point2(claim.evaluatedAt), point2(claim.recordedAt)) > 0)
+          problem(
+            "CLAIM.EVALUATION_ORDER",
+            `${path}/evaluatedAt`,
+            "Evaluation cannot occur after the assessment was recorded."
+          );
+        const method = methods.get(claim.methodRef);
+        if (!method)
+          problem(
+            "REF.LOCAL_RESOLUTION",
+            `${path}/methodRef`,
+            "Assessment method is not declared in the Observation inventory."
+          );
+        else if (method.version !== claim.methodVersion)
+          problem(
+            "METHOD.VERSION_MISMATCH",
+            `${path}/methodVersion`,
+            "Assessment method version differs from its inventory declaration."
+          );
+      }
+    }
+  }
+  const indegrees = new Map([...graph.keys()].map((ref2) => [ref2, 0]));
+  for (const edges of graph.values())
+    for (const ref2 of edges) indegrees.set(ref2, indegrees.get(ref2) + 1);
+  const queue = [...indegrees].filter(([, degree]) => degree === 0).map(([ref2]) => ref2);
+  for (let i = 0; i < queue.length; i++)
+    for (const ref2 of graph.get(queue[i]) ?? []) {
+      const degree = indegrees.get(ref2) - 1;
+      indegrees.set(ref2, degree);
+      if (degree === 0) queue.push(ref2);
+    }
+  if (queue.length !== graph.size)
+    problem(
+      "CLAIM.DEPENDENCY_CYCLE",
+      "/claims",
+      "Claim inputs and supersession must form an acyclic history."
+    );
+  const validation = {
+    contract,
+    issues,
+    uncheckedRefs: [
+      ...data.contextRefs.map((r) => r.sha256),
+      ...observationResult.uncheckedRefs,
+      ...data.claims.flatMap((c) => [
+        ...c.subject.kind === "context" ? [c.subject.reference.document.sha256] : [],
+        ...c.kind === "assessment" ? (c.contextInputRefs ?? []).map((r) => r.document.sha256) : []
+      ])
+    ],
+    checks: {
+      structural: "passed",
+      semantic: issues.length ? "failed" : "passed",
+      profile: "not_checked",
+      external: "not_checked"
+    }
+  };
+  return issues.length ? { ...validation, success: false } : {
+    ...validation,
+    success: true,
+    data,
+    currentClaimRefs: [...claims.keys()].filter(
+      (ref2) => !superseded.has(ref2)
+    )
+  };
+}
+
+export { AssessedClaimSchema, CLAIM_HISTORY_RULESET_VERSION, CONTEXT_CLAIM_HISTORY_RULESET_VERSION, CONTEXT_CLAIM_HISTORY_SCHEMA_ID, ClaimSubjectSchema, ContextAssertionReferenceSchema, ContextAssessedClaimSchema, ContextClaimHistorySchema, ContextClaimSubjectSchema, ContextCollectionFields, ContextEntitySchema, ContextEnvironmentFields, ContextEventFields, ContextHistoricalClaimSchema, ContextMeasurementLinkSchema, ContextObjectFields, ContextPlaceFields, ContextPlatformFields, ContextReferenceSchema, ContextSourceStatementSchema, ContextTargetSchema, ContextTemporalFields, ContextUnassessedClaimSchema, DocumentSnapshotRefSchema, EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID, EXPERIMENTAL_OBSERVATION_SCHEMA_ID, EventTimeIntervalSchema, EventTimePointSchema, EventTimeSchema, EventTimeValueSchema, ExperimentalClaimHistorySchema, ExperimentalObservationSchema, FramedPositionSchema, HistoricalClaimSchema, MeasuredQuantitySchema, OBSERVATION_CONTEXT_SCHEMA_ID, ObservationAssertionSchema, ObservationContextSchema, ObservationMeasurementSchema, ObservationMethodSchema, ObservationPositionSchema, ObservationProductSchema, ObservationSnapshotRefSchema, ObservationSourceSchema, ObservationTimeSchema, PRIMITIVES_SCHEMA_ID, PositionSchema, PositionValueSchema, PrimitiveRecordSchema, ProcessingActivitySchema, QuantitativeUncertaintySchema, ReferenceFrameSchema, SourceProvenanceSchema, SourceStatementSchema, UnassessedClaimSchema, ValueAssertionSchema, ValueSelectionSchema, compareUtcInstants, contextAssertions, contextClaimHistoryJsonSchema, experimentalClaimHistoryJsonSchema, experimentalObservationJsonSchema, observationContextJsonSchema, parseContextClaimHistory, parseExperimentalClaimHistory, parseExperimentalObservation, parseObservationContext, parsePrimitiveRecord, primitivesJsonSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map