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

package/dist/experimental/v2/index.js

@@ -126,9 +126,9 @@ function parsePrimitiveRecord(input) {
         unchecked.add(ref2);
         continue;
       }
-      const target3 = assertions.get(ref2.slice("assertion:".length));
-      if (!target3) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Local assertion does not exist." });
-      else if (target3.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 target3 = assertions.get(ref2.slice("assertion:".length));
-      if (!target3) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion does not exist." });
-      else if (target3.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 target3 = assertions.get(key(value.assertionRef));
-    if (target3 && !matchesField(value.assertionRef, field, measurementId)) problem("REF.FIELD_MISMATCH", `${selectionPath}/assertionRef`, "Selected assertion concerns a different field or measurement.");
-    else if (target3 && JSON.stringify(target3.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((id7) => `source:${id7}`).concat(
-    [...products.keys()].map((id7) => `product:${id7}`),
-    [...methods.keys()].map((id7) => `method:${id7}`),
-    [...frames.keys()].map((id7) => `frame:${id7}`)
+  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(values3, path, owner) {
+  function refs2(values4, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of values3.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(entity3) {
-  return Object.entries(entity3.fields).flatMap(
+function contextAssertions(entity4) {
+  return Object.entries(entity4.fields).flatMap(
     ([field, assertions]) => (assertions ?? []).map((assertion) => ({
       field,
       assertion
@@ -1475,12 +1475,12 @@ function parseObservationContext(input) {
   const data = parsed.data;
   const entities = /* @__PURE__ */ new Map();
   const relativeGraph = /* @__PURE__ */ new Map();
-  for (const [i, entity3] of data.entities.entries()) {
-    const key2 = `${entity3.kind}:${entity3.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, entity3);
-    if (entity3.kind === "temporal") relativeGraph.set(entity3.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, entity3] of data.entities.entries()) {
+  for (const [i, entity4] of data.entities.entries()) {
     const path = `/entities/${i}`;
-    const assertions = contextAssertions(entity3);
+    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 id7 of content.value)
-          if (!entities.has(`place:${id7}`))
+        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(entity3.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 entity3.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 id7 of selection.consideredAssertionIds)
+      for (const id10 of selection.consideredAssertionIds)
         if (!assertions.some(
-          (a) => a.field === selection.field && a.assertion.id === id7
+          (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 entity3.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(values3, path, owner) {
+  function refs2(values4, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of values3.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)
@@ -2382,29 +2382,25 @@ function researchEntitiesJsonSchema() {
   };
 }
 
-// src/experimental/v2/research-entities.ts
-function researchEntityAssertions(entity3) {
-  return Object.entries(entity3.fields).flatMap(
+// 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(entity3) {
-  return researchEntityAssertions(entity3).flatMap(({ 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 parseResearchEntities(input) {
-  const parsed = ResearchEntitiesSchema.safeParse(input);
-  const contract = {
-    schemaId: RESEARCH_ENTITIES_SCHEMA_ID,
-    rulesetVersion: "0.1.0"
-  };
+function parseEntityDocument(input, schema, contract) {
+  const parsed = schema.safeParse(input);
   if (!parsed.success)
     return {
       success: false,
@@ -2477,19 +2473,19 @@ function parseResearchEntities(input) {
       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 refs = Array.isArray(value) ? value : [value];
-        if (new Set(refs).size !== refs.length)
+        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 id7 of refs)
-          if (!identities.has(`${targetKind}:${id7}`))
+        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 refs = value;
-        if (new Set(refs).size !== refs.length)
+        const refs2 = value;
+        if (new Set(refs2).size !== refs2.length)
           problem("REF.UNIQUE_ID", p, "Support references repeat.");
-        refs.forEach((r) => unchecked.add(r));
+        refs2.forEach((r) => unchecked.add(r));
       }
     }
     for (const ref2 of researchEntityContextReferences(e))
@@ -2513,6 +2509,14 @@ function parseResearchEntities(input) {
   };
   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])/);
@@ -2617,20 +2621,15 @@ function researchClaimHistoryJsonSchema() {
   };
 }
 
-// src/experimental/v2/research-claim-history.ts
+// 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 parseResearchClaimHistory(input) {
-  const contract = {
-    kind: "claim_history",
-    schemaId: RESEARCH_CLAIM_HISTORY_SCHEMA_ID,
-    rulesetVersion: RESEARCH_CLAIM_HISTORY_RULESET_VERSION
-  };
-  const parsed = ResearchClaimHistorySchema.safeParse(input);
+function parseEntityClaimHistory(input, schema, contract) {
+  const parsed = schema.safeParse(input);
   if (!parsed.success)
     return {
       success: false,
@@ -2712,9 +2711,9 @@ function parseResearchClaimHistory(input) {
       );
     else if (owner && claims.has(ref2)) graph.get(owner)?.add(ref2);
   }
-  function refs(values3, path, owner) {
+  function refs2(values4, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of values3.entries()) {
+    for (const [i, ref2] of values4.entries()) {
       if (seen.has(ref2))
         problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
       seen.add(ref2);
@@ -2753,11 +2752,11 @@ function parseResearchClaimHistory(input) {
   if (entitySnapshots.size !== data.entityRefs.length)
     problem("REF.UNIQUE_ID", "/entityRefs", "Entity snapshots repeat.");
   for (const [i, claim] of data.claims.entries()) {
-    const refs2 = [
+    const refs3 = [
       ...claim.subject.kind === "entity" ? [claim.subject.reference] : [],
       ...claim.kind === "assessment" ? claim.entityInputRefs ?? [] : []
     ];
-    for (const ref2 of refs2)
+    for (const ref2 of refs3)
       if (!entitySnapshots.has(JSON.stringify(ref2.document)))
         problem(
           "REF.LOCAL_RESOLUTION",
@@ -2780,7 +2779,7 @@ function parseResearchClaimHistory(input) {
             `/claims/${i}/witnessReview`,
             "Witness review requires a typed research-entity subject."
           );
-        if (claim.inputRefs.length + (claim.entityInputRefs?.length ?? 0) + (claim.contextInputRefs?.length ?? 0) === 0)
+        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`,
@@ -2799,7 +2798,7 @@ function parseResearchClaimHistory(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;
@@ -2845,7 +2844,7 @@ function parseResearchClaimHistory(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(point3(claim.evaluatedAt), point3(claim.recordedAt)) > 0)
@@ -2915,6 +2914,781 @@ function parseResearchClaimHistory(input) {
   };
 }
 
-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, 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, SourceProvenanceSchema, SourceStatementSchema, UnassessedClaimSchema, ValueAssertionSchema, ValueSelectionSchema, WitnessReviewSchema, compareUtcInstants, contextAssertions, contextClaimHistoryJsonSchema, experimentalClaimHistoryJsonSchema, experimentalObservationJsonSchema, observationContextJsonSchema, parseContextClaimHistory, parseExperimentalClaimHistory, parseExperimentalObservation, parseObservationContext, parsePrimitiveRecord, parseResearchClaimHistory, parseResearchEntities, primitivesJsonSchema, researchClaimHistoryJsonSchema, researchEntitiesJsonSchema, researchEntityAssertions, researchEntityContextReferences };
+// 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 { 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