@disclosureos/records 1.1.0 → 2.0.0-beta.0

package/dist/experimental/v2/index.js

@@ -0,0 +1,645 @@
+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 target = assertions.get(ref2.slice("assertion:".length));
+      if (!target) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Local assertion does not exist." });
+      else if (target.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Assertion concerns a different field." });
+    }
+    const 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 target = assertions.get(ref2.slice("assertion:".length));
+      if (!target) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion does not exist." });
+      else if (target.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion concerns a different field." });
+    }
+    const 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 target = assertions.get(key(value.assertionRef));
+    if (target && !matchesField(value.assertionRef, field, measurementId)) problem("REF.FIELD_MISMATCH", `${selectionPath}/assertionRef`, "Selected assertion concerns a different field or measurement.");
+    else if (target && JSON.stringify(target.value) !== JSON.stringify(selectedValue)) problem("SELECTION.VALUE_MISMATCH", `${path}/value`, "Selection must copy the cited assertion value exactly; processing is declared separately.");
+  }
+  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((id3) => `source:${id3}`).concat(
+    [...products.keys()].map((id3) => `product:${id3}`),
+    [...methods.keys()].map((id3) => `method:${id3}`),
+    [...frames.keys()].map((id3) => `frame:${id3}`)
+  );
+  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(values, path, owner) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [i, ref2] of values.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;
+}
+
+export { AssessedClaimSchema, CLAIM_HISTORY_RULESET_VERSION, ClaimSubjectSchema, EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID, EXPERIMENTAL_OBSERVATION_SCHEMA_ID, EventTimeIntervalSchema, EventTimePointSchema, EventTimeSchema, EventTimeValueSchema, ExperimentalClaimHistorySchema, ExperimentalObservationSchema, FramedPositionSchema, HistoricalClaimSchema, MeasuredQuantitySchema, ObservationAssertionSchema, ObservationMeasurementSchema, ObservationMethodSchema, ObservationPositionSchema, ObservationProductSchema, ObservationSourceSchema, ObservationTimeSchema, PRIMITIVES_SCHEMA_ID, PositionSchema, PositionValueSchema, PrimitiveRecordSchema, ProcessingActivitySchema, QuantitativeUncertaintySchema, ReferenceFrameSchema, SourceProvenanceSchema, SourceStatementSchema, UnassessedClaimSchema, ValueAssertionSchema, ValueSelectionSchema, compareUtcInstants, experimentalClaimHistoryJsonSchema, experimentalObservationJsonSchema, parseExperimentalClaimHistory, parseExperimentalObservation, parsePrimitiveRecord, primitivesJsonSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map