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

package/dist/experimental/v2/index.js

@@ -126,9 +126,9 @@ function parsePrimitiveRecord(input) {
         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 target4 = assertions.get(ref2.slice("assertion:".length));
+      if (!target4) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Local assertion does not exist." });
+      else if (target4.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;
@@ -137,13 +137,13 @@ function parsePrimitiveRecord(input) {
     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();
+    const refs2 = /* @__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." });
+      if (refs2.has(ref2)) issues.push({ code: "REF.UNIQUE_ID", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion is repeated." });
+      refs2.add(ref2);
+      const target4 = assertions.get(ref2.slice("assertion:".length));
+      if (!target4) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion does not exist." });
+      else if (target4.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." });
@@ -313,9 +313,9 @@ function parseExperimentalObservation(input) {
     if (owner) graph.get(owner)?.add(ref2);
     return true;
   }
-  function references(refs, path, owner) {
+  function references(refs2, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of refs.entries()) {
+    for (const [i, ref2] of refs2.entries()) {
       if (seen.has(ref2)) problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
       seen.add(ref2);
       resolve(ref2, `${path}/${i}`, owner);
@@ -365,15 +365,15 @@ function parseExperimentalObservation(input) {
     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()) {
+  function fieldReferences(refs2, field, path, owner, measurementId) {
+    references(refs2, path, owner);
+    for (const [i, ref2] of refs2.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) {
+  function selection(value, selectedValue, refs2, 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.");
+      if (refs2.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`;
@@ -382,10 +382,10 @@ function parseExperimentalObservation(input) {
     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.");
+    if (!refs2.includes(value.assertionRef)) problem("SELECTION.SOURCE_REF", `${path}/sourceRefs`, "Field must cite the selected assertion.");
+    const target4 = assertions.get(key(value.assertionRef));
+    if (target4 && !matchesField(value.assertionRef, field, measurementId)) problem("REF.FIELD_MISMATCH", `${selectionPath}/assertionRef`, "Selected assertion concerns a different field or measurement.");
+    else if (target4 && JSON.stringify(target4.value) !== JSON.stringify(selectedValue)) problem("SELECTION.VALUE_MISMATCH", `${path}/value`, "Selection must copy the cited assertion value exactly; processing is declared separately.");
   }
   instant(data.createdAt, "/createdAt");
   instant(data.updatedAt, "/updatedAt");
@@ -457,10 +457,10 @@ function parseExperimentalObservation(input) {
   }
   if (queue.length !== graph.size) problem("PROCESS.CYCLE", "/processing", "Local processing/provenance dependencies contain a cycle.");
   const checks = { structural: "passed", semantic: issues.length ? "failed" : "passed", profile: "not_checked", external: "not_checked" };
-  const uncheckedRefs = [...sources.keys()].map((id5) => `source:${id5}`).concat(
-    [...products.keys()].map((id5) => `product:${id5}`),
-    [...methods.keys()].map((id5) => `method:${id5}`),
-    [...frames.keys()].map((id5) => `frame:${id5}`)
+  const uncheckedRefs = [...sources.keys()].map((id10) => `source:${id10}`).concat(
+    [...products.keys()].map((id10) => `product:${id10}`),
+    [...methods.keys()].map((id10) => `method:${id10}`),
+    [...frames.keys()].map((id10) => `frame:${id10}`)
   );
   return issues.length ? { success: false, issues, checks, uncheckedRefs } : { success: true, data, issues, checks, uncheckedRefs };
 }
@@ -561,9 +561,9 @@ function parseExperimentalClaimHistory(input) {
     if (!available.has(ref2)) problem("REF.LOCAL_RESOLUTION", path, `Undeclared local reference: ${ref2}`);
     else if (owner && claims.has(ref2)) graph.get(owner)?.add(ref2);
   }
-  function refs(values2, path, owner) {
+  function refs2(values4, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of values2.entries()) {
+    for (const [i, ref2] of values4.entries()) {
       if (seen.has(ref2)) problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
       seen.add(ref2);
       resolve(ref2, `${path}/${i}`, owner);
@@ -575,7 +575,7 @@ function parseExperimentalClaimHistory(input) {
     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);
+      refs2(claim.supersedes, `${path}/supersedes`, owner);
       for (const [j, ref2] of claim.supersedes.entries()) {
         const previous = claims.get(ref2);
         if (!previous) continue;
@@ -600,7 +600,7 @@ function parseExperimentalClaimHistory(input) {
       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);
+      refs2(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.");
@@ -1438,8 +1438,8 @@ function observationContextJsonSchema() {
 }
 
 // src/experimental/v2/context.ts
-function contextAssertions(entity2) {
-  return Object.entries(entity2.fields).flatMap(
+function contextAssertions(entity4) {
+  return Object.entries(entity4.fields).flatMap(
     ([field, assertions]) => (assertions ?? []).map((assertion) => ({
       field,
       assertion
@@ -1453,7 +1453,7 @@ function parseObservationContext(input) {
     rulesetVersion: "0.1.0"
   };
   const issues = [];
-  const error = (code, pointer5, message) => issues.push({ code, stage: "semantic", pointer: pointer5, message });
+  const error = (code, pointer6, message) => issues.push({ code, stage: "semantic", pointer: pointer6, message });
   if (!parsed.success)
     return {
       success: false,
@@ -1475,12 +1475,12 @@ function parseObservationContext(input) {
   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}`;
+  for (const [i, entity4] of data.entities.entries()) {
+    const key2 = `${entity4.kind}:${entity4.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());
+    entities.set(key2, entity4);
+    if (entity4.kind === "temporal") relativeGraph.set(entity4.id, /* @__PURE__ */ new Set());
   }
   function time(value, path) {
     const found = [];
@@ -1493,9 +1493,9 @@ function parseObservationContext(input) {
   );
   const unchecked = /* @__PURE__ */ new Set([data.observationRef.sha256]);
   if (data.acquisitionRef) unchecked.add(data.acquisitionRef.sha256);
-  for (const [i, entity2] of data.entities.entries()) {
+  for (const [i, entity4] of data.entities.entries()) {
     const path = `/entities/${i}`;
-    const assertions = contextAssertions(entity2);
+    const assertions = contextAssertions(entity4);
     const ids = /* @__PURE__ */ new Set();
     for (const { field, assertion } of assertions) {
       const p = `${path}/fields/${field}`;
@@ -1528,8 +1528,8 @@ function parseObservationContext(input) {
           "Context entity reference does not resolve."
         );
       if (field === "placeIds") {
-        for (const id5 of content.value)
-          if (!entities.has(`place:${id5}`))
+        for (const id10 of content.value)
+          if (!entities.has(`place:${id10}`))
             error(
               "REF.LOCAL_RESOLUTION",
               p,
@@ -1552,7 +1552,7 @@ function parseObservationContext(input) {
             p,
             "Relative date anchor does not resolve."
           );
-        relativeGraph.get(entity2.id)?.add(relative2.anchorTemporalId);
+        relativeGraph.get(entity4.id)?.add(relative2.anchorTemporalId);
         if (relative2.relation === "during" && relative2.offset)
           error(
             "TIME.RELATIVE_OFFSET",
@@ -1608,7 +1608,7 @@ function parseObservationContext(input) {
       }
     }
     const selectedFields = /* @__PURE__ */ new Set();
-    for (const selection of entity2.selections ?? []) {
+    for (const selection of entity4.selections ?? []) {
       const p = `${path}/selections`;
       if (selectedFields.has(selection.field))
         error(
@@ -1625,9 +1625,9 @@ function parseObservationContext(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)
+      for (const id10 of selection.consideredAssertionIds)
         if (!assertions.some(
-          (a) => a.field === selection.field && a.assertion.id === id5
+          (a) => a.field === selection.field && a.assertion.id === id10
         ))
           error(
             "REF.FIELD_MISMATCH",
@@ -1661,7 +1661,7 @@ function parseObservationContext(input) {
       unchecked.add(selection.methodRef);
     }
     const measurements = /* @__PURE__ */ new Set();
-    for (const link of entity2.measurements ?? []) {
+    for (const link of entity4.measurements ?? []) {
       if (measurements.has(link.id))
         error(
           "REF.UNIQUE_ID",
@@ -1882,9 +1882,9 @@ function parseContextClaimHistory(input) {
       );
     else if (owner && claims.has(ref2)) graph.get(owner)?.add(ref2);
   }
-  function refs(values2, path, owner) {
+  function refs2(values4, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of values2.entries()) {
+    for (const [i, ref2] of values4.entries()) {
       if (seen.has(ref2))
         problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
       seen.add(ref2);
@@ -1927,7 +1927,7 @@ function parseContextClaimHistory(input) {
         `${path}/subject/measurementId`
       );
     if (claim.supersedes) {
-      refs(claim.supersedes, `${path}/supersedes`, owner);
+      refs2(claim.supersedes, `${path}/supersedes`, owner);
       for (const [j, ref2] of claim.supersedes.entries()) {
         const previous = claims.get(ref2);
         if (!previous) continue;
@@ -1973,7 +1973,7 @@ function parseContextClaimHistory(input) {
           "Locator end precedes its start."
         );
     } else {
-      refs(claim.inputRefs, `${path}/inputRefs`, owner);
+      refs2(claim.inputRefs, `${path}/inputRefs`, owner);
       if (claim.status === "assessed") {
         instant(claim.evaluatedAt, `${path}/evaluatedAt`);
         if (comparePoints(point2(claim.evaluatedAt), point2(claim.recordedAt)) > 0)
@@ -2041,7 +2041,1654 @@ function parseContextClaimHistory(input) {
     )
   };
 }
+var WitnessCategorySchema = z.enum([
+  "military_pilot",
+  "military_aircrew",
+  "military_ground",
+  "military_naval",
+  "military_radar_operator",
+  "military_other",
+  "commercial_pilot",
+  "commercial_aircrew",
+  "private_pilot",
+  "air_traffic_controller",
+  "aviation_other",
+  "government_official",
+  "elected_official",
+  "intelligence_officer",
+  "law_enforcement",
+  "scientist",
+  "astronomer",
+  "meteorologist",
+  "engineer",
+  "medical_professional",
+  "maritime",
+  "civilian",
+  "civilian_group",
+  "anonymous",
+  "unknown"
+]).describe("Professional/role category of a witness.");
+var CredibilityFactorSchema = z.enum([
+  "professional_training",
+  "official_capacity",
+  "sworn_statement",
+  "contemporaneous_record",
+  "corroborating_witnesses",
+  "corroborating_evidence",
+  "consistent_account",
+  "no_apparent_motive",
+  "reputation_risk",
+  "security_clearance"
+]).describe("A factor strengthening witness credibility.");
+var CredibilityDetractorSchema = z.enum([
+  "anonymous",
+  "inconsistent_account",
+  "delayed_report",
+  "known_fabricator",
+  "financial_motive",
+  "single_witness",
+  "impaired_state",
+  "recovered_memory"
+]).describe("A factor weakening witness credibility.");
+var WitnessCredibilitySchema = z.object({
+  // The former `CredibilityRating` was byte-identical to the qualitative
+  // `ConfidenceLevel`; it is now the single shared scale (DRY #1).
+  rating: ConfidenceLevelSchema.optional(),
+  factors: z.array(CredibilityFactorSchema).optional(),
+  detractors: z.array(CredibilityDetractorSchema).optional(),
+  isProfessionalObserver: z.boolean().optional().describe("Whether the witness is a trained observer (pilot, astronomer, military)."),
+  hasAviationExperience: z.boolean().optional().describe("Whether the witness has aviation experience."),
+  hasMilitaryExperience: z.boolean().optional().describe("Whether the witness has military experience."),
+  hasScientificBackground: z.boolean().optional().describe("Whether the witness has a scientific background."),
+  hasPriorUAPKnowledge: z.boolean().optional().describe("Whether the witness had prior knowledge of or interest in UAP before the observation."),
+  wasSkepticPrior: z.boolean().optional().describe("Whether the witness was a skeptic before the observation."),
+  underOathTestimony: z.boolean().optional().describe("Whether the testimony was given under oath."),
+  polygraphAdministered: z.boolean().optional().describe("Whether a polygraph was administered."),
+  polygraphPassed: z.boolean().optional().describe("Whether the witness passed the polygraph."),
+  consistentTestimony: z.boolean().optional().describe("Whether the account has remained consistent across retellings."),
+  willingToBeIdentified: z.boolean().optional().describe("Whether the witness is willing to be publicly identified."),
+  notes: z.string().optional().describe("Free-text context about the credibility assessment.")
+}).meta({ id: "WitnessCredibility" }).describe("Structured assessment of a witness's credibility (rating, factors, detractors).");
+
+// src/extensions/testimony/witness.ts
+var SecurityClearanceSchema = z.enum(["none", "confidential", "secret", "top_secret", "sci", "unknown"]).describe("Security clearance level held by a witness.");
+var WitnessSchema = z.object({
+  witnessId: z.string().describe("Stable unique identifier for this witness."),
+  category: WitnessCategorySchema,
+  anonymous: z.boolean().describe("Whether the witness\u2019s identity is withheld."),
+  publicName: z.string().optional().describe("Witness\u2019s name as publicly known, when not anonymous."),
+  pseudonym: z.string().optional().describe("Pseudonym used when the witness is anonymous."),
+  role: z.string().optional().describe('Witness\u2019s role at the time (e.g. "F/A-18F pilot", "radar operator").'),
+  organization: z.string().optional().describe("Organization the witness belonged to at the time."),
+  experienceYears: z.number().optional().describe("Years of relevant professional experience."),
+  securityClearance: SecurityClearanceSchema.optional(),
+  credibility: WitnessCredibilitySchema.optional(),
+  statementSummary: z.string().optional().describe("Brief summary of what the witness reported."),
+  interviewAvailable: z.boolean().optional().describe("Whether a recorded interview with the witness exists."),
+  writtenReportAvailable: z.boolean().optional().describe("Whether a written report from the witness exists.")
+}).meta({ id: "Witness" }).describe("A person who reported or corroborated an observation.");
+var TemporalCertaintySchema = z.enum(["exact", "approximate", "estimated", "unknown"]).describe("Confidence in a date or time value \u2014 the single certainty scale for all temporal values.");
+var ChainOfCustodySchema = z.enum([
+  "verified",
+  "partial",
+  "unverified",
+  "government_held",
+  "private_held",
+  "lost",
+  "destroyed",
+  "classified",
+  "unknown"
+]).describe("Custody status of an evidence item.");
+var CustodyActionSchema = z.enum([
+  "creation",
+  "collection",
+  "transfer",
+  "storage",
+  "analysis",
+  "release",
+  "classification",
+  "destruction",
+  "loss",
+  "recovery",
+  "other"
+]).describe("An action recorded in a chain-of-custody entry.");
+var CustodyEntrySchema = z.object({
+  entryId: z.string().describe("Stable unique identifier for this custody entry."),
+  date: z.string().describe("When the custody event occurred (ISO date)."),
+  action: CustodyActionSchema,
+  from: z.string().optional().describe("Party that held the evidence before this event."),
+  to: z.string().optional().describe("Party that held the evidence after this event."),
+  location: z.string().optional().describe("Where the custody event took place."),
+  reference: z.string().optional().describe("Document or record substantiating the event (e.g. transfer receipt, log entry)."),
+  notes: z.string().optional().describe("Free-text context about the event.")
+}).meta({ id: "CustodyEntry" }).describe("A single custody event for an evidence item.");
+z.object({
+  evidenceId: z.string().describe("Identifier of the evidence item this custody history belongs to."),
+  status: ChainOfCustodySchema,
+  entries: z.array(CustodyEntrySchema)
+}).meta({ id: "ChainOfCustodyRecord" }).describe("The full custody history for a piece of evidence.");
+
+// src/extensions/testimony/statement.ts
+var TestimonyContextSchema = z.enum([
+  "sworn_affidavit",
+  "congressional_testimony",
+  "deposition",
+  "official_interview",
+  "written_statement",
+  "recorded_interview",
+  "informal_account",
+  "anonymous_tip",
+  "whistleblower_disclosure"
+]).describe("The setting in which testimony was given.");
+var TestimonyDateSchema = z.object({
+  date: z.string().describe("When the testimony was given (ISO date)."),
+  certainty: TemporalCertaintySchema
+}).meta({ id: "TestimonyDate" }).describe("When testimony was given, with its certainty.");
+z.object({
+  statementId: z.string().describe('Stable id, addressable by a claim `evidenceRef` ("testimony:<statementId>").'),
+  witness: WitnessSchema,
+  context: TestimonyContextSchema,
+  date: TestimonyDateSchema,
+  content: z.string().optional().describe("Full text of the statement, when available."),
+  summary: z.string().optional().describe("Brief summary of what the statement asserts."),
+  sourceDocument: SourceReferenceSchema.optional(),
+  chainOfCustody: ChainOfCustodySchema.optional(),
+  additionalEvidenceIds: z.array(z.string()).optional().describe("Ids of other evidence items the statement references or supports.")
+}).meta({ id: "TestimonyStatement" }).describe("A single witness statement, its context, and supporting documentation.");
+
+// src/experimental/v2/research-entities-schema.ts
+var text6 = z.string().min(1).regex(/\S/);
+var id5 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var sourceRef3 = z.string().regex(/^(source|product):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var provenance3 = SourceProvenanceSchema.extend({ sourceRef: sourceRef3 });
+var RESEARCH_ENTITIES_SCHEMA_ID = "urn:disclosureos:experimental:research-entities:0.1.0";
+function values2(schema) {
+  return z.array(
+    z.strictObject({
+      id: id5.describe(
+        "Assertion identity within this entity, independent of array order."
+      ),
+      content: z.union([
+        z.strictObject({
+          state: z.literal("known"),
+          value: schema,
+          provenance: provenance3,
+          originalWording: text6.optional()
+        }),
+        z.strictObject({
+          state: z.literal("approximate"),
+          value: schema,
+          precision: text6,
+          provenance: provenance3,
+          originalWording: text6.optional()
+        }),
+        z.strictObject({
+          state: z.literal("unknown"),
+          reason: z.enum(["not_recorded", "not_collected", "unavailable"])
+        }),
+        z.strictObject({ state: z.literal("redacted"), reason: text6 }),
+        z.strictObject({
+          state: z.literal("unmapped"),
+          originalWording: text6,
+          provenance: provenance3
+        })
+      ])
+    })
+  ).min(1).optional();
+}
+var timeContextReference = ContextReferenceSchema.extend({
+  target: z.union([
+    ContextTargetSchema.options[0],
+    ContextTargetSchema.options[5]
+  ])
+}).describe(
+  "Temporal or event context for a qualification, not an arbitrary object attribute."
+);
+var relevantTime = z.union([
+  z.strictObject({ kind: z.literal("calendar"), value: EventTimeValueSchema }),
+  z.strictObject({
+    kind: z.literal("context"),
+    reference: timeContextReference
+  }),
+  z.strictObject({ kind: z.literal("unknown"), reason: text6 })
+]);
+var qualification = (value) => z.strictObject({ value, relevantTime });
+var ResearchWitnessFields = {
+  publicIdentity: values2(
+    z.discriminatedUnion("kind", [
+      z.strictObject({ kind: z.literal("public_name"), display: text6 }),
+      z.strictObject({ kind: z.literal("pseudonym"), display: text6 }),
+      z.strictObject({ kind: z.literal("withheld"), display: text6 })
+    ])
+  ),
+  anonymous: values2(z.boolean()),
+  willingToBeIdentified: values2(z.boolean()),
+  category: values2(qualification(WitnessCategorySchema)),
+  role: values2(qualification(text6)),
+  organization: values2(qualification(text6)),
+  experienceYears: values2(qualification(z.number().min(0))),
+  securityClearance: values2(qualification(SecurityClearanceSchema)),
+  isProfessionalObserver: values2(qualification(z.boolean())),
+  hasAviationExperience: values2(qualification(z.boolean())),
+  hasMilitaryExperience: values2(qualification(z.boolean())),
+  hasScientificBackground: values2(qualification(z.boolean())),
+  hasPriorUAPKnowledge: values2(qualification(z.boolean())),
+  wasSkepticPrior: values2(qualification(z.boolean())),
+  description: values2(text6)
+};
+var ResearchAccountFields = {
+  speakerWitnessIds: values2(z.array(id5).min(1)),
+  recorder: values2(text6),
+  context: values2(TestimonyContextSchema),
+  recordedTime: values2(EventTimeValueSchema),
+  dateCertainty: values2(
+    z.enum(["exact", "approximate", "estimated", "unknown"])
+  ),
+  eventContext: values2(ContextReferenceSchema),
+  content: values2(text6),
+  summary: values2(z.strictObject({ text: text6, summarizedBy: text6 })),
+  sourceDocument: values2(sourceRef3),
+  interviewAvailable: values2(z.boolean()),
+  writtenReportAvailable: values2(z.boolean()),
+  underOath: values2(z.boolean()),
+  custodyStatus: values2(ChainOfCustodySchema),
+  supportRefs: values2(z.array(sourceRef3).min(1))
+};
+var ResearchProcedureFields = {
+  procedureType: values2(z.literal("polygraph")),
+  witnessId: values2(id5),
+  accountId: values2(id5),
+  administered: values2(z.boolean()),
+  passed: values2(z.boolean()),
+  performedAt: values2(EventTimeValueSchema),
+  context: values2(text6),
+  sourceDocument: values2(sourceRef3)
+};
+var ResearchWitnessGroupFields = {
+  witnessIds: values2(z.array(id5).min(1)),
+  reportedCount: values2(z.number().int().min(0)),
+  categories: values2(z.array(WitnessCategorySchema).min(1)),
+  militaryWitnesses: values2(z.boolean()),
+  aviationWitnesses: values2(z.boolean()),
+  professionalObservers: values2(z.boolean()),
+  descriptions: values2(z.array(text6).min(1))
+};
+for (const fields of [
+  ResearchWitnessFields,
+  ResearchAccountFields,
+  ResearchProcedureFields,
+  ResearchWitnessGroupFields
+])
+  for (const [key2, schema] of Object.entries(fields))
+    fields[key2] = schema.describe(
+      `Sourced ${key2.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase()} assertions. Alternatives and unknowns are retained; supplied does not mean verified.`
+    );
+function entity2(kind, fields) {
+  return z.strictObject({
+    kind: z.literal(kind),
+    id: id5,
+    fields: z.strictObject(fields)
+  });
+}
+var ResearchEntitySchema = z.discriminatedUnion("kind", [
+  entity2("witness", ResearchWitnessFields),
+  entity2("account", ResearchAccountFields),
+  entity2("procedure", ResearchProcedureFields),
+  entity2("witness_group", ResearchWitnessGroupFields)
+]);
+var ResearchEntitiesSchema = z.strictObject({
+  kind: z.literal("research_entities"),
+  schemaVersion: z.literal("0.1.0"),
+  id: id5,
+  observationRef: ObservationSnapshotRefSchema,
+  contextRefs: z.array(
+    DocumentSnapshotRefSchema.extend({
+      schemaId: z.literal(OBSERVATION_CONTEXT_SCHEMA_ID)
+    })
+  ),
+  recordedAt: instantString,
+  recordedBy: text6,
+  entities: z.array(ResearchEntitySchema).min(1)
+}).describe(
+  "Public witness, account, procedure and aggregate declarations. Private identity mappings and contact fields belong outside this exchange document. No consent or credibility is inferred."
+);
+function target2(kind, fields) {
+  return z.strictObject({
+    kind: z.literal(kind),
+    id: id5,
+    field: z.enum(Object.keys(fields)).optional()
+  });
+}
+var ResearchEntityTargetSchema = z.discriminatedUnion("kind", [
+  target2("witness", ResearchWitnessFields),
+  target2("account", ResearchAccountFields),
+  target2("procedure", ResearchProcedureFields),
+  target2("witness_group", ResearchWitnessGroupFields)
+]);
+var ResearchEntityReferenceSchema = z.strictObject({
+  document: DocumentSnapshotRefSchema.extend({
+    schemaId: z.literal(RESEARCH_ENTITIES_SCHEMA_ID)
+  }),
+  target: ResearchEntityTargetSchema
+});
+var ResearchEntityAssertionReferenceSchema = ResearchEntityReferenceSchema.extend({ assertionId: id5 });
+function researchEntitiesJsonSchema() {
+  return {
+    ...z.toJSONSchema(ResearchEntitiesSchema, {
+      target: "draft-2020-12",
+      reused: "ref"
+    }),
+    $id: RESEARCH_ENTITIES_SCHEMA_ID
+  };
+}
+
+// src/experimental/v2/entity-document-validation.ts
+function researchEntityAssertions(entity4) {
+  return Object.entries(entity4.fields).flatMap(
+    ([field, list]) => (list ?? []).map((assertion) => ({
+      field,
+      assertion
+    }))
+  );
+}
+function researchEntityContextReferences(entity4) {
+  return researchEntityAssertions(entity4).flatMap(({ field, assertion }) => {
+    const value = assertion.content.value;
+    if (field === "eventContext" && value)
+      return [value];
+    return value?.relevantTime?.kind === "context" ? [value.relevantTime.reference] : [];
+  });
+}
+function parseEntityDocument(input, schema, contract) {
+  const parsed = schema.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((i) => ({
+        code: "STRUCT.VALUE",
+        stage: "structural",
+        pointer: "/" + i.path.join("/"),
+        message: i.message
+      }))
+    };
+  const data = parsed.data, issues = [];
+  const problem = (code, pointer6, message) => issues.push({ code, stage: "semantic", pointer: pointer6, message });
+  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."
+    );
+  const unchecked = /* @__PURE__ */ new Set([
+    data.observationRef.sha256,
+    ...data.contextRefs.map((r) => r.sha256)
+  ]);
+  const identities = /* @__PURE__ */ new Set();
+  for (const [i, e] of data.entities.entries()) {
+    const key2 = `${e.kind}:${e.id}`;
+    if (identities.has(key2))
+      problem(
+        "REF.UNIQUE_ID",
+        `/entities/${i}/id`,
+        "Entity identity repeats within its kind."
+      );
+    identities.add(key2);
+  }
+  function time(v, p) {
+    const found = [];
+    checkTime(v, p, found);
+    found.forEach((i) => problem(i.code, i.pointer, i.message));
+  }
+  time(
+    { kind: "instant", value: data.recordedAt},
+    "/recordedAt"
+  );
+  for (const [i, e] of data.entities.entries()) {
+    const ep = `/entities/${i}`, ids = /* @__PURE__ */ new Set();
+    for (const { field, assertion: a } of researchEntityAssertions(e)) {
+      const p = `${ep}/fields/${field}`;
+      if (ids.has(a.id))
+        problem("REF.UNIQUE_ID", p, "Assertion IDs repeat within this entity.");
+      ids.add(a.id);
+      const prov = a.content.provenance;
+      if (prov) {
+        unchecked.add(prov.sourceRef);
+        if (prov.locator?.kind === "time_range" && prov.locator.endSeconds < prov.locator.startSeconds)
+          problem("TIME.INTERVAL", p, "Source locator end precedes its start.");
+      }
+      const value = a.content.value;
+      if (value === void 0) continue;
+      if (field === "recordedTime" || field === "performedAt")
+        time(value, p);
+      const relevant = value.relevantTime;
+      if (relevant?.kind === "calendar") time(relevant.value, p);
+      const targetKind = field === "speakerWitnessIds" || field === "witnessIds" || field === "witnessId" ? "witness" : field === "accountId" ? "account" : void 0;
+      if (targetKind) {
+        const refs2 = Array.isArray(value) ? value : [value];
+        if (new Set(refs2).size !== refs2.length)
+          problem("REF.UNIQUE_ID", p, "Typed local links repeat.");
+        for (const id10 of refs2)
+          if (!identities.has(`${targetKind}:${id10}`))
+            problem("REF.ENTITY", p, "Typed local entity does not exist.");
+      }
+      if (field === "sourceDocument") unchecked.add(value);
+      if (field === "supportRefs") {
+        const refs2 = value;
+        if (new Set(refs2).size !== refs2.length)
+          problem("REF.UNIQUE_ID", p, "Support references repeat.");
+        refs2.forEach((r) => unchecked.add(r));
+      }
+    }
+    for (const ref2 of researchEntityContextReferences(e))
+      if (!snapshots.has(JSON.stringify(ref2.document)))
+        problem(
+          "REF.LOCAL_RESOLUTION",
+          ep,
+          "Context reference must select a declared snapshot."
+        );
+  }
+  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 };
+}
+
+// src/experimental/v2/research-entities.ts
+function parseResearchEntities(input) {
+  return parseEntityDocument(input, ResearchEntitiesSchema, {
+    schemaId: RESEARCH_ENTITIES_SCHEMA_ID,
+    rulesetVersion: "0.1.0"
+  });
+}
+var text7 = z.string().min(1).regex(/\S/, "must contain non-whitespace text");
+var id6 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var claimRef3 = z.string().regex(/^claim:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var inputRef3 = z.string().regex(
+  /^(?:claim|source|product|assertion|measurement):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/
+);
+var ResearchClaimSubjectSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("observation") }),
+  z.strictObject({
+    kind: z.literal("entity"),
+    reference: ResearchEntityReferenceSchema
+  }),
+  z.strictObject({
+    kind: z.literal("context"),
+    reference: ContextReferenceSchema
+  }),
+  z.strictObject({ kind: z.literal("measurement"), measurementId: id6 })
+]);
+var WitnessReviewSchema = z.strictObject({
+  rating: ConfidenceLevelSchema.optional(),
+  factors: z.array(CredibilityFactorSchema).optional().describe(
+    "Reviewer-selected factor labels; no built-in weighting or validation of their truth."
+  ),
+  detractors: z.array(CredibilityDetractorSchema).optional().describe(
+    "Retained vocabulary for attributable reviews. Anonymity never adds a penalty automatically."
+  ),
+  consistentTestimony: z.enum(["consistent", "inconsistent", "unknown"]).optional(),
+  multipleIndependent: z.enum(["independent", "not_independent", "unknown"]).optional(),
+  notes: text7.optional()
+}).describe(
+  "Attributable interpretation, separate from sourced qualifications; requires explicit inputs."
+);
+var common3 = {
+  id: id6,
+  recordedAt: instantString,
+  topic: text7,
+  subject: ResearchClaimSubjectSchema,
+  supersedes: z.array(claimRef3).min(1).optional()
+};
+var ResearchSourceStatementSchema = z.strictObject({
+  ...common3,
+  kind: z.literal("source_assertion"),
+  text: text7,
+  reportedLevel: text7.optional(),
+  provenance: ObservationAssertionSchema.options[0].shape.provenance
+});
+var assessment3 = {
+  ...common3,
+  kind: z.literal("assessment"),
+  inputRefs: z.array(inputRef3),
+  contextInputRefs: z.array(ContextAssertionReferenceSchema).optional(),
+  entityInputRefs: z.array(ResearchEntityAssertionReferenceSchema).optional(),
+  rationale: text7
+};
+var ResearchUnassessedClaimSchema = z.strictObject({
+  ...assessment3,
+  status: z.literal("unassessed")
+});
+var ResearchAssessedClaimSchema = z.strictObject({
+  ...assessment3,
+  status: z.literal("assessed"),
+  outcome: z.enum(["reported", "confirmed", "absent", "inconclusive"]),
+  evaluatedBy: text7,
+  evaluatedAt: instantString,
+  methodRef: z.string().regex(/^method:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/),
+  methodVersion: text7,
+  confidence: z.number().min(0).max(1).optional(),
+  witnessReview: WitnessReviewSchema.optional()
+});
+var ResearchHistoricalClaimSchema = z.union([
+  ResearchSourceStatementSchema,
+  ResearchUnassessedClaimSchema,
+  ResearchAssessedClaimSchema
+]);
+var RESEARCH_CLAIM_HISTORY_SCHEMA_ID = "urn:disclosureos:experimental:claim-history:0.3.0";
+var RESEARCH_CLAIM_HISTORY_RULESET_VERSION = "0.3.0";
+var ResearchClaimHistorySchema = z.strictObject({
+  kind: z.literal("claim_history"),
+  schemaVersion: z.literal("0.3.0"),
+  id: id6,
+  contextRefs: z.array(
+    DocumentSnapshotRefSchema.extend({
+      schemaId: z.literal(OBSERVATION_CONTEXT_SCHEMA_ID)
+    })
+  ),
+  entityRefs: z.array(
+    DocumentSnapshotRefSchema.extend({
+      schemaId: z.literal(RESEARCH_ENTITIES_SCHEMA_ID)
+    })
+  ),
+  observation: ExperimentalObservationSchema,
+  claims: z.array(ResearchHistoricalClaimSchema),
+  extensions: ExperimentalObservationSchema.shape.extensions
+});
+function researchClaimHistoryJsonSchema() {
+  return {
+    ...z.toJSONSchema(ResearchClaimHistorySchema, {
+      target: "draft-2020-12",
+      reused: "ref"
+    }),
+    $id: RESEARCH_CLAIM_HISTORY_SCHEMA_ID
+  };
+}
+
+// src/experimental/v2/entity-claim-history-validation.ts
+var point3 = (value) => ({
+  kind: "instant",
+  value,
+  timeScale: "UTC"
+});
+var pointer5 = (path) => path.map((p) => `/${String(p).replace(/~/g, "~0").replace(/\//g, "~1")}`).join("");
+function parseEntityClaimHistory(input, schema, contract) {
+  const parsed = schema.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: pointer5(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(point3(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 refs2(values4, path, owner) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [i, ref2] of values4.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."
+      );
+  }
+  const entitySnapshots = new Set(
+    data.entityRefs.map((r) => JSON.stringify(r))
+  );
+  if (entitySnapshots.size !== data.entityRefs.length)
+    problem("REF.UNIQUE_ID", "/entityRefs", "Entity snapshots repeat.");
+  for (const [i, claim] of data.claims.entries()) {
+    const refs3 = [
+      ...claim.subject.kind === "entity" ? [claim.subject.reference] : [],
+      ...claim.kind === "assessment" ? claim.entityInputRefs ?? [] : []
+    ];
+    for (const ref2 of refs3)
+      if (!entitySnapshots.has(JSON.stringify(ref2.document)))
+        problem(
+          "REF.LOCAL_RESOLUTION",
+          `/claims/${i}`,
+          "Entity reference must select a declared snapshot."
+        );
+    if (claim.kind === "assessment") {
+      if (new Set((claim.entityInputRefs ?? []).map((r) => JSON.stringify(r))).size !== (claim.entityInputRefs ?? []).length)
+        problem(
+          "REF.UNIQUE_ID",
+          `/claims/${i}/entityInputRefs`,
+          "Entity inputs repeat."
+        );
+      if (claim.status === "assessed" && claim.witnessReview) {
+        if (claim.subject.kind !== "entity" || !["witness", "account", "witness_group", "procedure"].includes(
+          claim.subject.reference.target.kind
+        ))
+          problem(
+            "CLAIM.SUPERSESSION_SCOPE",
+            `/claims/${i}/witnessReview`,
+            "Witness review requires a typed research-entity subject."
+          );
+        if (claim.inputRefs.length + (claim.entityInputRefs?.length ?? 0) + (claim.contextInputRefs?.length ?? 0) + ("editionInputRefs" in claim ? claim.editionInputRefs?.length ?? 0 : 0) === 0)
+          problem(
+            "REF.LOCAL_RESOLUTION",
+            `/claims/${i}/witnessReview`,
+            "Witness review requires explicit inputs."
+          );
+      }
+    }
+  }
+  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) {
+      refs2(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(point3(previous.recordedAt), point3(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 {
+      refs2(claim.inputRefs, `${path}/inputRefs`, owner);
+      if (claim.status === "assessed") {
+        instant(claim.evaluatedAt, `${path}/evaluatedAt`);
+        if (comparePoints(point3(claim.evaluatedAt), point3(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),
+      ...data.entityRefs.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)
+    )
+  };
+}
+
+// src/experimental/v2/research-claim-history.ts
+function parseResearchClaimHistory(input) {
+  return parseEntityClaimHistory(input, ResearchClaimHistorySchema, {
+    kind: "claim_history",
+    schemaId: RESEARCH_CLAIM_HISTORY_SCHEMA_ID,
+    rulesetVersion: RESEARCH_CLAIM_HISTORY_RULESET_VERSION
+  });
+}
+var text8 = z.string().min(1).regex(/\S/);
+var id7 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var sourceRef4 = z.string().regex(/^(source|product):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var provenance4 = SourceProvenanceSchema.extend({ sourceRef: sourceRef4 });
+function values3(schema) {
+  return z.array(
+    z.strictObject({
+      id: id7.describe(
+        "Assertion identity within this entity, independent of array order."
+      ),
+      content: z.union([
+        z.strictObject({
+          state: z.literal("known"),
+          value: schema,
+          provenance: provenance4,
+          originalWording: text8.optional()
+        }),
+        z.strictObject({
+          state: z.literal("approximate"),
+          value: schema,
+          precision: text8,
+          provenance: provenance4,
+          originalWording: text8.optional()
+        }),
+        z.strictObject({
+          state: z.literal("unknown"),
+          reason: z.enum(["not_recorded", "not_collected", "unavailable"])
+        }),
+        z.strictObject({ state: z.literal("redacted"), reason: text8 }),
+        z.strictObject({
+          state: z.literal("unmapped"),
+          originalWording: text8,
+          provenance: provenance4
+        })
+      ])
+    })
+  ).min(1).optional();
+}
+function entity3(kind, fields) {
+  return z.strictObject({
+    kind: z.literal(kind),
+    id: id7,
+    fields: z.strictObject(fields)
+  });
+}
+function target3(kind, fields) {
+  return z.strictObject({
+    kind: z.literal(kind),
+    id: id7,
+    field: z.enum(Object.keys(fields)).optional()
+  });
+}
+var DocumentTypeSchema = z.enum([
+  "foia_release",
+  "official_report",
+  "congressional_record",
+  "military_memo",
+  "intelligence_assessment",
+  "inspector_general",
+  "presidential_directive",
+  "executive_order",
+  "declassified_cable",
+  "investigation_file",
+  "other"
+]).describe("Kind of government/official document.");
+z.object({
+  documentType: DocumentTypeSchema,
+  classificationLevel: z.string().optional().describe('Current classification of the document (e.g. "UNCLASSIFIED", "SECRET//NOFORN").'),
+  originatingAgency: z.string().optional().describe("Agency that produced the document."),
+  controlNumbers: z.array(z.string()).optional().describe("Agency control or tracking numbers stamped on the document."),
+  foiaRequestNumber: z.string().optional().describe("FOIA request number that produced the document."),
+  declassificationDate: z.string().optional().describe("When the document was declassified (ISO date)."),
+  originalClassification: z.string().optional().describe("Classification the document carried when created."),
+  pageCount: z.number().optional().describe("Number of pages in the document."),
+  redactionLevel: z.enum(["none", "partial", "heavy", "unknown"]).optional().describe("How much of the document is redacted.")
+}).meta({ id: "DocumentMetadata" }).describe("Provenance metadata for a source document (classification, agency, redaction).");
+var IdentifierSystemSchema = z.enum([
+  "nuforc",
+  "mufon",
+  "geipan",
+  "cufos",
+  "nicap",
+  "bluebook",
+  "nara",
+  "foia",
+  "aaro",
+  "congress",
+  "doi",
+  "arxiv",
+  "orcid",
+  "pubmed",
+  "isbn",
+  "issn",
+  "youtube",
+  "vimeo",
+  "internet_archive",
+  "wayback",
+  "url",
+  "uri",
+  "custom"
+]).describe("External identifier namespace (reporting centers, archives, academic registries, media hosts).");
+var ExternalIdentifierSchema = z.object({
+  system: IdentifierSystemSchema,
+  systemName: z.string().optional().describe('Display name of the system, required when `system` is "custom".'),
+  value: z.string().describe("The identifier value within the external system (e.g. a case number)."),
+  url: z.string().optional().describe("Direct link to the record in the external system."),
+  verified: z.boolean().optional().describe("Whether the identifier has been confirmed to point at this observation."),
+  verifiedDate: z.string().optional().describe("When the identifier was last verified (ISO date)."),
+  accessible: z.boolean().optional().describe("Whether the external record is currently reachable."),
+  accessCheckedDate: z.string().optional().describe("When accessibility was last checked (ISO date)."),
+  notes: z.string().optional().describe("Free-text context about the cross-reference.")
+}).meta({ id: "ExternalIdentifier" }).describe("A reference to this observation in an external system or archive.");
+z.object({
+  primary: ExternalIdentifierSchema.optional(),
+  identifiers: z.array(ExternalIdentifierSchema)
+}).meta({ id: "CrossReferences" }).describe("External identifiers cross-referencing this observation, with an optional primary.");
+
+// src/experimental/v2/archival-entities-schema.ts
+var text9 = z.string().min(1).regex(/\S/);
+var id8 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var refs = z.array(id8).min(1);
+var url = z.url();
+var ArtifactSnapshotRefSchema = z.strictObject({
+  sourceRef: z.string().regex(/^(source|product):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/),
+  digest: z.strictObject({
+    algorithm: z.literal("sha256"),
+    value: z.string().regex(/^[a-f0-9]{64}(?![\s\S])/)
+  })
+}).describe(
+  "One exact artifact in the scoped observation inventory. A URL, title or legacy hash cannot substitute for this identity."
+);
+var SourceEditionFields = {
+  title: values3(text9),
+  type: values3(SourceTypeSchema),
+  author: values3(text9),
+  organization: values3(text9),
+  issuedAt: values3(EventTimeValueSchema),
+  archiveLocation: values3(text9),
+  primaryDisplay: values3(z.boolean()),
+  originalUrl: values3(url),
+  archiveUrl: values3(url),
+  reference: values3(text9),
+  isPrimarySource: values3(
+    z.strictObject({ value: z.boolean(), context: text9 })
+  ),
+  documentType: values3(DocumentTypeSchema),
+  originatingAgency: values3(text9),
+  controlNumbers: values3(z.array(text9).min(1)),
+  foiaRequestNumber: values3(text9),
+  originalClassification: values3(text9),
+  classificationLevel: values3(text9),
+  pageCount: values3(z.number().int().min(1)),
+  redactionLevel: values3(z.enum(["none", "partial", "heavy", "unknown"])),
+  redactionDescription: values3(text9),
+  redactionPercent: values3(z.number().min(0).max(100)),
+  notes: values3(text9)
+};
+var DocumentEventFields = {
+  eventType: values3(
+    z.enum(["creation", "release", "classification", "declassification"])
+  ),
+  occurredAt: values3(EventTimeValueSchema),
+  authority: values3(text9),
+  reference: values3(text9),
+  marking: values3(text9),
+  notes: values3(text9)
+};
+var declaredHash = z.discriminatedUnion("algorithm", [
+  z.strictObject({
+    algorithm: z.literal("sha256"),
+    value: z.string().regex(/^[a-fA-F0-9]{64}(?![\s\S])/)
+  }),
+  z.strictObject({
+    algorithm: z.literal("sha512"),
+    value: z.string().regex(/^[a-fA-F0-9]{128}(?![\s\S])/)
+  }),
+  z.strictObject({
+    algorithm: z.literal("sha1"),
+    value: z.string().regex(/^[a-fA-F0-9]{40}(?![\s\S])/)
+  }),
+  z.strictObject({
+    algorithm: z.literal("md5"),
+    value: z.string().regex(/^[a-fA-F0-9]{32}(?![\s\S])/)
+  })
+]);
+var DigitalArtifactFields = {
+  declaredHashes: values3(
+    z.array(
+      z.strictObject({
+        hash: declaredHash,
+        appliesTo: z.union([
+          z.strictObject({
+            kind: z.literal("artifact"),
+            reference: ArtifactSnapshotRefSchema
+          }),
+          z.strictObject({
+            kind: z.literal("unavailable_original"),
+            description: text9
+          })
+        ])
+      })
+    ).min(1)
+  ),
+  device: values3(text9),
+  manufacturer: values3(text9),
+  model: values3(text9),
+  software: values3(text9),
+  originalFilename: values3(text9),
+  originalCreationDate: values3(EventTimeValueSchema),
+  gpsCoordinates: values3(
+    z.strictObject({
+      latitude: z.number().min(-90).max(90),
+      longitude: z.number().min(-180).max(180),
+      altitude: z.strictObject({
+        value: z.number(),
+        unit: z.union([text9, z.null()]),
+        datum: text9.optional()
+      }).optional()
+    })
+  ),
+  metadataPreserved: values3(z.boolean()),
+  metadataStripped: values3(z.boolean()),
+  strippedReason: values3(text9),
+  custodyStatus: values3(ChainOfCustodySchema),
+  provenanceChainDescription: values3(z.array(text9).min(1)),
+  derivedFromArtifactIds: values3(refs),
+  lastUpdated: values3(EventTimeValueSchema),
+  notes: values3(text9)
+};
+var DigitalCustodyFields = {
+  action: values3(CustodyActionSchema),
+  occurredAt: values3(EventTimeValueSchema),
+  from: values3(text9),
+  to: values3(text9),
+  location: values3(text9),
+  reference: values3(text9),
+  notes: values3(text9)
+};
+var ExternalIdentifierFields = {
+  value: values3(
+    z.strictObject({
+      system: IdentifierSystemSchema,
+      systemName: text9.optional(),
+      value: text9,
+      url: url.optional(),
+      notes: text9.optional()
+    })
+  ),
+  primaryDisplay: values3(z.boolean()),
+  notes: values3(text9)
+};
+var IdentifierCheckFields = {
+  checkedAt: values3(EventTimeValueSchema),
+  agent: values3(text9),
+  method: values3(text9),
+  methodVersion: values3(text9),
+  outcome: values3(
+    z.discriminatedUnion("kind", [
+      z.strictObject({
+        kind: z.literal("access"),
+        result: z.enum(["accessible", "inaccessible", "unknown"])
+      }),
+      z.strictObject({
+        kind: z.literal("identity"),
+        result: z.enum(["matches", "does_not_match", "unknown"])
+      })
+    ])
+  ),
+  notes: values3(text9)
+};
+for (const fields of [
+  SourceEditionFields,
+  DocumentEventFields,
+  DigitalArtifactFields,
+  DigitalCustodyFields,
+  ExternalIdentifierFields,
+  IdentifierCheckFields
+])
+  for (const [key2, schema] of Object.entries(fields))
+    fields[key2] = schema.describe(
+      `Sourced ${key2.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase()} assertions. Alternatives and missingness are retained; declarations are not independent verification.`
+    );
+var edition = entity3("source_edition", SourceEditionFields).extend({
+  artifact: ArtifactSnapshotRefSchema
+});
+var artifact = entity3("digital_artifact", DigitalArtifactFields).extend({
+  artifact: ArtifactSnapshotRefSchema
+});
+var documentEvent = entity3("document_event", DocumentEventFields).extend({
+  editionId: id8
+});
+var custody = entity3("digital_custody_action", DigitalCustodyFields).extend({
+  artifactId: id8,
+  predecessor: z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("action"), id: id8 }),
+    z.strictObject({ kind: z.literal("start") }),
+    z.strictObject({ kind: z.literal("unknown"), reason: text9 })
+  ]).describe(
+    "Declared preceding action on the same artifact, a declared beginning, or an explicit gap. Array order carries no chronology."
+  )
+});
+var identifier2 = entity3(
+  "external_identifier",
+  ExternalIdentifierFields
+).extend({
+  subject: z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("observation") }),
+    z.strictObject({ kind: z.literal("source_edition"), editionId: id8 })
+  ]).describe(
+    "The scoped observation or one exact source edition. A catalog identifier is not automatically an event identifier."
+  )
+});
+var check = entity3("identifier_check", IdentifierCheckFields).extend({
+  identifierId: id8,
+  identifierAssertionId: id8
+});
+var ArchivalEntitySchema = z.discriminatedUnion("kind", [
+  ...ResearchEntitySchema.options,
+  edition,
+  documentEvent,
+  artifact,
+  custody,
+  identifier2,
+  check
+]);
+var ARCHIVAL_ENTITIES_SCHEMA_ID = "urn:disclosureos:experimental:research-entities:0.2.0";
+var ArchivalEntitiesSchema = ResearchEntitiesSchema.extend({
+  schemaVersion: z.literal("0.2.0"),
+  entities: z.array(ArchivalEntitySchema).min(1)
+}).describe(
+  "Public research declarations including exact source editions and digital artifact custody. No source authentication, public-release permission or complete custody is inferred."
+);
+var ArchivalEntityTargetSchema = z.discriminatedUnion("kind", [
+  ...ResearchEntityTargetSchema.options,
+  target3("source_edition", SourceEditionFields),
+  target3("document_event", DocumentEventFields),
+  target3("digital_artifact", DigitalArtifactFields),
+  target3("digital_custody_action", DigitalCustodyFields),
+  target3("external_identifier", ExternalIdentifierFields),
+  target3("identifier_check", IdentifierCheckFields)
+]);
+var ArchivalEntityReferenceSchema = z.strictObject({
+  document: DocumentSnapshotRefSchema.extend({
+    schemaId: z.literal(ARCHIVAL_ENTITIES_SCHEMA_ID)
+  }),
+  target: ArchivalEntityTargetSchema
+});
+var ArchivalEntityAssertionReferenceSchema = ArchivalEntityReferenceSchema.extend({ assertionId: id8 });
+function archivalEntitiesJsonSchema() {
+  return {
+    ...z.toJSONSchema(ArchivalEntitiesSchema, {
+      target: "draft-2020-12",
+      reused: "ref"
+    }),
+    $id: ARCHIVAL_ENTITIES_SCHEMA_ID
+  };
+}
+
+// src/experimental/v2/archival-entities.ts
+function archivalArtifactReferences(entity4) {
+  const direct = "artifact" in entity4 ? [entity4.artifact] : [];
+  if (entity4.kind !== "digital_artifact") return direct;
+  return [
+    ...direct,
+    ...(entity4.fields.declaredHashes ?? []).flatMap(
+      (a) => "value" in a.content ? a.content.value.flatMap(
+        (d) => d.appliesTo.kind === "artifact" ? [d.appliesTo.reference] : []
+      ) : []
+    )
+  ];
+}
+function parseArchivalEntities(input) {
+  const result = parseEntityDocument(input, ArchivalEntitiesSchema, {
+    schemaId: ARCHIVAL_ENTITIES_SCHEMA_ID,
+    rulesetVersion: "0.2.0"
+  });
+  if (!result.success) return result;
+  const data = result.data, issues = [];
+  const problem = (code, pointer6, message) => issues.push({ code, stage: "semantic", pointer: pointer6, message });
+  const index = new Map(data.entities.map((e) => [`${e.kind}:${e.id}`, e]));
+  const unchecked = new Set(result.uncheckedRefs);
+  const derivation = /* @__PURE__ */ new Map(), custody2 = /* @__PURE__ */ new Map();
+  const known = (entity4, field) => {
+    const a = researchEntityAssertions(entity4).filter((a2) => a2.field === field);
+    return a.length === 1 && a[0].assertion.content.state === "known" ? a[0].assertion.content.value : void 0;
+  };
+  for (const [i, e] of data.entities.entries()) {
+    const p = `/entities/${i}`;
+    const link = (kind, id10, field) => {
+      const target4 = index.get(`${kind}:${id10}`);
+      if (!target4)
+        problem(
+          "REF.ENTITY",
+          `${p}/${field}`,
+          "Typed local archival entity does not exist."
+        );
+      return target4;
+    };
+    for (const ref2 of archivalArtifactReferences(e))
+      unchecked.add(ref2.sourceRef);
+    if (e.kind === "document_event")
+      link("source_edition", e.editionId, "editionId");
+    if (e.kind === "external_identifier" && e.subject.kind === "source_edition")
+      link("source_edition", e.subject.editionId, "subject/editionId");
+    if (e.kind === "identifier_check") {
+      const identifier3 = link(
+        "external_identifier",
+        e.identifierId,
+        "identifierId"
+      );
+      if (identifier3?.kind === "external_identifier" && !identifier3.fields.value?.some((a) => a.id === e.identifierAssertionId))
+        problem(
+          "REF.ASSERTION",
+          `${p}/identifierAssertionId`,
+          "Identifier check must name an existing value assertion in the selected identifier revision."
+        );
+    }
+    for (const { field, assertion } of researchEntityAssertions(e)) {
+      const value = assertion.content.value;
+      if (value === void 0) continue;
+      if ([
+        "issuedAt",
+        "occurredAt",
+        "originalCreationDate",
+        "lastUpdated",
+        "checkedAt"
+      ].includes(field)) {
+        const found = [];
+        checkTime(value, `${p}/fields/${field}`, found);
+        found.forEach((v) => problem(v.code, v.pointer, v.message));
+      }
+      if (e.kind === "external_identifier" && field === "value") {
+        const v = value;
+        if (v.system === "custom" && !v.systemName)
+          problem(
+            "ARCHIVE.IDENTIFIER_SYSTEM",
+            `${p}/fields/value`,
+            "A custom identifier system needs a declared system name."
+          );
+      }
+    }
+    if (e.kind === "digital_artifact") {
+      const parents = (e.fields.derivedFromArtifactIds ?? []).flatMap(
+        (a) => "value" in a.content ? a.content.value : []
+      );
+      for (const a of e.fields.derivedFromArtifactIds ?? [])
+        if ("value" in a.content && new Set(a.content.value).size !== a.content.value.length)
+          problem(
+            "REF.UNIQUE_ID",
+            `${p}/fields/derivedFromArtifactIds`,
+            "Parent artifact links repeat within an assertion."
+          );
+      parents.forEach(
+        (id10) => link("digital_artifact", id10, "fields/derivedFromArtifactIds")
+      );
+      derivation.set(e.id, [...new Set(parents)]);
+    }
+    if (e.kind === "digital_custody_action") {
+      link("digital_artifact", e.artifactId, "artifactId");
+      custody2.set(
+        e.id,
+        e.predecessor.kind === "action" ? [e.predecessor.id] : []
+      );
+      if (e.predecessor.kind === "action") {
+        const previous = link(
+          "digital_custody_action",
+          e.predecessor.id,
+          "predecessor"
+        );
+        if (previous?.kind !== "digital_custody_action") continue;
+        if (previous.artifactId !== e.artifactId)
+          problem(
+            "ARCHIVE.CUSTODY_SCOPE",
+            `${p}/predecessor`,
+            "A custody predecessor must concern the same exact artifact, not a different edition or derived file."
+          );
+        const from = known(e, "from"), to = known(previous, "to");
+        if (typeof from === "string" && typeof to === "string" && from !== to)
+          problem(
+            "ARCHIVE.CUSTODY_HANDOFF",
+            `${p}/fields/from`,
+            "Explicit predecessor recipient and next sender differ. Missing or conflicting parties are not repaired automatically."
+          );
+        const now = known(e, "occurredAt");
+        const before = known(previous, "occurredAt");
+        if (now && before && now.kind !== "interval" && before.kind === now.kind) {
+          if (comparePoints(before, now) > 0)
+            problem(
+              "ARCHIVE.CUSTODY_ORDER",
+              `${p}/fields/occurredAt`,
+              "Declared custody action precedes its explicit predecessor."
+            );
+        }
+      }
+    }
+  }
+  function acyclic(graph, code) {
+    const indegree = new Map([...graph.keys()].map((id10) => [id10, 0]));
+    for (const edges of graph.values())
+      for (const id10 of edges)
+        if (indegree.has(id10)) indegree.set(id10, indegree.get(id10) + 1);
+    const queue = [...indegree].filter(([, n]) => n === 0).map(([id10]) => id10);
+    for (let i = 0; i < queue.length; i++)
+      for (const id10 of graph.get(queue[i]) ?? [])
+        if (indegree.has(id10)) {
+          const count = indegree.get(id10) - 1;
+          indegree.set(id10, count);
+          if (count === 0) queue.push(id10);
+        }
+    if (queue.length !== graph.size)
+      problem(
+        code,
+        "/entities",
+        "Declared archival dependency links must be acyclic."
+      );
+  }
+  acyclic(derivation, "ARCHIVE.DERIVATION_CYCLE");
+  acyclic(custody2, "ARCHIVE.CUSTODY_CYCLE");
+  const validation = {
+    contract: result.contract,
+    issues,
+    uncheckedRefs: [...unchecked],
+    checks: {
+      ...result.checks,
+      semantic: issues.length ? "failed" : "passed"
+    }
+  };
+  return issues.length ? { ...validation, success: false } : { ...validation, success: true, data };
+}
+var HashAlgorithmSchema = z.enum(["sha256", "sha512", "sha1", "md5"]).describe("Cryptographic hash algorithm used to fingerprint a file.");
+var FileHashSchema = z.object({
+  algorithm: HashAlgorithmSchema,
+  value: z.string().describe("Hex-encoded hash digest of the file contents.")
+}).meta({ id: "FileHash" }).describe("A content hash of a file.");
+var VerificationMethodSchema = z.enum([
+  "metadata_analysis",
+  "forensic_analysis",
+  "hash_verification",
+  "chain_of_custody",
+  "source_confirmation",
+  "expert_review",
+  "ai_analysis",
+  "other"
+]).describe("Method used to verify media authenticity.");
+var VerificationResultSchema = z.enum([
+  "authentic",
+  "likely_authentic",
+  "inconclusive",
+  "likely_manipulated",
+  "manipulated",
+  "ai_generated",
+  "deepfake",
+  "composite",
+  "unknown"
+]).describe("Outcome of an authenticity verification.");
+var ThirdPartyVerificationSchema = z.object({
+  verifier: z.string().describe("Name of the person who performed the verification."),
+  organization: z.string().optional().describe("Organization the verifier represents."),
+  credentials: z.string().optional().describe('Verifier\u2019s relevant qualifications (e.g. "certified forensic video analyst").'),
+  date: z.string().describe("When the verification was performed (ISO date)."),
+  method: VerificationMethodSchema,
+  methodDescription: z.string().optional().describe("Fuller description of how the verification was performed."),
+  result: VerificationResultSchema,
+  confidence: z.enum(["high", "medium", "low"]).optional().describe("Verifier\u2019s confidence in their own result."),
+  findings: z.string().optional().describe("Summary of what the verification found."),
+  reportUrl: z.string().optional().describe("Link to the full verification report.")
+}).meta({ id: "ThirdPartyVerification" }).describe("An independent authenticity assessment of media or a document.");
+var CaptureMetadataSchema = z.object({
+  device: z.string().optional().describe('Capture device as recorded in metadata (e.g. "iPhone 14 Pro").'),
+  manufacturer: z.string().optional().describe("Device manufacturer from metadata."),
+  model: z.string().optional().describe("Device model from metadata."),
+  software: z.string().optional().describe("Software that produced or processed the file."),
+  originalFilename: z.string().optional().describe("Filename as originally captured, before any renaming."),
+  originalCreationDate: z.string().optional().describe("Creation timestamp embedded in the file metadata."),
+  gpsCoordinates: z.object({
+    latitude: z.number(),
+    longitude: z.number(),
+    altitude: z.number().optional()
+  }).optional().describe("GPS position embedded in the file metadata."),
+  metadataPreserved: z.boolean().optional().describe("Whether the original metadata survives intact."),
+  metadataStripped: z.boolean().optional().describe("Whether metadata was removed at some point."),
+  strippedReason: z.string().optional().describe('Why metadata was stripped (e.g. "platform re-encoding", "privacy redaction").')
+}).meta({ id: "CaptureMetadata" }).describe("Capture/EXIF-style metadata extracted from a media file.");
+z.object({
+  hash: FileHashSchema.optional(),
+  additionalHashes: z.array(FileHashSchema).optional(),
+  captureMetadata: CaptureMetadataSchema.optional(),
+  verifications: z.array(ThirdPartyVerificationSchema).optional(),
+  provenanceChain: z.array(z.string()).optional().describe('Ordered hops the file took from capture to here (e.g. "witness phone \u2192 NYT \u2192 public release").'),
+  manipulationDetected: z.boolean().optional().describe("Whether any analysis found evidence of manipulation."),
+  manipulationDescription: z.string().optional().describe("What manipulation was found, if any."),
+  authenticityAssessment: VerificationResultSchema.optional(),
+  authenticityConfidence: z.enum(["high", "medium", "low", "unassessed"]).optional().describe("Overall confidence in the authenticity assessment."),
+  lastUpdated: z.string().optional().describe("When this provenance record was last updated (ISO timestamp)."),
+  notes: z.string().optional().describe("Free-text context about the provenance trail.")
+}).meta({ id: "DigitalProvenance" }).describe("Digital authenticity trail for media: hashes, capture metadata, and verifications.");
+
+// src/experimental/v2/archival-claim-history-schema.ts
+var text10 = z.string().min(1).regex(/\S/);
+var id9 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var EditionCitationSchema = z.strictObject({
+  document: DocumentSnapshotRefSchema.extend({
+    schemaId: z.literal(ARCHIVAL_ENTITIES_SCHEMA_ID)
+  }),
+  editionId: id9,
+  artifact: ArtifactSnapshotRefSchema,
+  locator: SourceProvenanceSchema.shape.locator.unwrap()
+}).describe(
+  "A citation bound to an exact edition declaration and artifact digest. Similar titles do not permit edition substitution."
+);
+var ArtifactReviewSchema = z.strictObject({
+  verifier: text10.optional(),
+  organization: text10.optional(),
+  credentials: text10.optional(),
+  reviewedAt: EventTimeValueSchema.optional(),
+  verificationMethod: VerificationMethodSchema.optional(),
+  methodDescription: text10.optional(),
+  result: VerificationResultSchema.optional(),
+  confidence: z.enum(["high", "medium", "low", "unassessed"]).optional(),
+  sourceCredibility: SourceCredibilitySchema.optional(),
+  findings: text10.optional(),
+  reportRef: ArtifactSnapshotRefSchema.shape.sourceRef.optional(),
+  reportUrl: z.url().optional(),
+  manipulationDetected: z.boolean().optional(),
+  manipulationDescription: text10.optional(),
+  notes: text10.optional()
+}).describe(
+  "An attributed authenticity or source-credibility review, not an automatic result of snapshot validation."
+);
+var ArchivalClaimSubjectSchema = z.discriminatedUnion("kind", [
+  ResearchClaimSubjectSchema.options[0],
+  z.strictObject({
+    kind: z.literal("entity"),
+    reference: ArchivalEntityReferenceSchema
+  }),
+  ResearchClaimSubjectSchema.options[2],
+  ResearchClaimSubjectSchema.options[3]
+]);
+var subject = ArchivalClaimSubjectSchema;
+var ArchivalSourceStatementSchema = ResearchSourceStatementSchema.extend({
+  subject,
+  editionCitation: EditionCitationSchema.optional(),
+  reportedArtifactReview: ArtifactReviewSchema.optional()
+});
+var assessment4 = {
+  subject,
+  entityInputRefs: z.array(ArchivalEntityAssertionReferenceSchema).optional(),
+  editionInputRefs: z.array(EditionCitationSchema).optional()
+};
+var ArchivalUnassessedClaimSchema = ResearchUnassessedClaimSchema.extend(assessment4);
+var ArchivalAssessedClaimSchema = ResearchAssessedClaimSchema.extend({
+  ...assessment4,
+  artifactReview: ArtifactReviewSchema.optional()
+});
+var ArchivalHistoricalClaimSchema = z.union([
+  ArchivalSourceStatementSchema,
+  ArchivalUnassessedClaimSchema,
+  ArchivalAssessedClaimSchema
+]);
+var ARCHIVAL_CLAIM_HISTORY_SCHEMA_ID = "urn:disclosureos:experimental:claim-history:0.4.0";
+var ArchivalClaimHistorySchema = ResearchClaimHistorySchema.extend({
+  schemaVersion: z.literal("0.4.0"),
+  claims: z.array(ArchivalHistoricalClaimSchema),
+  entityRefs: z.array(
+    DocumentSnapshotRefSchema.extend({
+      schemaId: z.literal(ARCHIVAL_ENTITIES_SCHEMA_ID)
+    })
+  )
+});
+function archivalClaimHistoryJsonSchema() {
+  return {
+    ...z.toJSONSchema(ArchivalClaimHistorySchema, {
+      target: "draft-2020-12",
+      reused: "ref"
+    }),
+    $id: ARCHIVAL_CLAIM_HISTORY_SCHEMA_ID
+  };
+}
+
+// src/experimental/v2/archival-claim-history.ts
+function parseArchivalClaimHistory(input) {
+  const result = parseEntityClaimHistory(input, ArchivalClaimHistorySchema, {
+    kind: "claim_history",
+    schemaId: ARCHIVAL_CLAIM_HISTORY_SCHEMA_ID,
+    rulesetVersion: "0.4.0"
+  });
+  if (!result.success) return result;
+  const data = result.data, issues = [];
+  const problem = (code, pointer6, message) => issues.push({ code, stage: "semantic", pointer: pointer6, message });
+  const snapshots = new Set(data.entityRefs.map((r) => JSON.stringify(r)));
+  const sources = new Map([
+    ...data.observation.sources.map((s) => [`source:${s.id}`, s]),
+    ...data.observation.products.map((s) => [`product:${s.id}`, s])
+  ]);
+  for (const [i, claim] of data.claims.entries()) {
+    const p = `/claims/${i}`;
+    const citations = claim.kind === "source_assertion" ? claim.editionCitation ? [claim.editionCitation] : [] : claim.editionInputRefs ?? [];
+    if (new Set(citations.map((c) => JSON.stringify(c))).size !== citations.length)
+      problem("REF.UNIQUE_ID", p, "Edition citations repeat.");
+    for (const citation of citations) {
+      if (!snapshots.has(JSON.stringify(citation.document)))
+        problem(
+          "REF.LOCAL_RESOLUTION",
+          p,
+          "Edition citation must select a declared entity snapshot."
+        );
+      const source = sources.get(citation.artifact.sourceRef);
+      if (!source?.digest || source.digest.value !== citation.artifact.digest.value)
+        problem(
+          "ARCHIVE.ARTIFACT_IDENTITY",
+          p,
+          "Edition citation must match an inventory artifact's SHA-256 declaration."
+        );
+      if (citation.locator.kind === "time_range" && citation.locator.endSeconds < citation.locator.startSeconds)
+        problem("TIME.INTERVAL", p, "Edition locator end precedes its start.");
+      if (claim.kind === "source_assertion" && (claim.provenance.sourceRef !== citation.artifact.sourceRef || claim.provenance.sourceDigest && claim.provenance.sourceDigest.value !== citation.artifact.digest.value || JSON.stringify(claim.provenance.locator) !== JSON.stringify(citation.locator)))
+        problem(
+          "ARCHIVE.CITATION_SCOPE",
+          p,
+          "A source statement's provenance and edition citation must name the same artifact and locator."
+        );
+    }
+    const review = claim.kind === "source_assertion" ? claim.reportedArtifactReview : claim.status === "assessed" ? claim.artifactReview : void 0;
+    if (!review) continue;
+    if (claim.subject.kind !== "entity" || !["source_edition", "digital_artifact"].includes(
+      claim.subject.reference.target.kind
+    ))
+      problem(
+        "ARCHIVE.REVIEW_SUBJECT",
+        p,
+        "Artifact review requires an exact source-edition or digital-artifact subject."
+      );
+    if (claim.kind === "assessment" && claim.inputRefs.length + (claim.entityInputRefs?.length ?? 0) + (claim.contextInputRefs?.length ?? 0) + citations.length === 0)
+      problem(
+        "REF.LOCAL_RESOLUTION",
+        p,
+        "Artifact review requires explicit inputs."
+      );
+    if (review.reportRef && !sources.has(review.reportRef))
+      problem(
+        "REF.LOCAL_RESOLUTION",
+        p,
+        "Review report is absent from the observation inventory."
+      );
+    if (review.reviewedAt) {
+      const found = [];
+      checkTime(review.reviewedAt, `${p}/artifactReview/reviewedAt`, found);
+      found.forEach((v) => problem(v.code, v.pointer, v.message));
+    }
+  }
+  const validation = {
+    contract: result.contract,
+    issues,
+    uncheckedRefs: result.uncheckedRefs,
+    checks: {
+      ...result.checks,
+      semantic: issues.length ? "failed" : "passed"
+    }
+  };
+  return issues.length ? { ...validation, success: false } : {
+    ...validation,
+    success: true,
+    data,
+    currentClaimRefs: result.currentClaimRefs
+  };
+}
 
-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 };
+export { ARCHIVAL_CLAIM_HISTORY_SCHEMA_ID, ARCHIVAL_ENTITIES_SCHEMA_ID, ArchivalAssessedClaimSchema, ArchivalClaimHistorySchema, ArchivalClaimSubjectSchema, ArchivalEntitiesSchema, ArchivalEntityAssertionReferenceSchema, ArchivalEntityReferenceSchema, ArchivalEntitySchema, ArchivalEntityTargetSchema, ArchivalHistoricalClaimSchema, ArchivalSourceStatementSchema, ArchivalUnassessedClaimSchema, ArtifactReviewSchema, ArtifactSnapshotRefSchema, 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, DigitalArtifactFields, DigitalCustodyFields, DocumentEventFields, DocumentSnapshotRefSchema, EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID, EXPERIMENTAL_OBSERVATION_SCHEMA_ID, EditionCitationSchema, EventTimeIntervalSchema, EventTimePointSchema, EventTimeSchema, EventTimeValueSchema, ExperimentalClaimHistorySchema, ExperimentalObservationSchema, ExternalIdentifierFields, FramedPositionSchema, HistoricalClaimSchema, IdentifierCheckFields, MeasuredQuantitySchema, OBSERVATION_CONTEXT_SCHEMA_ID, ObservationAssertionSchema, ObservationContextSchema, ObservationMeasurementSchema, ObservationMethodSchema, ObservationPositionSchema, ObservationProductSchema, ObservationSnapshotRefSchema, ObservationSourceSchema, ObservationTimeSchema, PRIMITIVES_SCHEMA_ID, PositionSchema, PositionValueSchema, PrimitiveRecordSchema, ProcessingActivitySchema, QuantitativeUncertaintySchema, RESEARCH_CLAIM_HISTORY_RULESET_VERSION, RESEARCH_CLAIM_HISTORY_SCHEMA_ID, RESEARCH_ENTITIES_SCHEMA_ID, ReferenceFrameSchema, ResearchAccountFields, ResearchAssessedClaimSchema, ResearchClaimHistorySchema, ResearchClaimSubjectSchema, ResearchEntitiesSchema, ResearchEntityAssertionReferenceSchema, ResearchEntityReferenceSchema, ResearchEntitySchema, ResearchEntityTargetSchema, ResearchHistoricalClaimSchema, ResearchProcedureFields, ResearchSourceStatementSchema, ResearchUnassessedClaimSchema, ResearchWitnessFields, ResearchWitnessGroupFields, SourceEditionFields, SourceProvenanceSchema, SourceStatementSchema, UnassessedClaimSchema, ValueAssertionSchema, ValueSelectionSchema, WitnessReviewSchema, archivalArtifactReferences, archivalClaimHistoryJsonSchema, archivalEntitiesJsonSchema, compareUtcInstants, contextAssertions, contextClaimHistoryJsonSchema, experimentalClaimHistoryJsonSchema, experimentalObservationJsonSchema, observationContextJsonSchema, parseArchivalClaimHistory, parseArchivalEntities, parseContextClaimHistory, parseExperimentalClaimHistory, parseExperimentalObservation, parseObservationContext, parsePrimitiveRecord, parseResearchClaimHistory, parseResearchEntities, primitivesJsonSchema, researchClaimHistoryJsonSchema, researchEntitiesJsonSchema, researchEntityAssertions, researchEntityContextReferences };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map