logiparity 1.1.0 → 1.2.0

package/lib/core/dist/calendar.js

@@ -0,0 +1,30 @@
+import { DateTime } from 'luxon';
+export function formatHasTime(format) {
+    return DateTime.fromFormatExplain('', format).tokens.some((token) => !token.literal && /^(?:[HhmsSu]+|[tTfF]{1,4}|[xX])$/.test(token.val));
+}
+export function isCalendarFormat(format) {
+    const tokens = DateTime.fromFormatExplain('', format).tokens.filter((token) => !token.literal);
+    return (!tokens.some((token) => /^(?:[HhmsSuZaXxz]+|[tTfF]{1,4})$/.test(token.val)) &&
+        tokens.some((token) => /^y{2,4}$/.test(token.val)) &&
+        tokens.some((token) => /^[ML]{1,4}$/.test(token.val)) &&
+        tokens.some((token) => /^d{1,2}$/.test(token.val)));
+}
+// Calendar dates have no instant or zone. The fixed 1969–2068 pivot does not depend on the host year or Luxon settings.
+export function normalizeDate(text, format, locale) {
+    if (!format && !/^\d{4}-\d{2}-\d{2}$/.test(text))
+        throw new Error('Date requires an ISO calendar day (yyyy-MM-dd), or a date-only format; omit the time and zone.');
+    const selected = format ?? 'yyyy-MM-dd';
+    const explanation = DateTime.fromFormatExplain(text, selected, { locale });
+    if (!explanation.rawMatches || explanation.invalidReason)
+        throw new Error(`Date value does not match configured calendar format "${selected}".`);
+    const parts = { ...explanation.result };
+    if (explanation.tokens.some((token) => !token.literal && token.val === 'yy') &&
+        typeof explanation.matches?.y === 'number') {
+        const year = explanation.matches.y % 100;
+        parts.year = year <= 68 ? 2000 + year : 1900 + year;
+    }
+    const date = DateTime.fromObject(parts, { zone: 'UTC', locale });
+    if (!date.isValid || date.year < 1 || date.year > 9999)
+        throw new Error('Invalid calendar date; check the year, month, day and leap year.');
+    return date.toISODate();
+}

package/lib/core/dist/config.d.ts

@@ -19,7 +19,9 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         path: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
+        missing: z.ZodOptional<z.ZodNull>;
     }, z.core.$strict>]>>;
+    absentAsNull: z.ZodDefault<z.ZodBoolean>;
     items: z.ZodDefault<z.ZodString>;
     headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     headersEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -75,6 +77,7 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         group: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     datetimeFormat: z.ZodOptional<z.ZodString>;
+    dateFormat: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"rest">;
     label: z.ZodOptional<z.ZodString>;
     rollup: z.ZodOptional<z.ZodObject<{
@@ -115,6 +118,7 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         group: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     datetimeFormat: z.ZodOptional<z.ZodString>;
+    dateFormat: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"csv">;
     label: z.ZodOptional<z.ZodString>;
     rollup: z.ZodOptional<z.ZodObject<{
@@ -149,6 +153,7 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         group: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     datetimeFormat: z.ZodOptional<z.ZodString>;
+    dateFormat: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"xlsx">;
     label: z.ZodOptional<z.ZodString>;
     rollup: z.ZodOptional<z.ZodObject<{
@@ -189,6 +194,7 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         group: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     datetimeFormat: z.ZodOptional<z.ZodString>;
+    dateFormat: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"ui">;
     label: z.ZodOptional<z.ZodString>;
     rollup: z.ZodOptional<z.ZodObject<{
@@ -225,6 +231,7 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         group: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     datetimeFormat: z.ZodOptional<z.ZodString>;
+    dateFormat: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"sql">;
     label: z.ZodOptional<z.ZodString>;
     rollup: z.ZodOptional<z.ZodObject<{
@@ -247,6 +254,7 @@ export declare const ruleSchema: z.ZodObject<{
     type: z.ZodEnum<{
         string: "string";
         number: "number";
+        date: "date";
         enum: "enum";
         money: "money";
         datetime: "datetime";
@@ -256,6 +264,7 @@ export declare const ruleSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
     allowNumber: z.ZodDefault<z.ZodBoolean>;
     caseFold: z.ZodDefault<z.ZodBoolean>;
+    whitespaceFold: z.ZodDefault<z.ZodBoolean>;
     emptyAsNull: z.ZodDefault<z.ZodBoolean>;
     locale: z.ZodOptional<z.ZodString>;
     numberFormat: z.ZodOptional<z.ZodObject<{
@@ -293,15 +302,15 @@ export declare const aggregateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     tolerance: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>], "type">;
 export declare const failOnSchema: z.ZodDefault<z.ZodUnion<readonly [z.ZodArray<z.ZodEnum<{
-    invalid: "invalid";
     missing: "missing";
+    invalid: "invalid";
     extra: "extra";
     mismatch: "mismatch";
     aggregate: "aggregate";
     duplicate: "duplicate";
 }>>, z.ZodRecord<z.ZodEnum<{
-    invalid: "invalid";
     missing: "missing";
+    invalid: "invalid";
     extra: "extra";
     mismatch: "mismatch";
     aggregate: "aggregate";
@@ -319,7 +328,9 @@ export declare const entitySchema: z.ZodObject<{
         fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             path: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
+            missing: z.ZodOptional<z.ZodNull>;
         }, z.core.$strict>]>>;
+        absentAsNull: z.ZodDefault<z.ZodBoolean>;
         items: z.ZodDefault<z.ZodString>;
         headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
         headersEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -375,6 +386,7 @@ export declare const entitySchema: z.ZodObject<{
             group: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         datetimeFormat: z.ZodOptional<z.ZodString>;
+        dateFormat: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"rest">;
         label: z.ZodOptional<z.ZodString>;
         rollup: z.ZodOptional<z.ZodObject<{
@@ -415,6 +427,7 @@ export declare const entitySchema: z.ZodObject<{
             group: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         datetimeFormat: z.ZodOptional<z.ZodString>;
+        dateFormat: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"csv">;
         label: z.ZodOptional<z.ZodString>;
         rollup: z.ZodOptional<z.ZodObject<{
@@ -449,6 +462,7 @@ export declare const entitySchema: z.ZodObject<{
             group: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         datetimeFormat: z.ZodOptional<z.ZodString>;
+        dateFormat: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"xlsx">;
         label: z.ZodOptional<z.ZodString>;
         rollup: z.ZodOptional<z.ZodObject<{
@@ -489,6 +503,7 @@ export declare const entitySchema: z.ZodObject<{
             group: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         datetimeFormat: z.ZodOptional<z.ZodString>;
+        dateFormat: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"ui">;
         label: z.ZodOptional<z.ZodString>;
         rollup: z.ZodOptional<z.ZodObject<{
@@ -525,6 +540,7 @@ export declare const entitySchema: z.ZodObject<{
             group: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         datetimeFormat: z.ZodOptional<z.ZodString>;
+        dateFormat: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"sql">;
         label: z.ZodOptional<z.ZodString>;
         rollup: z.ZodOptional<z.ZodObject<{
@@ -547,6 +563,7 @@ export declare const entitySchema: z.ZodObject<{
         type: z.ZodEnum<{
             string: "string";
             number: "number";
+            date: "date";
             enum: "enum";
             money: "money";
             datetime: "datetime";
@@ -556,6 +573,7 @@ export declare const entitySchema: z.ZodObject<{
         format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
         allowNumber: z.ZodDefault<z.ZodBoolean>;
         caseFold: z.ZodDefault<z.ZodBoolean>;
+        whitespaceFold: z.ZodDefault<z.ZodBoolean>;
         emptyAsNull: z.ZodDefault<z.ZodBoolean>;
         locale: z.ZodOptional<z.ZodString>;
         numberFormat: z.ZodOptional<z.ZodObject<{
@@ -593,15 +611,15 @@ export declare const entitySchema: z.ZodObject<{
         tolerance: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>], "type">>>;
     failOn: z.ZodDefault<z.ZodUnion<readonly [z.ZodArray<z.ZodEnum<{
-        invalid: "invalid";
         missing: "missing";
+        invalid: "invalid";
         extra: "extra";
         mismatch: "mismatch";
         aggregate: "aggregate";
         duplicate: "duplicate";
     }>>, z.ZodRecord<z.ZodEnum<{
-        invalid: "invalid";
         missing: "missing";
+        invalid: "invalid";
         extra: "extra";
         mismatch: "mismatch";
         aggregate: "aggregate";
@@ -634,7 +652,9 @@ export declare const configSchema: z.ZodObject<{
             fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 path: z.ZodString;
                 label: z.ZodOptional<z.ZodString>;
+                missing: z.ZodOptional<z.ZodNull>;
             }, z.core.$strict>]>>;
+            absentAsNull: z.ZodDefault<z.ZodBoolean>;
             items: z.ZodDefault<z.ZodString>;
             headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
             headersEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -690,6 +710,7 @@ export declare const configSchema: z.ZodObject<{
                 group: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>;
             datetimeFormat: z.ZodOptional<z.ZodString>;
+            dateFormat: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"rest">;
             label: z.ZodOptional<z.ZodString>;
             rollup: z.ZodOptional<z.ZodObject<{
@@ -730,6 +751,7 @@ export declare const configSchema: z.ZodObject<{
                 group: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>;
             datetimeFormat: z.ZodOptional<z.ZodString>;
+            dateFormat: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"csv">;
             label: z.ZodOptional<z.ZodString>;
             rollup: z.ZodOptional<z.ZodObject<{
@@ -764,6 +786,7 @@ export declare const configSchema: z.ZodObject<{
                 group: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>;
             datetimeFormat: z.ZodOptional<z.ZodString>;
+            dateFormat: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"xlsx">;
             label: z.ZodOptional<z.ZodString>;
             rollup: z.ZodOptional<z.ZodObject<{
@@ -804,6 +827,7 @@ export declare const configSchema: z.ZodObject<{
                 group: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>;
             datetimeFormat: z.ZodOptional<z.ZodString>;
+            dateFormat: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"ui">;
             label: z.ZodOptional<z.ZodString>;
             rollup: z.ZodOptional<z.ZodObject<{
@@ -840,6 +864,7 @@ export declare const configSchema: z.ZodObject<{
                 group: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>;
             datetimeFormat: z.ZodOptional<z.ZodString>;
+            dateFormat: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"sql">;
             label: z.ZodOptional<z.ZodString>;
             rollup: z.ZodOptional<z.ZodObject<{
@@ -862,6 +887,7 @@ export declare const configSchema: z.ZodObject<{
             type: z.ZodEnum<{
                 string: "string";
                 number: "number";
+                date: "date";
                 enum: "enum";
                 money: "money";
                 datetime: "datetime";
@@ -871,6 +897,7 @@ export declare const configSchema: z.ZodObject<{
             format: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
             allowNumber: z.ZodDefault<z.ZodBoolean>;
             caseFold: z.ZodDefault<z.ZodBoolean>;
+            whitespaceFold: z.ZodDefault<z.ZodBoolean>;
             emptyAsNull: z.ZodDefault<z.ZodBoolean>;
             locale: z.ZodOptional<z.ZodString>;
             numberFormat: z.ZodOptional<z.ZodObject<{
@@ -908,15 +935,15 @@ export declare const configSchema: z.ZodObject<{
             tolerance: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>], "type">>>;
         failOn: z.ZodDefault<z.ZodUnion<readonly [z.ZodArray<z.ZodEnum<{
-            invalid: "invalid";
             missing: "missing";
+            invalid: "invalid";
             extra: "extra";
             mismatch: "mismatch";
             aggregate: "aggregate";
             duplicate: "duplicate";
         }>>, z.ZodRecord<z.ZodEnum<{
-            invalid: "invalid";
             missing: "missing";
+            invalid: "invalid";
             extra: "extra";
             mismatch: "mismatch";
             aggregate: "aggregate";

package/lib/core/dist/config.js

@@ -7,6 +7,7 @@ import { normalize, sourceRule } from './normalize.js';
 import { validAllowedHost } from './hosts.js';
 import { DateTime } from 'luxon';
 import { findingCategories } from './policy.js';
+import { formatHasTime, isCalendarFormat } from './calendar.js';
 const name = z.string().min(1);
 const locale = name.refine((value) => {
     try {
@@ -42,6 +43,7 @@ const datetimeFormat = name.refine((format) => {
         return false;
     }
 }, 'Use supported datetime format tokens, e.g. yyyy-MM-dd HH:mm; quote literal text');
+const dateFormat = datetimeFormat.refine(isCalendarFormat, 'Use a calendar date format with year, month and day, without time or time zone');
 export const reportFileMode = z
     .string({
     error: "Quote report.fileMode as an octal string, e.g. '0640' or '0o640'; plain integers are not accepted",
@@ -55,10 +57,14 @@ const sourceFormatting = {
     locale: locale.optional(),
     numberFormat: numberFormat.optional(),
     datetimeFormat: datetimeFormat.optional(),
+    dateFormat: dateFormat.optional(),
 };
 const envName = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
 export const fieldSchema = z.union([name, z.object({ path: name, label: name.optional() }).strict()]);
 const fields = z.record(name, fieldSchema).refine((v) => Object.keys(v).length > 0, 'Map at least one field');
+const restFields = z
+    .record(name, z.union([name, z.object({ path: name, label: name.optional(), missing: z.null().optional() }).strict()]))
+    .refine((v) => Object.keys(v).length > 0, 'Map at least one field');
 const httpUrl = z.url().refine((v) => {
     try {
         const u = new URL(v);
@@ -156,7 +162,8 @@ export const sourceSchema = z.discriminatedUnion('type', [
         unique: z.array(name).default([]),
         baseUrl: httpUrl,
         path: name,
-        fields,
+        fields: restFields,
+        absentAsNull: z.boolean().default(false),
         items: name.default('$.data[*]'),
         headers: z
             .record(name, z.string())
@@ -252,12 +259,13 @@ export const sourceSchema = z.discriminatedUnion('type', [
 ]);
 export const ruleSchema = z
     .object({
-    type: z.enum(['string', 'number', 'money', 'datetime', 'enum']),
+    type: z.enum(['string', 'number', 'money', 'datetime', 'date', 'enum']),
     allowCurrencySymbol: z.boolean().default(false),
     negativeParentheses: z.boolean().default(false),
     format: z.union([datetimeFormat, z.record(name, datetimeFormat)]).optional(),
     allowNumber: z.boolean().default(false),
     caseFold: z.boolean().default(false),
+    whitespaceFold: z.boolean().default(false),
     emptyAsNull: z.boolean().default(true),
     locale: locale.optional(),
     numberFormat: numberFormat.optional(),
@@ -275,6 +283,26 @@ export const ruleSchema = z
 })
     .strict()
     .superRefine((v, ctx) => {
+    for (const [source, format] of Object.entries(typeof v.format === 'string' ? { '': v.format } : (v.format ?? {}))) {
+        if (v.type === 'datetime' && !formatHasTime(format))
+            ctx.addIssue({
+                code: 'custom',
+                path: ['format', ...(source ? [source] : [])],
+                message: 'Datetime date has no time in the configured format; use type: date for a calendar date',
+            });
+        if (v.type === 'date' && !isCalendarFormat(format))
+            ctx.addIssue({
+                code: 'custom',
+                path: ['format', ...(source ? [source] : [])],
+                message: 'Use a calendar date format without time or time zone',
+            });
+    }
+    if (v.type === 'date' &&
+        (Object.keys(v.sourceTimezones).length || v.tolerance || v.toleranceSeconds || v.displayTimezoneField))
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Calendar dates have no time zone or time tolerance; compare the calendar day exactly',
+        });
     if (v.type === 'money' && !v.currency)
         ctx.addIssue({ code: 'custom', path: ['currency'], message: 'Money requires a currency (e.g. USD)' });
     if (v.type === 'money' && !Number.isSafeInteger(v.tolerance))
@@ -332,6 +360,17 @@ export const entitySchema = z
             message: 'Configure at least two sources; the first is the reference',
         });
     for (const [source, config] of Object.entries(v.sources)) {
+        for (const [field, rule] of Object.entries(v.compare))
+            if (rule.type === 'datetime' &&
+                Object.hasOwn(config.fields, field) &&
+                !(typeof rule.format === 'string' ? rule.format : rule.format?.[source]) &&
+                config.datetimeFormat &&
+                !formatHasTime(config.datetimeFormat))
+                ctx.addIssue({
+                    code: 'custom',
+                    path: ['sources', source, 'datetimeFormat'],
+                    message: `Datetime format for ${field} has no time; use type: date for a calendar date`,
+                });
         if (keyFields(v.key).some((field) => !Object.hasOwn(config.fields, field)))
             ctx.addIssue({
                 code: 'custom',

package/lib/core/dist/engine.js

@@ -4,7 +4,7 @@ import { secretValues, redactSecrets, redactTree } from './diagnostics.js';
 import { keyFields } from './config.js';
 import { readSource } from './source-state.js';
 import { equalValues } from './normalize.js';
-import { aggregateEqual } from './aggregates.js';
+import { aggregateEqual, sumDecimal } from './aggregates.js';
 import { applyFailurePolicies } from './policy.js';
 import { groupFindings, attachGroupMembership } from './groups.js';
 import { collectReconciliation, reconcileAggregates } from './reconciliation.js';
@@ -101,7 +101,7 @@ function compareSource(entity, source, reference, baseline, current, report) {
     const observations = new Map();
     for (const [key, row] of baseline.rows)
         for (const [field, value] of Object.entries(row)) {
-            if (keys.has(field) || ['money', 'number', 'datetime'].includes(entity.compare[field]?.type ?? ''))
+            if (keys.has(field) || ['money', 'number', 'datetime', 'date'].includes(entity.compare[field]?.type ?? ''))
                 continue;
             if (baseline.uncertain.get(key)?.has(field) || current.uncertain.get(key)?.has(field))
                 continue;
@@ -228,6 +228,11 @@ function publishAggregates(entity, source, reference, state, summary, report) {
         aggregate.sourceStatus[source] = excluded.size ? 'uncertain' : 'certain';
         aggregate.uncertainKeys[source] = [...excluded].map((key) => state.parts.get(key) ?? [key]);
         aggregate.values[source] = actual;
+        const exactActual = state.exactMeasurements.get(definition.name);
+        if (exactActual !== undefined) {
+            aggregate.exactValues ??= {};
+            aggregate.exactValues[source] = exactActual;
+        }
         aggregate.rawValues ??= {};
         aggregate.rawValues[source] = state.rawMeasurements.get(definition.name) ?? actual;
         aggregate.excludedRows ??= {};
@@ -264,16 +269,18 @@ function publishAggregates(entity, source, reference, state, summary, report) {
             }
             continue;
         }
-        const expected = aggregate.values[reference];
-        if (source !== reference && expected !== undefined && !aggregateEqual(expected, actual, definition))
+        const expected = aggregate.values[reference], exactExpected = aggregate.exactValues?.[reference];
+        if (source !== reference &&
+            expected !== undefined &&
+            !aggregateEqual(exactExpected ?? expected, exactActual ?? actual, definition))
             appendFinding(report, {
                 type: 'aggregate_mismatch',
                 entity: entity.name,
                 source,
                 key: '',
                 field: definition.name,
-                expected,
-                actual,
+                expected: exactExpected !== undefined && sumDecimal(expected) !== exactExpected ? exactExpected : expected,
+                actual: exactActual !== undefined && sumDecimal(actual) !== exactActual ? exactActual : actual,
                 message: `${definition.name} differs from ${reference}.`,
             });
     }

package/lib/core/dist/groups.d.ts

@@ -6,7 +6,7 @@ export interface PatternOptions {
 }
 export declare function strideGroups(bucket: readonly Finding[], minCount: number, finalKey?: string): FindingGroup[];
 export declare function deltaGroups(bucket: readonly Finding[], entities: readonly EntityConfig[], minCount: number): FindingGroup[];
-export declare function mappingGroups(bucket: readonly Finding[], minCount: number): FindingGroup[];
+export declare function mappingGroups(bucket: readonly Finding[], minCount: number, rule?: EntityConfig['compare'][string]): FindingGroup[];
 export declare function groupFindings(findings: readonly Finding[], entities?: readonly EntityConfig[], finalReferenceKeys?: Readonly<Record<string, string>>, options?: PatternOptions): FindingGroup[];
 export declare function reportGroups(report: Report, presentation?: ReportPresentation): FindingGroup[];
 export declare function groupMembership(report: Report, presentation?: ReportPresentation): number[][];

package/lib/core/dist/groups.js

@@ -166,7 +166,7 @@ export function deltaGroups(bucket, entities, minCount) {
         ]
         : []);
 }
-export function mappingGroups(bucket, minCount) {
+export function mappingGroups(bucket, minCount, rule) {
     const pairs = new Map();
     for (const finding of bucket) {
         if (finding.reason === 'currency_mismatch')
@@ -183,18 +183,38 @@ export function mappingGroups(bucket, minCount) {
         if (!first || entries.length < minCount || first.expected === undefined || first.actual === undefined)
             return [];
         const summary = `${entries.length.toLocaleString('en-US')} ${first.field} values in ${first.source} map ${quoted(first.expected)} to ${quoted(first.actual)}.`;
+        const fold = (value) => value.trim().replace(/\s+/gu, ' ');
+        const formatting = (!rule || rule.type === 'enum' || rule.type === 'string') &&
+            typeof first.expected === 'string' &&
+            typeof first.actual === 'string' &&
+            fold(first.expected).toLocaleLowerCase(rule?.locale ?? 'en-US') ===
+                fold(first.actual).toLocaleLowerCase(rule?.locale ?? 'en-US');
+        const formattingCause = formatting
+            ? fold(String(first.expected)) === fold(String(first.actual))
+                ? 'whitespace_only'
+                : String(first.expected).toLocaleLowerCase(rule?.locale ?? 'en-US') ===
+                    String(first.actual).toLocaleLowerCase(rule?.locale ?? 'en-US')
+                    ? 'case_only'
+                    : 'case_whitespace'
+            : undefined;
         return [
             {
                 ...identity(first),
                 count: entries.length,
-                kind: 'value_mapping',
-                ...(entries.some((item) => item.evidence?.sourceContainsReference)
-                    ? {
-                        cause: 'stale_value',
-                        referenceCount: first.evidence?.referenceCount ?? entries.length,
-                        matchingCount: first.evidence?.matchingCount ?? 0,
-                    }
-                    : {}),
+                kind: rule?.type === 'number'
+                    ? 'number_change'
+                    : formatting
+                        ? 'formatting_difference'
+                        : 'value_mapping',
+                ...(formattingCause
+                    ? { cause: formattingCause }
+                    : rule?.type !== 'number' && entries.some((item) => item.evidence?.sourceContainsReference)
+                        ? {
+                            cause: 'stale_value',
+                            referenceCount: first.evidence?.referenceCount ?? entries.length,
+                            matchingCount: first.evidence?.matchingCount ?? 0,
+                        }
+                        : {}),
                 expected: first.expected,
                 actual: first.actual,
                 summary,
@@ -226,7 +246,9 @@ export function groupFindings(findings, entities = [], finalReferenceKeys = {},
         const rule = entities.find((entity) => entity.name === first.entity)?.compare[first.field];
         const candidates = rule?.type === 'money' || rule?.type === 'datetime'
             ? deltaGroups(bucket, entities, minCount)
-            : mappingGroups(bucket, minCount);
+            : rule?.type === 'date'
+                ? []
+                : mappingGroups(bucket, minCount, rule);
         for (const group of candidates)
             groups.push(group);
     }
@@ -262,7 +284,7 @@ export function groupMembership(report, presentation = {}) {
                     : [];
             if (finding.type !== 'field_mismatch' || finding.field !== group.field)
                 return [];
-            if (group.kind === 'value_mapping')
+            if (['value_mapping', 'formatting_difference', 'number_change'].includes(group.kind))
                 return finding.expected === group.expected && finding.actual === group.actual ? [index] : [];
             const expected = integerValue(finding.expected), actual = integerValue(finding.actual);
             return expected !== undefined && actual !== undefined && String(actual - expected) === group.delta ? [index] : [];

package/lib/core/dist/html-patterns.d.ts

@@ -26,6 +26,16 @@ export declare const kindInfo: {
         readonly color: "tz";
         readonly path: "<path d=\"M4 7h16l-4-4M20 17H4l4 4\"/>";
     };
+    readonly formatting_difference: {
+        readonly label: "Formatting difference";
+        readonly color: "tz";
+        readonly path: "<path d=\"M4 7h16M4 12h10M4 17h16\"/>";
+    };
+    readonly number_change: {
+        readonly label: "Repeated numeric change";
+        readonly color: "round";
+        readonly path: "<path d=\"M4 7h16l-4-4M20 17H4l4 4\"/>";
+    };
 };
 export declare function patternKind(group: FindingGroup): {
     readonly label: "Page boundary";
@@ -47,6 +57,14 @@ export declare function patternKind(group: FindingGroup): {
     readonly label: "Value mapping";
     readonly color: "tz";
     readonly path: "<path d=\"M4 7h16l-4-4M20 17H4l4 4\"/>";
+} | {
+    readonly label: "Formatting difference";
+    readonly color: "tz";
+    readonly path: "<path d=\"M4 7h16M4 12h10M4 17h16\"/>";
+} | {
+    readonly label: "Repeated numeric change";
+    readonly color: "round";
+    readonly path: "<path d=\"M4 7h16l-4-4M20 17H4l4 4\"/>";
 } | {
     label: string;
     color: "page";
@@ -67,6 +85,14 @@ export declare function patternKind(group: FindingGroup): {
     label: string;
     color: "tz";
     path: "<path d=\"M4 7h16l-4-4M20 17H4l4 4\"/>";
+} | {
+    label: string;
+    color: "tz";
+    path: "<path d=\"M4 7h16M4 12h10M4 17h16\"/>";
+} | {
+    label: string;
+    color: "round";
+    path: "<path d=\"M4 7h16l-4-4M20 17H4l4 4\"/>";
 };
 export declare const icon: (path: string) => string;
 export interface PatternCard {

package/lib/core/dist/html-patterns.js

@@ -21,6 +21,8 @@ export const kindInfo = {
         path: '<rect x="3" y="5" width="18" height="14" rx="3"/><path d="M3 9h18M7 14h4"/>',
     },
     value_mapping: { label: 'Value mapping', color: 'tz', path: '<path d="M4 7h16l-4-4M20 17H4l4 4"/>' },
+    formatting_difference: { label: 'Formatting difference', color: 'tz', path: '<path d="M4 7h16M4 12h10M4 17h16"/>' },
+    number_change: { label: 'Repeated numeric change', color: 'round', path: '<path d="M4 7h16l-4-4M20 17H4l4 4"/>' },
 };
 export function patternKind(group) {
     const info = kindInfo[group.kind];
@@ -53,7 +55,9 @@ export function patternCards(report, presentation) {
             group.stride,
             group.cause,
             group.currency ?? rule?.currency,
-            group.kind === 'value_mapping' ? [group.expected, group.actual] : [],
+            ['value_mapping', 'formatting_difference', 'number_change'].includes(group.kind)
+                ? [group.expected, group.actual]
+                : [],
         ], (_, value) => (typeof value === 'bigint' ? String(value) : value));
         let card = cards.get(key);
         if (!card) {
@@ -72,7 +76,11 @@ export function patternCards(report, presentation) {
                             ? `${delta > 0n ? '+' : ''}${formatMoneyMajor(delta, group.currency ?? rule.currency)}`.replace('-', '−')
                             : group.cause === 'stale_value'
                                 ? 'Some values lag'
-                                : 'Consistent mapping',
+                                : group.kind === 'formatting_difference'
+                                    ? 'Formatting differs'
+                                    : group.kind === 'number_change'
+                                        ? 'Numeric values differ'
+                                        : 'Consistent mapping',
                 hint: patternWords(group, presentation).hint,
                 nextStep: patternWords(group, presentation).nextStep,
             };
@@ -195,7 +203,7 @@ export function patternCards(report, presentation) {
         }
         else {
             card.chart =
-                svg(210, 70, `${sources}: ${first.cause === 'stale_value' ? 'stale or lagging values' : 'consistent value mapping'}.`, `<text x="105" y="25" text-anchor="middle" fill="var(--ink)" font-size="13">${escape(presentationValue(first.expected, first.entity, first.field, false, presentation))} → ${escape(presentationValue(first.actual, first.entity, first.field, false, presentation))}</text><text x="105" y="53" text-anchor="middle" fill="var(--muted)" font-size="12">${members.length} values</text>`) + caption(`${sources}: ${labels.field(first.entity, first.field)}.`);
+                svg(210, 70, `${sources}: ${patternKind(first).label}.`, `<text x="105" y="25" text-anchor="middle" fill="var(--ink)" font-size="13" style="white-space:pre">${escape(first.kind === 'formatting_difference' ? JSON.stringify(first.expected) : presentationValue(first.expected, first.entity, first.field, false, presentation))} → ${escape(first.kind === 'formatting_difference' ? JSON.stringify(first.actual) : presentationValue(first.actual, first.entity, first.field, false, presentation))}</text><text x="105" y="53" text-anchor="middle" fill="var(--muted)" font-size="12">${members.length} values</text>`) + caption(`${sources}: ${labels.field(first.entity, first.field)}.`);
         }
     }
     return [...cards.values()];