@disclosureos/records 1.1.0 → 2.0.0-beta.1

package/dist/experimental/v2/index.js

@@ -0,0 +1,2047 @@
+import { z } from 'zod';
+
+// src/experimental/v2/primitives.ts
+var text = z.string().min(1).regex(/\S/, "must contain non-whitespace text");
+var identifier = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var sourceRef = z.string().regex(/^(source|product):[^\s:]+$/);
+var valueRef = z.string().regex(/^(source|product|assertion):[^\s:]+$/);
+var sourceRefs = z.array(valueRef).min(1);
+var instantString = z.iso.datetime({ offset: true }).regex(/^(?!0000)/).regex(/T[0-9]{2}:[0-9]{2}:[0-9]{2}/).regex(/(?:Z|[+-][0-9]{2}:[0-9]{2})(?![\s\S])/);
+var EventTimePointSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("year"), value: z.string().regex(/^(?!0000)[0-9]{4}$/) }),
+  z.strictObject({ kind: z.literal("month"), value: z.string().regex(/^(?!0000)[0-9]{4}-(0[1-9]|1[0-2])$/) }),
+  z.strictObject({ kind: z.literal("date"), value: z.iso.date().regex(/^(?!0000)/) }),
+  z.strictObject({ kind: z.literal("instant"), value: instantString, timeScale: z.literal("UTC") })
+]);
+var EventTimeIntervalSchema = z.strictObject({
+  kind: z.literal("interval"),
+  start: EventTimePointSchema,
+  end: EventTimePointSchema
+});
+var EventTimeValueSchema = z.union([EventTimePointSchema, EventTimeIntervalSchema]);
+var assertionRef = z.string().regex(/^assertion:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var ValueSelectionSchema = z.strictObject({
+  assertionRef,
+  consideredAssertionRefs: z.array(assertionRef).min(1),
+  methodRef: z.string().regex(/^method:[^\s:]+(?![\s\S])/),
+  methodVersion: text,
+  evaluatedBy: text,
+  evaluatedAt: instantString,
+  rationale: text
+});
+var PositionValueSchema = z.strictObject({
+  latitude: z.number().min(-90).max(90),
+  longitude: z.number().min(-180).max(180),
+  datum: z.literal("WGS84")
+});
+function envelope(value) {
+  return z.discriminatedUnion("state", [
+    z.strictObject({ state: z.literal("known"), value, sourceRefs, selection: ValueSelectionSchema.optional() }),
+    z.strictObject({ state: z.literal("approximate"), value, sourceRefs, precision: text, selection: ValueSelectionSchema.optional() }),
+    z.strictObject({ state: z.literal("unknown"), reason: z.enum(["not_recorded", "not_collected", "unavailable"]) }),
+    z.strictObject({ state: z.literal("redacted"), reason: text })
+  ]);
+}
+var EventTimeSchema = envelope(EventTimeValueSchema);
+var PositionSchema = envelope(PositionValueSchema);
+var SourceProvenanceSchema = z.strictObject({
+  sourceRef,
+  sourceDigest: z.strictObject({ algorithm: z.literal("sha256"), value: z.string().regex(/^[a-f0-9]{64}$/) }).optional(),
+  locator: z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("page"), page: z.number().int().min(1) }),
+    z.strictObject({ kind: z.literal("time_range"), startSeconds: z.number().min(0), endSeconds: z.number().min(0) }),
+    z.strictObject({ kind: z.literal("json_pointer"), pointer: z.string().regex(/^(?:\/(?:[^~]|~[01])*)?(?![\s\S])/) })
+  ]).optional(),
+  attributedTo: text.optional(),
+  extractedBy: text.optional()
+});
+var ValueAssertionSchema = z.discriminatedUnion("field", [
+  z.strictObject({ id: identifier, field: z.literal("eventTime"), value: EventTimeValueSchema, provenance: SourceProvenanceSchema }),
+  z.strictObject({ id: identifier, field: z.literal("position"), value: PositionValueSchema, provenance: SourceProvenanceSchema })
+]);
+var PrimitiveRecordSchema = z.strictObject({
+  id: identifier,
+  eventTime: EventTimeSchema,
+  position: PositionSchema,
+  assertions: z.array(ValueAssertionSchema).optional()
+});
+var pointer = (path) => path.map((p) => `/${String(p).replace(/~/g, "~0").replace(/\//g, "~1")}`).join("");
+function instantParts(value) {
+  const dot = value.indexOf(".", 10);
+  if (dot === -1) return { milliseconds: Date.parse(value), fraction: "" };
+  let end = dot + 1;
+  while (end < value.length && value[end] >= "0" && value[end] <= "9") end++;
+  return { milliseconds: Date.parse(value.slice(0, dot) + value.slice(end)), fraction: value.slice(dot + 1, end) };
+}
+function comparePoints(start, end) {
+  if (start.kind !== "instant" || end.kind !== "instant") return start.value < end.value ? -1 : start.value > end.value ? 1 : 0;
+  const a = instantParts(start.value);
+  const b = instantParts(end.value);
+  if (!Number.isFinite(a.milliseconds) || !Number.isFinite(b.milliseconds)) return NaN;
+  if (a.milliseconds !== b.milliseconds) return a.milliseconds < b.milliseconds ? -1 : 1;
+  const digits = Math.max(a.fraction.length, b.fraction.length);
+  const af = a.fraction.padEnd(digits, "0");
+  const bf = b.fraction.padEnd(digits, "0");
+  return af < bf ? -1 : af > bf ? 1 : 0;
+}
+function checkTime(value, path, issues) {
+  if (value.kind === "instant" && !Number.isFinite(instantParts(value.value).milliseconds)) {
+    issues.push({ code: "TIME.INSTANT", stage: "semantic", pointer: path, message: "Instant cannot be resolved with its declared UTC offset." });
+  }
+  if (value.kind !== "interval") return;
+  checkTime(value.start, `${path}/start`, issues);
+  checkTime(value.end, `${path}/end`, issues);
+  if (value.start.kind !== value.end.kind) {
+    issues.push({ code: "TIME.PRECISION_MISMATCH", stage: "semantic", pointer: path, message: "Interval endpoints must use the same kind of calendar precision or both be instants." });
+  } else if (comparePoints(value.start, value.end) > 0) {
+    issues.push({ code: "TIME.INTERVAL", stage: "semantic", pointer: `${path}/end`, message: "Interval end precedes its start." });
+  }
+}
+function parsePrimitiveRecord(input) {
+  const result = PrimitiveRecordSchema.safeParse(input);
+  if (!result.success) return { success: false, uncheckedRefs: [], issues: result.error.issues.map((issue) => ({
+    code: "STRUCT.VALUE",
+    stage: "structural",
+    pointer: pointer(issue.path),
+    message: issue.message
+  })) };
+  const data = result.data;
+  const issues = [];
+  const unchecked = /* @__PURE__ */ new Set();
+  const assertions = /* @__PURE__ */ new Map();
+  for (const [index, assertion] of (data.assertions ?? []).entries()) {
+    if (assertions.has(assertion.id)) issues.push({ code: "REF.UNIQUE_ID", stage: "semantic", pointer: `/assertions/${index}/id`, message: "Assertion ID is duplicated." });
+    else assertions.set(assertion.id, assertion);
+    unchecked.add(assertion.provenance.sourceRef);
+    if (assertion.field === "eventTime") checkTime(assertion.value, `/assertions/${index}/value`, issues);
+    const locator = assertion.provenance.locator;
+    if (locator?.kind === "time_range" && locator.endSeconds < locator.startSeconds) issues.push({ code: "TIME.INTERVAL", stage: "semantic", pointer: `/assertions/${index}/provenance/locator/endSeconds`, message: "Locator end precedes its start." });
+  }
+  for (const field of ["eventTime", "position"]) {
+    const value = data[field];
+    if (value.state !== "known" && value.state !== "approximate") continue;
+    if (field === "eventTime" && (data.eventTime.state === "known" || data.eventTime.state === "approximate")) checkTime(data.eventTime.value, "/eventTime/value", issues);
+    for (const [index, ref2] of value.sourceRefs.entries()) {
+      if (!ref2.startsWith("assertion:")) {
+        unchecked.add(ref2);
+        continue;
+      }
+      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;
+    const path = `/${field}/selection`;
+    unchecked.add(selection.methodRef);
+    if (!Number.isFinite(instantParts(selection.evaluatedAt).milliseconds)) issues.push({ code: "TIME.INSTANT", stage: "semantic", pointer: `${path}/evaluatedAt`, message: "Selection timestamp cannot be resolved with its declared UTC offset." });
+    if (!selection.consideredAssertionRefs.includes(selection.assertionRef)) issues.push({ code: "SELECTION.INPUTS", stage: "semantic", pointer: `${path}/assertionRef`, message: "Selected assertion must be among the considered inputs." });
+    if (!value.sourceRefs.includes(selection.assertionRef)) issues.push({ code: "SELECTION.SOURCE_REF", stage: "semantic", pointer: `/${field}/sourceRefs`, message: "Field provenance must cite the selected assertion." });
+    const refs = /* @__PURE__ */ new Set();
+    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 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." });
+    else if (selected.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `${path}/assertionRef`, message: "Selected assertion concerns a different field." });
+    else if (JSON.stringify(selected.value) !== JSON.stringify(value.value)) issues.push({ code: "SELECTION.VALUE_MISMATCH", stage: "semantic", pointer: `/${field}/value`, message: "Selected value must equal the cited source value; derived values need a separate contract." });
+  }
+  return issues.length ? { success: false, issues, uncheckedRefs: [...unchecked] } : { success: true, data, issues, uncheckedRefs: [...unchecked] };
+}
+var PRIMITIVES_SCHEMA_ID = "urn:disclosureos:experimental:records-v2-primitives:0.2.0";
+function primitivesJsonSchema() {
+  return { ...z.toJSONSchema(PrimitiveRecordSchema, { target: "draft-2020-12" }), $id: PRIMITIVES_SCHEMA_ID };
+}
+var text2 = z.string().min(1).regex(/\S/, "must contain non-whitespace text");
+var id = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var ref = (kinds) => z.string().regex(new RegExp(`^(?:${kinds.join("|")}):[A-Za-z0-9][A-Za-z0-9._-]*(?![\\s\\S])`));
+var sourceProductRef = ref(["source", "product"]);
+var valueRef2 = ref(["source", "product", "assertion"]);
+var sourceRefs2 = z.array(valueRef2).min(1);
+var access = z.enum(["public", "restricted", "withheld", "unknown"]);
+var digest = z.strictObject({ algorithm: z.literal("sha256"), value: z.string().regex(/^[a-f0-9]{64}(?![\s\S])/) });
+var quantified = { magnitude: z.number().min(0), unit: text2, sourceRefs: z.array(sourceProductRef).min(1) };
+var QuantitativeUncertaintySchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("unknown"), reason: z.enum(["not_reported", "not_characterized", "unavailable"]) }),
+  z.strictObject({ kind: z.literal("standard"), ...quantified }),
+  z.strictObject({ kind: z.literal("expanded"), ...quantified, coverageFactor: z.number().positive(), coverageProbability: z.number().gt(0).lte(1).optional() }),
+  z.strictObject({ kind: z.literal("bound"), ...quantified })
+]);
+var MeasuredQuantitySchema = z.strictObject({
+  value: z.number(),
+  unit: text2,
+  uncertainty: QuantitativeUncertaintySchema
+});
+var definition = z.discriminatedUnion("state", [
+  z.strictObject({ state: z.literal("identified"), authority: text2, code: text2, revision: text2.optional() }),
+  z.strictObject({ state: z.literal("described"), description: text2 }),
+  z.strictObject({ state: z.literal("unknown"), reason: text2 })
+]);
+var ReferenceFrameSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ id, kind: z.literal("geodetic"), definition, angularUnit: z.literal("deg"), vertical: z.strictObject({ definition, unit: text2 }).optional() }),
+  z.strictObject({ id, kind: z.literal("cartesian"), definition, unit: text2 })
+]);
+var FramedPositionSchema = z.discriminatedUnion("kind", [
+  PositionValueSchema.omit({ datum: true }).extend({
+    kind: z.literal("geodetic"),
+    frameRef: ref(["frame"]),
+    altitude: MeasuredQuantitySchema.optional(),
+    uncertainty: z.strictObject({ latitude: QuantitativeUncertaintySchema, longitude: QuantitativeUncertaintySchema }).optional()
+  }),
+  z.strictObject({ kind: z.literal("cartesian"), frameRef: ref(["frame"]), x: MeasuredQuantitySchema, y: MeasuredQuantitySchema, z: MeasuredQuantitySchema })
+]);
+function envelope2(value) {
+  return z.discriminatedUnion("state", [
+    z.strictObject({ state: z.literal("known"), value, sourceRefs: sourceRefs2, selection: ValueSelectionSchema.optional() }),
+    z.strictObject({ state: z.literal("approximate"), value, sourceRefs: sourceRefs2, selection: ValueSelectionSchema.optional(), precision: text2 }),
+    z.strictObject({ state: z.literal("unknown"), reason: z.enum(["not_recorded", "not_collected", "unavailable"]) }),
+    z.strictObject({ state: z.literal("redacted"), reason: text2 })
+  ]);
+}
+var timeEnvelope = envelope2(EventTimeValueSchema);
+var ObservationTimeSchema = z.discriminatedUnion("state", [
+  timeEnvelope.options[0].extend({ uncertainty: QuantitativeUncertaintySchema.optional() }),
+  timeEnvelope.options[1].extend({ uncertainty: QuantitativeUncertaintySchema.optional() }),
+  timeEnvelope.options[2],
+  timeEnvelope.options[3]
+]);
+var ObservationPositionSchema = envelope2(FramedPositionSchema);
+var ObservationSourceSchema = z.strictObject({
+  id,
+  kind: z.enum(["document", "testimony", "instrument_data", "other", "unknown"]),
+  access,
+  title: text2.optional(),
+  uri: z.url().optional(),
+  digest: digest.optional()
+});
+var product = { id, format: text2, access, uri: z.url().optional(), digest: digest.optional() };
+var ObservationProductSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ ...product, kind: z.literal("raw"), sourceRefs: z.array(ref(["source"])).min(1) }),
+  z.strictObject({ ...product, kind: z.literal("derived"), generatedBy: ref(["process"]) })
+]);
+var ObservationMethodSchema = z.strictObject({ id, version: text2, description: text2.optional(), uri: z.url().optional() });
+var provenance = SourceProvenanceSchema.extend({ sourceRef: sourceProductRef, sourceDigest: digest.optional() });
+var ObservationAssertionSchema = z.discriminatedUnion("field", [
+  z.strictObject({ id, field: z.literal("eventTime"), value: EventTimeValueSchema, provenance }),
+  z.strictObject({ id, field: z.literal("position"), value: FramedPositionSchema, provenance }),
+  z.strictObject({ id, field: z.literal("measurement"), measurementId: id, value: MeasuredQuantitySchema, provenance })
+]);
+var ObservationMeasurementSchema = z.strictObject({
+  id,
+  quantity: text2,
+  value: MeasuredQuantitySchema,
+  sourceRefs: sourceRefs2,
+  frameRef: ref(["frame"]).optional(),
+  selection: ValueSelectionSchema.optional()
+});
+var ProcessingActivitySchema = z.strictObject({
+  id,
+  methodRef: ref(["method"]),
+  methodVersion: text2,
+  performedBy: text2,
+  performedAt: instantString,
+  inputRefs: z.array(valueRef2).min(1),
+  outputRefs: z.array(ref(["product"])).min(1)
+});
+var EXPERIMENTAL_OBSERVATION_SCHEMA_ID = "urn:disclosureos:experimental:observation:0.1.0";
+var ExperimentalObservationSchema = z.strictObject({
+  kind: z.literal("observation"),
+  schemaVersion: z.literal("0.1.0"),
+  id,
+  status: z.enum(["draft", "published", "withdrawn"]),
+  createdAt: instantString,
+  updatedAt: instantString,
+  summary: text2.optional(),
+  eventTime: ObservationTimeSchema,
+  position: ObservationPositionSchema,
+  sources: z.array(ObservationSourceSchema),
+  products: z.array(ObservationProductSchema),
+  methods: z.array(ObservationMethodSchema),
+  frames: z.array(ReferenceFrameSchema),
+  assertions: z.array(ObservationAssertionSchema),
+  measurements: z.array(ObservationMeasurementSchema),
+  processing: z.array(ProcessingActivitySchema),
+  extensions: z.record(z.string().regex(/^[a-z][a-z0-9_-]*(?:\.[a-z0-9_-]+)+(?![\s\S])/), z.json()).optional()
+});
+function experimentalObservationJsonSchema() {
+  return { ...z.toJSONSchema(ExperimentalObservationSchema, { target: "draft-2020-12" }), $id: EXPERIMENTAL_OBSERVATION_SCHEMA_ID };
+}
+
+// src/experimental/v2/observation.ts
+var pointer2 = (path) => path.map((p) => `/${String(p).replace(/~/g, "~0").replace(/\//g, "~1")}`).join("");
+var key = (ref2) => ref2.slice(ref2.indexOf(":") + 1);
+function parseExperimentalObservation(input) {
+  const parsed = ExperimentalObservationSchema.safeParse(input);
+  if (!parsed.success) return {
+    success: false,
+    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: pointer2(issue.path), message: issue.message }))
+  };
+  const data = parsed.data;
+  const issues = [];
+  const graph = /* @__PURE__ */ new Map();
+  const problem = (code, path, message) => issues.push({ code, stage: "semantic", severity: "error", pointer: path, message });
+  function index(items, prefix, collection) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [i, item] of items.entries()) {
+      if (result.has(item.id)) problem("REF.UNIQUE_ID", `/${collection}/${i}/id`, `Duplicate ${prefix} ID.`);
+      else {
+        result.set(item.id, item);
+        graph.set(`${prefix}:${item.id}`, /* @__PURE__ */ new Set());
+      }
+    }
+    return result;
+  }
+  const sources = index(data.sources, "source", "sources");
+  const products = index(data.products, "product", "products");
+  const methods = index(data.methods, "method", "methods");
+  const frames = index(data.frames, "frame", "frames");
+  const assertions = index(data.assertions, "assertion", "assertions");
+  index(data.measurements, "measurement", "measurements");
+  const processes = index(data.processing, "process", "processing");
+  const processOutputs = new Map(data.processing.map((process) => [process.id, new Set(process.outputRefs)]));
+  function resolve(ref2, path, owner) {
+    if (!graph.has(ref2)) {
+      problem("REF.LOCAL_RESOLUTION", path, `Undeclared local reference: ${ref2}`);
+      return false;
+    }
+    if (owner) graph.get(owner)?.add(ref2);
+    return true;
+  }
+  function references(refs, path, owner) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [i, ref2] of refs.entries()) {
+      if (seen.has(ref2)) problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
+      seen.add(ref2);
+      resolve(ref2, `${path}/${i}`, owner);
+    }
+  }
+  function method(ref2, version, path, owner) {
+    if (resolve(ref2, `${path}/methodRef`, owner) && methods.get(key(ref2))?.version !== version) {
+      problem("METHOD.VERSION_MISMATCH", `${path}/methodVersion`, "Method version differs from the local declaration.");
+    }
+  }
+  function time(value, path) {
+    const local = [];
+    checkTime(value, path, local);
+    for (const issue of local) problem(issue.code, issue.pointer, issue.message);
+  }
+  function instant(value, path) {
+    time({ kind: "instant", value}, path);
+  }
+  function uncertainty(value, expectedUnit, path, owner) {
+    if (value.kind === "unknown") return;
+    const units = typeof expectedUnit === "string" ? [expectedUnit] : expectedUnit;
+    if (!units.includes(value.unit)) problem("UNIT.MISMATCH", `${path}/unit`, "Uncertainty unit does not match the declared quantity; no conversion is inferred.");
+    references(value.sourceRefs, `${path}/sourceRefs`, owner);
+  }
+  function quantity(value, path, owner, expectedUnit) {
+    if (expectedUnit !== void 0 && value.unit !== expectedUnit) problem("UNIT.MISMATCH", `${path}/unit`, "Quantity unit differs from its reference frame.");
+    uncertainty(value.uncertainty, value.unit, `${path}/uncertainty`, owner);
+  }
+  function position(value, path, owner) {
+    resolve(value.frameRef, `${path}/frameRef`, owner);
+    const frame = frames.get(key(value.frameRef));
+    if (frame && frame.kind !== value.kind) problem("FRAME.KIND_MISMATCH", `${path}/frameRef`, "Position and reference frame use different coordinate systems.");
+    if (value.kind === "geodetic") {
+      if (value.uncertainty) {
+        uncertainty(value.uncertainty.latitude, "deg", `${path}/uncertainty/latitude`, owner);
+        uncertainty(value.uncertainty.longitude, "deg", `${path}/uncertainty/longitude`, owner);
+      }
+      if (value.altitude) {
+        if (frame?.kind === "geodetic" && !frame.vertical) problem("FRAME.VERTICAL_REFERENCE", `${path}/altitude`, "Altitude requires an explicit vertical reference and unit.");
+        quantity(value.altitude, `${path}/altitude`, owner, frame?.kind === "geodetic" ? frame.vertical?.unit : void 0);
+      }
+    } else {
+      for (const axis of ["x", "y", "z"]) quantity(value[axis], `${path}/${axis}`, owner, frame?.kind === "cartesian" ? frame.unit : void 0);
+    }
+  }
+  function matchesField(ref2, field, measurementId) {
+    const assertion = assertions.get(key(ref2));
+    return assertion?.field === field && (assertion.field !== "measurement" || assertion.measurementId === measurementId);
+  }
+  function fieldReferences(refs, field, path, owner, measurementId) {
+    references(refs, path, owner);
+    for (const [i, ref2] of refs.entries()) {
+      if (ref2.startsWith("assertion:") && assertions.has(key(ref2)) && !matchesField(ref2, field, measurementId)) problem("REF.FIELD_MISMATCH", `${path}/${i}`, "Assertion concerns a different field or measurement.");
+    }
+  }
+  function selection(value, selectedValue, refs, field, path, owner, measurementId) {
+    if (!value) {
+      if (refs.some((ref2) => ref2.startsWith("assertion:"))) problem("SELECTION.REQUIRED", `${path}/selection`, "A curated value citing local assertions requires an explicit selection record.");
+      return;
+    }
+    const selectionPath = `${path}/selection`;
+    instant(value.evaluatedAt, `${selectionPath}/evaluatedAt`);
+    method(value.methodRef, value.methodVersion, selectionPath, owner);
+    fieldReferences(value.consideredAssertionRefs, field, `${selectionPath}/consideredAssertionRefs`, owner, measurementId);
+    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 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");
+  if (comparePoints({ kind: "instant", value: data.createdAt}, { kind: "instant", value: data.updatedAt}) > 0) problem("TIME.RECORD_ORDER", "/updatedAt", "Record update precedes record creation.");
+  for (const [i, product2] of data.products.entries()) {
+    const owner = `product:${product2.id}`;
+    if (product2.kind === "raw") references(product2.sourceRefs, `/products/${i}/sourceRefs`, owner);
+    else {
+      resolve(product2.generatedBy, `/products/${i}/generatedBy`, owner);
+      const producer = processes.get(key(product2.generatedBy));
+      if (producer && !processOutputs.get(producer.id)?.has(owner)) problem("PROCESS.OUTPUT_MISMATCH", `/products/${i}/generatedBy`, "Producer does not list this derived product as an output.");
+    }
+  }
+  for (const [i, assertion] of data.assertions.entries()) {
+    const path = `/assertions/${i}`;
+    const owner = `assertion:${assertion.id}`;
+    resolve(assertion.provenance.sourceRef, `${path}/provenance/sourceRef`, owner);
+    const origin = assertion.provenance.sourceRef.startsWith("source:") ? sources.get(key(assertion.provenance.sourceRef)) : products.get(key(assertion.provenance.sourceRef));
+    if (assertion.provenance.sourceDigest && origin?.digest && assertion.provenance.sourceDigest.value !== origin.digest.value) problem("SOURCE.DIGEST_MISMATCH", `${path}/provenance/sourceDigest`, "Declared digest differs from the inventory declaration; neither has been verified against bytes.");
+    const locator = assertion.provenance.locator;
+    if (locator?.kind === "time_range" && locator.endSeconds < locator.startSeconds) problem("TIME.INTERVAL", `${path}/provenance/locator/endSeconds`, "Locator end precedes its start.");
+    if (assertion.field === "eventTime") time(assertion.value, `${path}/value`);
+    else if (assertion.field === "position") position(assertion.value, `${path}/value`, owner);
+    else {
+      resolve(`measurement:${assertion.measurementId}`, `${path}/measurementId`);
+      quantity(assertion.value, `${path}/value`, owner);
+    }
+  }
+  if (data.eventTime.state === "known" || data.eventTime.state === "approximate") {
+    time(data.eventTime.value, "/eventTime/value");
+    fieldReferences(data.eventTime.sourceRefs, "eventTime", "/eventTime/sourceRefs");
+    if (data.eventTime.uncertainty) uncertainty(data.eventTime.uncertainty, ["s", "ms", "us", "ns"], "/eventTime/uncertainty");
+    selection(data.eventTime.selection, data.eventTime.value, data.eventTime.sourceRefs, "eventTime", "/eventTime");
+  }
+  if (data.position.state === "known" || data.position.state === "approximate") {
+    position(data.position.value, "/position/value");
+    fieldReferences(data.position.sourceRefs, "position", "/position/sourceRefs");
+    selection(data.position.selection, data.position.value, data.position.sourceRefs, "position", "/position");
+  }
+  for (const [i, measurement] of data.measurements.entries()) {
+    const path = `/measurements/${i}`;
+    const owner = `measurement:${measurement.id}`;
+    if (measurement.frameRef) resolve(measurement.frameRef, `${path}/frameRef`, owner);
+    quantity(measurement.value, `${path}/value`, owner);
+    fieldReferences(measurement.sourceRefs, "measurement", `${path}/sourceRefs`, owner, measurement.id);
+    selection(measurement.selection, measurement.value, measurement.sourceRefs, "measurement", path, owner, measurement.id);
+  }
+  for (const [i, process] of data.processing.entries()) {
+    const path = `/processing/${i}`;
+    const owner = `process:${process.id}`;
+    instant(process.performedAt, `${path}/performedAt`);
+    method(process.methodRef, process.methodVersion, path, owner);
+    references(process.inputRefs, `${path}/inputRefs`, owner);
+    references(process.outputRefs, `${path}/outputRefs`);
+    for (const [j, ref2] of process.outputRefs.entries()) {
+      const product2 = products.get(key(ref2));
+      if (product2 && (product2.kind !== "derived" || product2.generatedBy !== owner)) problem("PROCESS.OUTPUT_MISMATCH", `${path}/outputRefs/${j}`, "Output must be a derived product identifying this producer.");
+    }
+  }
+  const indegrees = new Map([...graph.keys()].map((ref2) => [ref2, 0]));
+  for (const dependencies of graph.values()) for (const ref2 of dependencies) indegrees.set(ref2, (indegrees.get(ref2) ?? 0) + 1);
+  const queue = [...indegrees].filter(([, degree]) => degree === 0).map(([ref2]) => ref2);
+  for (let i = 0; i < queue.length; i++) {
+    for (const dependency of graph.get(queue[i]) ?? []) {
+      const degree = indegrees.get(dependency) - 1;
+      indegrees.set(dependency, degree);
+      if (degree === 0) queue.push(dependency);
+    }
+  }
+  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((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 };
+}
+var text3 = z.string().min(1).regex(/\S/, "must contain non-whitespace text");
+var id2 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var claimRef = z.string().regex(/^claim:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var inputRef = z.string().regex(/^(?:claim|source|product|assertion|measurement):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var ClaimSubjectSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("observation") }),
+  z.strictObject({ kind: z.literal("measurement"), measurementId: id2 })
+]);
+var common = {
+  id: id2,
+  recordedAt: instantString,
+  topic: text3,
+  subject: ClaimSubjectSchema,
+  supersedes: z.array(claimRef).min(1).optional()
+};
+var SourceStatementSchema = z.strictObject({
+  ...common,
+  kind: z.literal("source_assertion"),
+  text: text3,
+  reportedLevel: text3.optional(),
+  provenance: ObservationAssertionSchema.options[0].shape.provenance
+});
+var assessment = { ...common, kind: z.literal("assessment"), inputRefs: z.array(inputRef), rationale: text3 };
+var UnassessedClaimSchema = z.strictObject({ ...assessment, status: z.literal("unassessed") });
+var AssessedClaimSchema = z.strictObject({
+  ...assessment,
+  status: z.literal("assessed"),
+  outcome: z.enum(["reported", "confirmed", "absent", "inconclusive"]),
+  evaluatedBy: text3,
+  evaluatedAt: instantString,
+  methodRef: z.string().regex(/^method:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/),
+  methodVersion: text3,
+  confidence: z.number().min(0).max(1).optional()
+});
+var HistoricalClaimSchema = z.union([SourceStatementSchema, UnassessedClaimSchema, AssessedClaimSchema]);
+var EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID = "urn:disclosureos:experimental:claim-history:0.1.0";
+var CLAIM_HISTORY_RULESET_VERSION = "0.1.0";
+var ExperimentalClaimHistorySchema = z.strictObject({
+  kind: z.literal("claim_history"),
+  schemaVersion: z.literal("0.1.0"),
+  id: id2,
+  observation: ExperimentalObservationSchema,
+  claims: z.array(HistoricalClaimSchema),
+  extensions: ExperimentalObservationSchema.shape.extensions
+});
+function experimentalClaimHistoryJsonSchema() {
+  return { ...z.toJSONSchema(ExperimentalClaimHistorySchema, { target: "draft-2020-12" }), $id: EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID };
+}
+
+// src/experimental/v2/claim-history.ts
+var point = (value) => ({ kind: "instant", value, timeScale: "UTC" });
+var pointer3 = (path) => path.map((p) => `/${String(p).replace(/~/g, "~0").replace(/\//g, "~1")}`).join("");
+function parseExperimentalClaimHistory(input) {
+  const contract = { kind: "claim_history", schemaId: EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID, rulesetVersion: CLAIM_HISTORY_RULESET_VERSION };
+  const parsed = ExperimentalClaimHistorySchema.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: pointer3(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(point(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);
+    }
+  }
+  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(point(previous.recordedAt), point(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(point(claim.evaluatedAt), point(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: observationResult.uncheckedRefs,
+    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))
+  };
+}
+
+// src/experimental/v2/utc.ts
+function compareUtcInstants(left, right) {
+  if (!instantString.safeParse(left).success || !instantString.safeParse(right).success) return void 0;
+  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.");
+
+// 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