@actuarial-ts/data 0.7.1 → 0.8.1

package/src/historyMapping.ts

@@ -0,0 +1,514 @@
+import {
+  DiagnosticValidationError,
+  diagnosticJsonPreflight,
+  isDiagnosticToken,
+  isRealIsoDate,
+  snapshotDiagnosticJson,
+  type HistoricalObservationRecord,
+  type HistoricalScalar,
+} from "@actuarial-ts/core";
+import { z } from "zod";
+
+export interface HistoricalColumnSelector {
+  readonly columns: readonly string[];
+}
+
+export interface HistoricalDateSelector extends HistoricalColumnSelector {
+  readonly format: "iso-yyyy-mm-dd" | "mdy-slash" | "dmy-slash";
+}
+
+export interface HistoricalNumberSelector extends HistoricalColumnSelector {
+  readonly decimalSeparator: "." | ",";
+  readonly thousandsSeparator: "," | "." | " " | null;
+  readonly negative: "leading-minus" | "parentheses-or-leading-minus";
+  readonly blank: "null" | "error";
+  readonly scale: number;
+}
+
+export interface HistoricalDimensionSelector extends HistoricalColumnSelector {
+  readonly type: "string" | "number" | "boolean" | "date";
+  readonly dateFormat?: HistoricalDateSelector["format"];
+  readonly numberFormat?: Omit<HistoricalNumberSelector, "columns">;
+  readonly multipleDelimiter?: string;
+}
+
+export interface HistoricalSourceMapping {
+  readonly id: string;
+  readonly version: string;
+  readonly sourceNamespace: string;
+  readonly artifactId: string;
+  readonly grain: HistoricalObservationRecord["grain"];
+  readonly completeness: HistoricalObservationRecord["completeness"];
+  readonly fields: {
+    readonly recordId: HistoricalColumnSelector;
+    readonly claimId: HistoricalColumnSelector;
+    readonly componentId?: HistoricalColumnSelector;
+    readonly accidentDate?: HistoricalDateSelector;
+    readonly reportDate?: HistoricalDateSelector;
+    readonly evaluationDate?: HistoricalDateSelector;
+    readonly effectiveDate?: HistoricalDateSelector;
+    readonly status?: HistoricalColumnSelector;
+  };
+  readonly measures: Readonly<Record<string, HistoricalNumberSelector>>;
+  readonly dimensions?: Readonly<Record<string, HistoricalDimensionSelector>>;
+  readonly relationships?: {
+    readonly claimantIds?: HistoricalColumnSelector & { readonly delimiter: string };
+    readonly occurrenceId?: HistoricalColumnSelector;
+    readonly policyIds?: HistoricalColumnSelector & { readonly delimiter: string };
+    readonly coverageIds?: HistoricalColumnSelector & { readonly delimiter: string };
+  };
+  readonly revision: {
+    readonly id: HistoricalColumnSelector;
+    readonly action?: HistoricalColumnSelector;
+    readonly sequence?: HistoricalNumberSelector;
+    readonly correctedAt?: HistoricalColumnSelector;
+  };
+  readonly preserveUnmappedAttributes: boolean;
+}
+
+export interface HistoricalSourceRow {
+  readonly rowNumber: number;
+  readonly values: Readonly<Record<string, HistoricalScalar>>;
+}
+
+export interface HistoricalMappedRowRejection {
+  readonly rowNumber: number;
+  readonly source: { readonly artifactId: string; readonly sourceRow: number };
+  readonly issues: readonly { readonly path: string; readonly message: string }[];
+}
+
+export interface HistoricalMappingResult {
+  readonly mappingId: string;
+  readonly mappingVersion: string;
+  readonly sourceNamespace: string;
+  readonly artifactId: string;
+  readonly records: readonly HistoricalObservationRecord[];
+  readonly rejected: readonly HistoricalMappedRowRejection[];
+  readonly attributeCatalog: readonly {
+    readonly id: string;
+    readonly sourceColumn: string;
+    readonly observedTypes: readonly ("string" | "number" | "boolean" | "null")[];
+  }[];
+  readonly reconciliation: {
+    readonly inputRows: number;
+    readonly acceptedRows: number;
+    readonly rejectedRows: number;
+  };
+}
+
+const token = z.string().refine(isDiagnosticToken, "Expected a valid nonempty token");
+const columnSelector = z.object({ columns: z.array(token).min(1) }).strict();
+const dateSelector = columnSelector.extend({
+  format: z.enum(["iso-yyyy-mm-dd", "mdy-slash", "dmy-slash"]),
+}).strict();
+const numberFormat = {
+  decimalSeparator: z.enum([".", ","]),
+  thousandsSeparator: z.enum([",", ".", " "]).nullable(),
+  negative: z.enum(["leading-minus", "parentheses-or-leading-minus"]),
+  blank: z.enum(["null", "error"]),
+  scale: z.number().finite().positive(),
+};
+const numberSelector = columnSelector.extend(numberFormat).strict().superRefine((value, context) => {
+  if (value.thousandsSeparator === value.decimalSeparator)
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["thousandsSeparator"],
+      message: "Thousands and decimal separators must differ",
+    });
+});
+const dimensionSelector = columnSelector
+  .extend({
+    type: z.enum(["string", "number", "boolean", "date"]),
+    dateFormat: z.enum(["iso-yyyy-mm-dd", "mdy-slash", "dmy-slash"]).optional(),
+    numberFormat: z.object(numberFormat).strict().optional(),
+    multipleDelimiter: z.string().min(1).optional(),
+  })
+  .strict()
+  .superRefine((value, context) => {
+    if (value.type === "date" && value.dateFormat === undefined)
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["dateFormat"], message: "Date dimension requires dateFormat" });
+    if (value.type === "number" && value.numberFormat === undefined)
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["numberFormat"], message: "Number dimension requires numberFormat" });
+    if (value.multipleDelimiter !== undefined && value.type !== "string")
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["multipleDelimiter"],
+        message: "Only string dimensions support multipleDelimiter",
+      });
+  });
+const multiSelector = columnSelector.extend({ delimiter: z.string().min(1) }).strict();
+
+export const historicalSourceMappingSchema = z
+  .object({
+    id: token,
+    version: token,
+    sourceNamespace: token,
+    artifactId: token,
+    grain: z.enum(["claim-snapshot", "claim-component-snapshot", "transaction"]),
+    completeness: z.enum(["complete-snapshot", "partial-snapshot", "change-only"]),
+    fields: z
+      .object({
+        recordId: columnSelector,
+        claimId: columnSelector,
+        componentId: columnSelector.optional(),
+        accidentDate: dateSelector.optional(),
+        reportDate: dateSelector.optional(),
+        evaluationDate: dateSelector.optional(),
+        effectiveDate: dateSelector.optional(),
+        status: columnSelector.optional(),
+      })
+      .strict(),
+    measures: z.record(token, numberSelector),
+    dimensions: z.record(token, dimensionSelector).optional(),
+    relationships: z
+      .object({
+        claimantIds: multiSelector.optional(),
+        occurrenceId: columnSelector.optional(),
+        policyIds: multiSelector.optional(),
+        coverageIds: multiSelector.optional(),
+      })
+      .strict()
+      .optional(),
+    revision: z
+      .object({
+        id: columnSelector,
+        action: columnSelector.optional(),
+        sequence: numberSelector.optional(),
+        correctedAt: columnSelector.optional(),
+      })
+      .strict(),
+    preserveUnmappedAttributes: z.boolean(),
+  })
+  .strict()
+  .superRefine((mapping, context) => {
+    if (mapping.grain === "claim-component-snapshot" && mapping.fields.componentId === undefined)
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["fields", "componentId"], message: "Component grain requires componentId mapping" });
+    if (mapping.grain === "transaction" && mapping.fields.effectiveDate === undefined)
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["fields", "effectiveDate"], message: "Transaction grain requires effectiveDate mapping" });
+    if (mapping.grain !== "transaction" && mapping.fields.evaluationDate === undefined)
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["fields", "evaluationDate"], message: "Snapshot grain requires evaluationDate mapping" });
+    if (mapping.grain === "transaction" && mapping.completeness !== "change-only")
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["completeness"], message: "Transaction grain requires change-only completeness" });
+    if (Object.keys(mapping.measures).length === 0)
+      context.addIssue({ code: z.ZodIssueCode.custom, path: ["measures"], message: "At least one measure mapping is required" });
+  });
+
+function mappingError(error: z.ZodError): DiagnosticValidationError {
+  return new DiagnosticValidationError(
+    error.issues.map((issue) => ({
+      domain: "configuration" as const,
+      code: issue.code === z.ZodIssueCode.unrecognized_keys ? ("unknown-key" as const) : ("invalid-configuration" as const),
+      path: `$${issue.path.map((part) => (typeof part === "number" ? `[${part}]` : `.${part}`)).join("")}`,
+      message: issue.message,
+    })),
+  );
+}
+
+export function parseHistoricalSourceMapping(value: unknown): HistoricalSourceMapping {
+  const parsed = historicalSourceMappingSchema.safeParse(value);
+  if (!parsed.success) throw mappingError(parsed.error);
+  return snapshotDiagnosticJson(parsed.data) as HistoricalSourceMapping;
+}
+
+function scalarText(value: HistoricalScalar): string {
+  return value === null ? "" : typeof value === "string" ? value.trim() : String(value);
+}
+
+function selectedValue(
+  row: HistoricalSourceRow,
+  selector: HistoricalColumnSelector,
+  path: string,
+  issues: { path: string; message: string }[],
+  required = true,
+): HistoricalScalar | undefined {
+  const selected = selector.columns
+    .filter((column) => Object.hasOwn(row.values, column))
+    .map((column) => ({ column, value: row.values[column]! }))
+    .filter(({ value }) => scalarText(value) !== "");
+  if (selected.length === 0) {
+    if (required) issues.push({ path, message: `No value found in columns ${selector.columns.join(", ")}` });
+    return undefined;
+  }
+  if (new Set(selected.map(({ value }) => scalarText(value))).size > 1) {
+    issues.push({ path, message: `Alias columns disagree: ${selected.map(({ column }) => column).join(", ")}` });
+    return undefined;
+  }
+  return selected[0]!.value;
+}
+
+function parseDateValue(
+  value: HistoricalScalar | undefined,
+  format: HistoricalDateSelector["format"],
+  path: string,
+  issues: { path: string; message: string }[],
+): string | undefined {
+  if (value === undefined) return undefined;
+  const text = scalarText(value);
+  let result = text;
+  const match = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/.exec(text);
+  if (format !== "iso-yyyy-mm-dd") {
+    if (!match) {
+      issues.push({ path, message: `Expected ${format} date` });
+      return undefined;
+    }
+    const month = format === "mdy-slash" ? match[1]! : match[2]!;
+    const day = format === "mdy-slash" ? match[2]! : match[1]!;
+    result = `${match[3]}-${month.padStart(2, "0")}-${day.padStart(2, "0")}`;
+  }
+  if (!isRealIsoDate(result)) {
+    issues.push({ path, message: `Expected a real date; got ${text}` });
+    return undefined;
+  }
+  return result;
+}
+
+function parseNumberValue(
+  value: HistoricalScalar | undefined,
+  selector: Omit<HistoricalNumberSelector, "columns">,
+  path: string,
+  issues: { path: string; message: string }[],
+): number | null | undefined {
+  if (value === undefined || scalarText(value) === "") {
+    if (selector.blank === "error") issues.push({ path, message: "Blank numeric value is not allowed" });
+    return selector.blank === "null" ? null : undefined;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      issues.push({ path, message: "Numeric value is not finite" });
+      return undefined;
+    }
+    const result = value * selector.scale;
+    if (!Number.isFinite(result)) {
+      issues.push({ path, message: "Scaled numeric value is not finite" });
+      return undefined;
+    }
+    return Object.is(result, -0) ? 0 : result;
+  }
+  let text = scalarText(value);
+  let negative = false;
+  if (/^\(.*\)$/.test(text)) {
+    if (selector.negative !== "parentheses-or-leading-minus") {
+      issues.push({ path, message: "Parenthesized negative is not allowed" });
+      return undefined;
+    }
+    negative = true;
+    text = text.slice(1, -1);
+  }
+  if (selector.thousandsSeparator !== null)
+    text = text.split(selector.thousandsSeparator).join("");
+  if (selector.decimalSeparator === ",") text = text.replace(",", ".");
+  if (!/^-?\d+(?:\.\d+)?$/.test(text)) {
+    issues.push({ path, message: `Invalid number ${scalarText(value)} for declared format` });
+    return undefined;
+  }
+  const result = Number(text) * selector.scale * (negative ? -1 : 1);
+  if (!Number.isFinite(result)) {
+    issues.push({ path, message: "Numeric value is not finite" });
+    return undefined;
+  }
+  return Object.is(result, -0) ? 0 : result;
+}
+
+function splitIds(value: HistoricalScalar | undefined, delimiter: string): string[] | undefined {
+  if (value === undefined) return undefined;
+  const values = scalarText(value).split(delimiter).map((item) => item.trim()).filter(Boolean);
+  return values.length === 0 ? undefined : [...new Set(values)];
+}
+
+function selectorColumns(mapping: HistoricalSourceMapping): Set<string> {
+  const result = new Set<string>();
+  const add = (selector: HistoricalColumnSelector | undefined) => selector?.columns.forEach((column) => result.add(column));
+  Object.values(mapping.fields).forEach(add);
+  Object.values(mapping.measures).forEach(add);
+  Object.values(mapping.dimensions ?? {}).forEach(add);
+  Object.values(mapping.relationships ?? {}).forEach(add);
+  Object.values(mapping.revision).forEach(add);
+  return result;
+}
+
+export function mapHistoricalSourceRows(
+  mappingInput: HistoricalSourceMapping | unknown,
+  rowsInput: readonly HistoricalSourceRow[],
+): HistoricalMappingResult {
+  const mapping = parseHistoricalSourceMapping(mappingInput);
+  const records: HistoricalObservationRecord[] = [];
+  const rejected: HistoricalMappedRowRejection[] = [];
+  const usedColumns = selectorColumns(mapping);
+  const attributeTypes = new Map<string, Set<"string" | "number" | "boolean" | "null">>();
+  for (let rowIndex = 0; rowIndex < rowsInput.length; rowIndex += 1) {
+    const raw = rowsInput[rowIndex]!;
+    const preflight = diagnosticJsonPreflight(raw, "input");
+    if (preflight.length > 0) {
+      const candidate = (raw as { readonly rowNumber?: unknown }).rowNumber;
+      const rowNumber = typeof candidate === "number" && Number.isSafeInteger(candidate) && candidate > 0 ? candidate : rowIndex + 1;
+      rejected.push({
+        rowNumber,
+        source: { artifactId: mapping.artifactId, sourceRow: rowNumber },
+        issues: preflight.map((issue) => ({ path: issue.path, message: issue.message })),
+      });
+      continue;
+    }
+    const row = snapshotDiagnosticJson(raw);
+    const issues: { path: string; message: string }[] = [];
+    const pendingAttributeTypes = new Map<string, Set<"string" | "number" | "boolean" | "null">>();
+    if (!Number.isSafeInteger(row.rowNumber) || row.rowNumber < 1)
+      issues.push({ path: "$.rowNumber", message: "rowNumber must be a positive safe integer" });
+    const field = (selector: HistoricalColumnSelector | undefined, name: string, required = false) =>
+      selector === undefined ? undefined : selectedValue(row, selector, `$.${name}`, issues, required);
+    const recordId = scalarText(field(mapping.fields.recordId, "recordId", true) ?? "");
+    const claimId = scalarText(field(mapping.fields.claimId, "claimId", true) ?? "");
+    const componentIdValue = field(mapping.fields.componentId, "componentId", mapping.grain === "claim-component-snapshot");
+    const statusValue = field(mapping.fields.status, "status");
+    const mappedDate = (selector: HistoricalDateSelector | undefined, name: string, required = false) => {
+      if (selector === undefined) return undefined;
+      return parseDateValue(field(selector, name, required), selector.format, `$.${name}`, issues);
+    };
+    const accidentDate = mappedDate(mapping.fields.accidentDate, "accidentDate");
+    const reportDate = mappedDate(mapping.fields.reportDate, "reportDate");
+    const evaluationDate = mappedDate(
+      mapping.fields.evaluationDate,
+      "evaluationDate",
+      mapping.grain !== "transaction",
+    );
+    const effectiveDate = mappedDate(
+      mapping.fields.effectiveDate,
+      "effectiveDate",
+      mapping.grain === "transaction",
+    );
+    const measures: Record<string, number | null> = Object.create(null);
+    for (const [id, selector] of Object.entries(mapping.measures)) {
+      const value = selectedValue(row, selector, `$.measures.${id}`, issues, selector.blank === "error");
+      const amount = parseNumberValue(value, selector, `$.measures.${id}`, issues);
+      if (amount !== undefined) measures[id] = amount;
+    }
+    const dimensions: Record<string, HistoricalScalar | readonly HistoricalScalar[]> = Object.create(null);
+    for (const [id, selector] of Object.entries(mapping.dimensions ?? {})) {
+      const value = selectedValue(row, selector, `$.dimensions.${id}`, issues, false);
+      if (value === undefined) continue;
+      if (selector.multipleDelimiter !== undefined) {
+        dimensions[id] = splitIds(value, selector.multipleDelimiter) ?? [];
+      } else if (selector.type === "date") {
+        const parsed = parseDateValue(value, selector.dateFormat!, `$.dimensions.${id}`, issues);
+        if (parsed !== undefined) dimensions[id] = parsed;
+      } else if (selector.type === "number") {
+        const parsed = parseNumberValue(value, selector.numberFormat!, `$.dimensions.${id}`, issues);
+        if (parsed !== undefined) dimensions[id] = parsed;
+      } else if (selector.type === "boolean") {
+        const text = scalarText(value).toLowerCase();
+        if (text === "true" || text === "1") dimensions[id] = true;
+        else if (text === "false" || text === "0") dimensions[id] = false;
+        else issues.push({ path: `$.dimensions.${id}`, message: "Expected boolean true/false/1/0" });
+      } else dimensions[id] = scalarText(value);
+    }
+    if (mapping.preserveUnmappedAttributes)
+      for (const [column, value] of Object.entries(row.values)) {
+        if (usedColumns.has(column)) continue;
+        const id = `source:${mapping.sourceNamespace}:${column}`;
+        dimensions[id] = value;
+        const type = value === null ? "null" : typeof value;
+        if (type === "string" || type === "number" || type === "boolean" || type === "null") {
+          const current = pendingAttributeTypes.get(id) ?? new Set();
+          current.add(type);
+          pendingAttributeTypes.set(id, current);
+        }
+      }
+    const relationship = mapping.relationships;
+    const occurrence = scalarText(field(relationship?.occurrenceId, "relationships.occurrenceId") ?? "");
+    const claimantIds = relationship?.claimantIds
+      ? splitIds(field(relationship.claimantIds, "relationships.claimantIds"), relationship.claimantIds.delimiter)
+      : undefined;
+    const policyIds = relationship?.policyIds
+      ? splitIds(field(relationship.policyIds, "relationships.policyIds"), relationship.policyIds.delimiter)
+      : undefined;
+    const coverageIds = relationship?.coverageIds
+      ? splitIds(field(relationship.coverageIds, "relationships.coverageIds"), relationship.coverageIds.delimiter)
+      : undefined;
+    const revisionId = scalarText(field(mapping.revision.id, "revision.id", true) ?? "");
+    const actionText = scalarText(field(mapping.revision.action, "revision.action") ?? "upsert").toLowerCase();
+    if (actionText !== "upsert" && actionText !== "delete")
+      issues.push({ path: "$.revision.action", message: "Revision action must be upsert or delete" });
+    const sequenceValue = mapping.revision.sequence
+      ? parseNumberValue(
+          field(mapping.revision.sequence, "revision.sequence", true),
+          mapping.revision.sequence,
+          "$.revision.sequence",
+          issues,
+        )
+      : undefined;
+    if (typeof sequenceValue === "number" && !Number.isSafeInteger(sequenceValue))
+      issues.push({ path: "$.revision.sequence", message: "Revision sequence must be a safe integer" });
+    const correctedAtValue = field(mapping.revision.correctedAt, "revision.correctedAt");
+    const correctedAt = correctedAtValue === undefined ? undefined : scalarText(correctedAtValue);
+    if (correctedAt !== undefined && !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(correctedAt))
+      issues.push({ path: "$.revision.correctedAt", message: "correctedAt must be an ISO timestamp with offset" });
+    if (!isDiagnosticToken(recordId)) issues.push({ path: "$.recordId", message: "recordId is invalid" });
+    if (!isDiagnosticToken(claimId)) issues.push({ path: "$.claimId", message: "claimId is invalid" });
+    if (!isDiagnosticToken(revisionId)) issues.push({ path: "$.revision.id", message: "revision id is invalid" });
+    if (issues.length > 0) {
+      rejected.push({
+        rowNumber: row.rowNumber,
+        source: { artifactId: mapping.artifactId, sourceRow: row.rowNumber },
+        issues,
+      });
+      continue;
+    }
+    for (const [id, types] of pendingAttributeTypes) {
+      const current = attributeTypes.get(id) ?? new Set();
+      types.forEach((type) => current.add(type));
+      attributeTypes.set(id, current);
+    }
+    const relationships = {
+      ...(claimantIds === undefined ? {} : { claimantIds }),
+      ...(occurrence === "" ? {} : { occurrenceId: occurrence }),
+      ...(policyIds === undefined ? {} : { policyIds }),
+      ...(coverageIds === undefined ? {} : { coverageIds }),
+    };
+    records.push({
+      recordId,
+      sourceNamespace: mapping.sourceNamespace,
+      claimId,
+      grain: mapping.grain,
+      ...(componentIdValue === undefined ? {} : { componentId: scalarText(componentIdValue) }),
+      ...(accidentDate === undefined ? {} : { accidentDate }),
+      ...(reportDate === undefined ? {} : { reportDate }),
+      ...(evaluationDate === undefined ? {} : { evaluationDate }),
+      ...(effectiveDate === undefined ? {} : { effectiveDate }),
+      measures: actionText === "delete" ? {} : measures,
+      ...(statusValue === undefined ? {} : { status: scalarText(statusValue) }),
+      ...(Object.keys(dimensions).length === 0 ? {} : { dimensions }),
+      ...(Object.keys(relationships).length === 0 ? {} : { relationships }),
+      completeness: mapping.completeness,
+      revision: {
+        id: revisionId,
+        action: actionText as "upsert" | "delete",
+        ...(typeof sequenceValue !== "number" ? {} : { sequence: sequenceValue }),
+        ...(correctedAt === undefined ? {} : { correctedAt }),
+      },
+      source: { artifactId: mapping.artifactId, sourceRow: row.rowNumber },
+    });
+  }
+  records.sort((left, right) =>
+    left.recordId === right.recordId ? 0 : left.recordId < right.recordId ? -1 : 1,
+  );
+  rejected.sort((left, right) => left.rowNumber - right.rowNumber);
+  return snapshotDiagnosticJson({
+    mappingId: mapping.id,
+    mappingVersion: mapping.version,
+    sourceNamespace: mapping.sourceNamespace,
+    artifactId: mapping.artifactId,
+    records,
+    rejected,
+    attributeCatalog: [...attributeTypes.entries()]
+      .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+      .map(([id, types]) => ({
+        id,
+        sourceColumn: id.slice(`source:${mapping.sourceNamespace}:`.length),
+        observedTypes: [...types].sort(),
+      })),
+    reconciliation: {
+      inputRows: rowsInput.length,
+      acceptedRows: records.length,
+      rejectedRows: rejected.length,
+    },
+  });
+}

package/src/index.ts

@@ -1,4 +1,8 @@
 export * from "./csv.js";
+export * from "./customizationContracts.js";
+export * from "./customizationExternalState.js";
+export * from "./customizationHistoryStream.js";
+export * from "./historyMapping.js";
 export * from "./annualDevelopment.js";
 export * from "./exposure.js";
 export * from "./diagnosticInput.js";

package/src/version.ts

@@ -1 +1 @@
-export const DATA_PACKAGE_VERSION = "0.7.1";
+export const DATA_PACKAGE_VERSION = "0.8.1";