@dforge-core/metadata 0.0.45 → 0.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dforge-core/metadata",
-  "version": "0.0.45",
+  "version": "0.0.46",
   "description": "Canonical dForge authoring registries — field types, base datatypes, column types, traits, data-view kinds and chart types — with derivation helpers. Runtime-dependency-free; the single source of truth shared by editors, the web app and the CLI.",
   "license": "MIT",
   "author": "dForge",

package/schemas/registers.schema.json

@@ -24,7 +24,7 @@
 						"account": false,
 						"debitAccount": false, "creditAccount": false,
 						"debitAnalyticFields": false, "creditAnalyticFields": false,
-						"sideDimensions": false, "analyticTotals": false
+						"sideDimensions": false, "analyticTotals": false, "importedKeyField": false
 					},
 					"description": "A balance register keeps state, so it needs the entity that holds it. It dates its movements on the journal row under 'journalDate'; 'period' belongs to an information register, whose records ARE the dated thing. Its writer is recorded on the journal row, which is what 'recorder' names for an information register that has no journal."
 				}
@@ -41,7 +41,7 @@
 						"account": false,
 						"debitAccount": false, "creditAccount": false,
 						"debitAnalyticFields": false, "creditAnalyticFields": false,
-						"sideDimensions": false, "analyticTotals": false,
+						"sideDimensions": false, "analyticTotals": false, "importedKeyField": false,
 						"allowNegative": false,
 						"autoCreate": false
 					},
@@ -60,7 +60,7 @@
 						"account": false,
 						"debitAccount": false, "creditAccount": false,
 						"debitAnalyticFields": false, "creditAnalyticFields": false,
-						"sideDimensions": false, "analyticTotals": false,
+						"sideDimensions": false, "analyticTotals": false, "importedKeyField": false,
 						"totals": false,
 						"allowNegative": false,
 						"autoCreate": false
@@ -375,6 +375,11 @@
 				"items": { "type": "string", "pattern": "^[a-z_][a-z0-9_]*$" },
 				"description": "Analytic slot columns for the CREDITED account, in slot order and capped independently of the debit side. Only valid on a compound register."
 			},
+			"importedKeyField": {
+				"type": "string",
+				"pattern": "^[a-z_][a-z0-9_]*$",
+				"description": "Accounting only. The posting column holding the document's key on a posting LOADED beside a document posted in another system — one with no 'source' stamp. getAccountBalance / getAccountTurnover 'exclude' then leaves such postings out by that key as well as the stamped ones. Matches documents with a one-column key."
+			},
 			"sideDimensions": {
 				"type": "object",
 				"minProperties": 1,

package/src/index.ts

@@ -150,6 +150,10 @@ export {
 	registerLineMode,
 	registerRefusedProps,
 	registerRequiredProps,
+	REGISTER_COLUMN_SLOTS,
+	registerColumnSlot,
+	registerColumnHost,
+	isNumericDatatype,
 	checkRegister,
 	checkRegisters,
 	checkRegisterBinding,
@@ -166,6 +170,10 @@ export {
 	type RegisterIssue,
 	type RegisterEntityInfo,
 	type RegisterEntityLookup,
+	type RegisterHosts,
+	type RegisterColumnSlot,
+	type RegisterColumnHost,
+	type ResolvedColumnSlot,
 } from "./registers";
 export type { JobsFile, JobDef } from "./jobs";
 export type { TriggersFile, TriggerDef, EntityEvent } from "./triggers";

package/src/registers/check-declaration.ts

@@ -2,7 +2,7 @@
 // Every rule FAILS OPEN: what cannot be resolved is not reported.
 
 import { createEntityChecks } from "./entities";
-import type { EntityChecks, RegisterEntityLookup, ResolvedRegisterEntity } from "./entities";
+import type { EntityChecks, RegisterEntityLookup, RegisterHosts, ResolvedRegisterEntity } from "./entities";
 import { createIssueReporter } from "./issues";
 import type { IssuePath, RegisterIssue, RegisterReporter } from "./issues";
 import {
@@ -24,9 +24,7 @@ interface Context extends EntityChecks {
 	error: RegisterReporter;
 	warning: RegisterReporter;
 	journalCode?: string;
-	journal: ResolvedRegisterEntity;
-	carrierCode?: string;
-	carrier: ResolvedRegisterEntity;
+	hosts: RegisterHosts;
 	dimensions: string[];
 	sides: Raw;
 	resources: ReturnType<typeof registerResources>;
@@ -76,7 +74,8 @@ function resolveEntities(
 	def: Raw,
 	kind: RegisterKind,
 	checks: EntityChecks,
-): Pick<Context, "journalCode" | "journal" | "carrierCode" | "carrier"> {
+	hosts: RegisterHosts,
+): Pick<Context, "journalCode"> {
 	const { entityAt, columnAt } = checks;
 	const entityCode = safeTrim(def.entity);
 	const journalCode = safeTrim(def.journal);
@@ -87,15 +86,20 @@ function resolveEntities(
 		entityAt(["chart"], safeTrim(def.chart), "Chart");
 	}
 
-	columnAt(["journalDirection"], journal, journalCode, def.journalDirection, "Journal direction column");
-	columnAt(["journalDate"], journal, journalCode, def.journalDate, "Journal date column");
-	columnAt(["period"], entity, entityCode, def.period, "Period column");
-	columnAt(["recorder"], entity, entityCode, def.recorder, "Recorder column");
+	const carrier = carriedByEntity ? entity : journal;
+	hosts.entity = { entity, code: entityCode };
+	hosts.journal = { entity: journal, code: journalCode };
+	hosts.carrier = { entity: carrier, code: registerCarrier(def) };
 
-	return { journalCode, journal, carrierCode: registerCarrier(def), carrier: carriedByEntity ? entity : journal };
+	columnAt(["journalDirection"], def.journalDirection);
+	columnAt(["journalDate"], def.journalDate);
+	columnAt(["period"], def.period);
+	columnAt(["recorder"], def.recorder);
+
+	return { journalCode };
 }
 
-function checkDimensions({ def, dimensions, sides, carrier, carrierCode, columnAt, error }: Context): void {
+function checkDimensions({ def, dimensions, sides, columnAt, error }: Context): void {
 	if (!Array.isArray(def.dimensions) || dimensions.length === 0) {
 		error(["dimensions"], "dimensions", "A register needs at least one dimension.");
 	}
@@ -109,7 +113,7 @@ function checkDimensions({ def, dimensions, sides, carrier, carrierCode, columnA
 	dimensions.forEach((name, i) => {
 		// A two-sided dimension lives in its side columns, not under its own name.
 		if (!(name in sides)) {
-			columnAt(["dimensions", i], carrier, carrierCode, name, "Dimension");
+			columnAt(["dimensions", i], name);
 		}
 	});
 }
@@ -142,7 +146,7 @@ function checkResourceShape(ctx: Context, name: string, resource: Raw, path: (ke
 }
 
 function checkResources(ctx: Context): void {
-	const { def, kind, resources, dimensions, carrier, carrierCode, columnAt, error } = ctx;
+	const { def, kind, resources, dimensions, columnAt, error } = ctx;
 	if (!isRecord(def.resources) || resources.length === 0) {
 		error(["resources"], "resources", "A register needs at least one resource.");
 	}
@@ -162,7 +166,7 @@ function checkResources(ctx: Context): void {
 			if (!column) {
 				continue;
 			}
-			columnAt(path(key), carrier, carrierCode, column, `Resource '${name}' column`);
+			columnAt(path(key), column);
 			const other = storage.get(column);
 			if (other && other !== name) {
 				error(path(key), "resource-column-shared", `Resources '${other}' and '${name}' both store into '${column}' — posting would add both into one column.`);
@@ -180,11 +184,11 @@ function checkResources(ctx: Context): void {
 }
 
 function checkAnalyticSlotColumns(ctx: Context, key: string, columns: string[]): void {
-	columns.forEach((column, i) => ctx.columnAt([key, i], ctx.journal, ctx.journalCode, column, "Analytic slot column"));
+	columns.forEach((column, i) => ctx.columnAt([key, i], column));
 }
 
 function checkSideDimensions(ctx: Context): void {
-	const { dimensions, sides, journal, journalCode, columnAt, error } = ctx;
+	const { dimensions, sides, columnAt, error } = ctx;
 	for (const [name, side] of Object.entries(sides)) {
 		const base: IssuePath = ["sideDimensions", name];
 		if (!dimensions.includes(name)) {
@@ -199,14 +203,14 @@ function checkSideDimensions(ctx: Context): void {
 			same: [...base, "creditField"],
 			sameMessage: `Two-sided dimension '${name}': the two columns must differ.`,
 		});
-		columnAt([...base, "debitField"], journal, journalCode, debitField, `Dimension '${name}' debit column`);
-		columnAt([...base, "creditField"], journal, journalCode, creditField, `Dimension '${name}' credit column`);
+		columnAt([...base, "debitField"], debitField);
+		columnAt([...base, "creditField"], creditField);
 	}
 }
 
 /** Returns whether the register declares analytic slots. */
 function checkCompoundAccounts(ctx: Context): boolean {
-	const { def, journal, journalCode, columnAt, error } = ctx;
+	const { def, columnAt, error } = ctx;
 	refuseKeys(def, ["account", "analyticFields"], error, "line-mode", (key) => `'${key}' belongs to a classic register; a compound one names 'debitAccount' and 'creditAccount'.`);
 	const debit = safeTrim(def.debitAccount);
 	const credit = safeTrim(def.creditAccount);
@@ -216,8 +220,8 @@ function checkCompoundAccounts(ctx: Context): boolean {
 		same: ["creditAccount"],
 		sameMessage: "'debitAccount' and 'creditAccount' must differ — one column would record no correspondence.",
 	});
-	columnAt(["debitAccount"], journal, journalCode, debit, "Debit account column");
-	columnAt(["creditAccount"], journal, journalCode, credit, "Credit account column");
+	columnAt(["debitAccount"], debit);
+	columnAt(["creditAccount"], credit);
 
 	const debitSlots = stringList(def.debitAnalyticFields);
 	const creditSlots = stringList(def.creditAnalyticFields);
@@ -237,12 +241,12 @@ function checkCompoundAccounts(ctx: Context): boolean {
 
 /** Returns whether the register declares analytic slots. */
 function checkClassicAccounts(ctx: Context): boolean {
-	const { def, journal, journalCode, columnAt, error } = ctx;
+	const { def, columnAt, error } = ctx;
 	refuseKeys(def, ["debitAccount", "creditAccount", "debitAnalyticFields", "creditAnalyticFields", "sideDimensions"], error, "line-mode", (key) => `'${key}' belongs to a compound register.`);
 	if (!safeTrim(def.account)) {
 		error(["account"], "accounts", "A classic register names the posting's account column ('account').");
 	}
-	columnAt(["account"], journal, journalCode, safeTrim(def.account), "Account column");
+	columnAt(["account"], safeTrim(def.account));
 	const slots = stringList(def.analyticFields);
 	if (slots.length > MAX_ANALYTIC_SLOTS) {
 		error(["analyticFields"], "analytic-slots", `At most ${MAX_ANALYTIC_SLOTS} analytic slots.`);
@@ -252,7 +256,7 @@ function checkClassicAccounts(ctx: Context): boolean {
 }
 
 function checkComposition(ctx: Context, needsComposition: boolean): void {
-	const { def, entityAt, columnAt, error } = ctx;
+	const { def, entityAt, columnAt, hosts, error } = ctx;
 	const composition = isRecord(def.composition) ? def.composition : undefined;
 	if (needsComposition && !composition) {
 		error(["composition"], "composition", "Analytic slots need a 'composition' — where the chart says which analytic each account takes in which slot.");
@@ -269,9 +273,9 @@ function checkComposition(ctx: Context, needsComposition: boolean): void {
 		}
 	}
 	const code = safeTrim(composition.entity);
-	const entity = entityAt(["composition", "entity"], code, "Composition entity");
+	hosts.composition = { entity: entityAt(["composition", "entity"], code, "Composition entity"), code };
 	for (const key of ["account", "slot", "analytic"]) {
-		columnAt(["composition", key], entity, code, composition[key], `Composition '${key}' column`);
+		columnAt(["composition", key], composition[key]);
 	}
 }
 
@@ -288,7 +292,7 @@ function checkAccounting(ctx: Context): void {
 }
 
 function checkTotals(ctx: Context): void {
-	const { def, kind, dimensions, resources, entityAt, columnAt, error } = ctx;
+	const { def, kind, dimensions, resources, entityAt, columnAt, hosts, error } = ctx;
 	const totals = isRecord(def.totals) ? def.totals : undefined;
 	if (!totals || kind === "info") {
 		return;
@@ -297,7 +301,7 @@ function checkTotals(ctx: Context): void {
 	if (!totalsCode) {
 		error(["totals", "entity"], "totals", "The totals cache needs its entity.");
 	}
-	const totalsEntity = entityAt(["totals", "entity"], totalsCode, "Totals entity");
+	hosts.totals = { entity: entityAt(["totals", "entity"], totalsCode, "Totals entity"), code: totalsCode };
 	const period = safeTrim(totals.period);
 	if (!period || !(REGISTER_TOTALS_PERIODS as readonly string[]).includes(period)) {
 		error(["totals", "period"], "totals", "The totals cache needs a period: day, month, quarter or year.");
@@ -305,12 +309,12 @@ function checkTotals(ctx: Context): void {
 	if (!safeTrim(totals.periodField)) {
 		error(["totals", "periodField"], "totals", "The totals cache needs 'periodField' — the column holding each period's first date.");
 	}
-	columnAt(["totals", "periodField"], totalsEntity, totalsCode, safeTrim(totals.periodField), "Totals period column");
+	columnAt(["totals", "periodField"], safeTrim(totals.periodField));
 	if (kind === "accounting") {
 		if (!safeTrim(totals.accountField)) {
 			error(["totals", "accountField"], "totals", "An accounting register's cache needs 'accountField'.");
 		}
-		columnAt(["totals", "accountField"], totalsEntity, totalsCode, safeTrim(totals.accountField), "Totals account column");
+		columnAt(["totals", "accountField"], safeTrim(totals.accountField));
 		stringList(totals.dimensions).forEach((name, i) => {
 			if (!dimensions.includes(name)) {
 				error(["totals", "dimensions", i], "totals", `Totals dimension '${name}' isn't a dimension of the register.`);
@@ -336,7 +340,7 @@ function checkTotals(ctx: Context): void {
 			if (!safeTrim(entry[key])) {
 				error(["totals", "resources", name], "totals", `Totals resource '${name}' needs '${key}'.`);
 			}
-			columnAt(["totals", "resources", name, key], totalsEntity, totalsCode, safeTrim(entry[key]), `Totals '${name}' ${key}`);
+			columnAt(["totals", "resources", name, key], safeTrim(entry[key]));
 		}
 	}
 	for (const name of Object.keys(cached)) {
@@ -379,10 +383,11 @@ export function checkRegister(raw: unknown, lookup?: RegisterEntityLookup): Regi
 	}
 	const kind = def.kind;
 	checkProperties({ def, kind, error });
-	const checks = createEntityChecks(lookup, error, warning);
+	const hosts: RegisterHosts = {};
+	const checks = createEntityChecks(lookup, error, warning, hosts, kind);
 	const ctx: Context = {
-		def, kind, error, warning, ...checks,
-		...resolveEntities(def, kind, checks),
+		def, kind, error, warning, hosts, ...checks,
+		...resolveEntities(def, kind, checks, hosts),
 		dimensions: registerDimensions(def),
 		sides: isRecord(def.sideDimensions) ? def.sideDimensions : {},
 		resources: registerResources(def),

package/src/registers/columns.ts

@@ -0,0 +1,114 @@
+// Every place a declaration names a stored column, once: which entity the column
+// is stored on, what to call it, and whether it must hold a number.
+//
+// `checkRegister` reads a column through this table, and an editor reads the same
+// rows to offer the right entity's columns at a path — so a column slot added
+// here is checked and pickable without touching either.
+
+import type { IssuePath } from "./issues";
+import { isRecord, registerCarrier, safeTrim } from "./read";
+import type { Raw } from "./read";
+import type { RegisterKind } from "./types";
+
+/** The entity a column slot is stored on. `carrier` is `entity` on a balance / information register, `journal` otherwise. */
+export type RegisterColumnHost = "entity" | "journal" | "carrier" | "totals" | "composition";
+
+export interface RegisterColumnSlot {
+	/** Where in a declaration; `*` matches any key or index at that depth. */
+	path: readonly string[];
+	on: RegisterColumnHost;
+	/** What the column is called in a message; `{0}`, `{1}`… stand for the `*` matches in order. */
+	what: string;
+	/**
+	 * The kinds of register for which the column is added up and so must store a
+	 * number. An information register's resources are what a slice returns — a
+	 * currency code as readily as a price — so it is not among them.
+	 */
+	numericFor?: readonly RegisterKind[];
+}
+
+const SUMMED: readonly RegisterKind[] = ["balance", "turnover", "accounting"];
+
+const slot = (path: string, on: RegisterColumnHost, what: string, summed = false): RegisterColumnSlot => ({
+	path: path.split("."),
+	on,
+	what,
+	...(summed ? { numericFor: SUMMED } : {}),
+});
+
+export const REGISTER_COLUMN_SLOTS: readonly RegisterColumnSlot[] = [
+	slot("journalDirection", "journal", "Journal direction column"),
+	slot("journalDate", "journal", "Journal date column"),
+	slot("period", "entity", "Period column"),
+	slot("recorder", "entity", "Recorder column"),
+	slot("dimensions.*", "carrier", "Dimension"),
+	slot("resources.*.field", "carrier", "Resource '{0}' column", true),
+	slot("resources.*.debitField", "carrier", "Resource '{0}' column", true),
+	slot("resources.*.creditField", "carrier", "Resource '{0}' column", true),
+	slot("account", "journal", "Account column"),
+	slot("debitAccount", "journal", "Debit account column"),
+	slot("creditAccount", "journal", "Credit account column"),
+	slot("analyticFields.*", "journal", "Analytic slot column"),
+	slot("debitAnalyticFields.*", "journal", "Analytic slot column"),
+	slot("creditAnalyticFields.*", "journal", "Analytic slot column"),
+	slot("sideDimensions.*.debitField", "journal", "Dimension '{0}' debit column"),
+	slot("sideDimensions.*.creditField", "journal", "Dimension '{0}' credit column"),
+	slot("composition.account", "composition", "Composition 'account' column"),
+	slot("composition.slot", "composition", "Composition 'slot' column"),
+	slot("composition.analytic", "composition", "Composition 'analytic' column"),
+	slot("totals.periodField", "totals", "Totals period column"),
+	slot("totals.accountField", "totals", "Totals account column"),
+	slot("totals.resources.*.inField", "totals", "Totals '{0}' inField", true),
+	slot("totals.resources.*.outField", "totals", "Totals '{0}' outField", true),
+	slot("totals.resources.*.debitField", "totals", "Totals '{0}' debitField", true),
+	slot("totals.resources.*.creditField", "totals", "Totals '{0}' creditField", true),
+];
+
+export interface ResolvedColumnSlot {
+	on: RegisterColumnHost;
+	/** The column's name for a message, with the path's keys filled in. */
+	what: string;
+	numeric: boolean;
+}
+
+/** The slot a path inside one declaration names a column at; nothing for a path that isn't a column. `kind` is the register's, which decides whether the column must be numeric. */
+export function registerColumnSlot(path: IssuePath, kind?: RegisterKind): ResolvedColumnSlot | undefined {
+	for (const candidate of REGISTER_COLUMN_SLOTS) {
+		if (candidate.path.length !== path.length) {
+			continue;
+		}
+		const captured: string[] = [];
+		const matches = candidate.path.every((segment, i) => {
+			if (segment !== "*") {
+				return segment === path[i];
+			}
+			captured.push(String(path[i]));
+			return true;
+		});
+		if (matches) {
+			return { on: candidate.on, what: candidate.what.replace(/\{(\d+)\}/g, (_, n) => captured[Number(n)] ?? ""), numeric: !!kind && !!candidate.numericFor?.includes(kind) };
+		}
+	}
+	return undefined;
+}
+
+/** The code of the entity a slot's host names in this declaration. */
+export function registerColumnHost(def: Raw, on: RegisterColumnHost): string | undefined {
+	switch (on) {
+		case "entity":
+			return safeTrim(def.entity);
+		case "journal":
+			return safeTrim(def.journal);
+		case "carrier":
+			return registerCarrier(def);
+		case "totals":
+			return isRecord(def.totals) ? safeTrim(def.totals.entity) : undefined;
+		case "composition":
+			return isRecord(def.composition) ? safeTrim(def.composition.entity) : undefined;
+	}
+}
+
+const NUMERIC_DATATYPE = /^(?:(?:numeric|decimal)(?:\s*\(\s*\d+(?:\s*,\s*\d+)?\s*\))?|int[248]?|integer|bigint|smallint|(?:big|small)?serial[248]?|float[48]?|double precision|real|money)$/i;
+
+/** Whether a storage type (`numeric(18,2)`, `int8`) is a scalar number; the whole type must match, so `integer[]` is not. */
+export const isNumericDatatype = (datatype: string): boolean => NUMERIC_DATATYPE.test(datatype.trim());

package/src/registers/entities.ts

@@ -1,5 +1,8 @@
 // Resolving the entities and columns a declaration names, through the caller's lookup.
 
+import { isNumericDatatype, registerColumnSlot } from "./columns";
+import type { RegisterColumnHost } from "./columns";
+import type { RegisterKind } from "./types";
 import { REGISTER_COLUMN_NAME } from "./types";
 import type { IssuePath, RegisterReporter } from "./issues";
 
@@ -10,6 +13,8 @@ import type { IssuePath, RegisterReporter } from "./issues";
  */
 export interface RegisterEntityInfo {
 	columns?: Iterable<string>;
+	/** Storage type per column (`numeric(18,2)`); a column missing here has no numeric rule run on it. */
+	datatypes?: ReadonlyMap<string, string>;
 }
 
 /**
@@ -22,17 +27,22 @@ export type RegisterEntityLookup = (code: string) => RegisterEntityInfo | null |
 
 export type ResolvedRegisterEntity = RegisterEntityInfo | null | undefined;
 
+/** The entities of a declaration resolved so far, by the slot host that names them. */
+export type RegisterHosts = Partial<Record<RegisterColumnHost, { entity: ResolvedRegisterEntity; code: string | undefined }>>;
+
 export interface EntityChecks {
 	/** Resolve `code`, reporting `unknown-entity` when the module is known and has no such entity. */
 	entityAt: (path: IssuePath, code: string | undefined, what: string) => ResolvedRegisterEntity;
-	/** Check a column name, and that `entity` stores it. A non-string or blank column is skipped. */
-	columnAt: (path: IssuePath, entity: ResolvedRegisterEntity, entityCode: string | undefined, column: unknown, what: string) => void;
+	/** Check the column named at `path` — a column slot, so the table says which entity, what to call it and whether it must be numeric. A non-string or blank column is skipped. */
+	columnAt: (path: IssuePath, column: unknown) => void;
 }
 
 export function createEntityChecks(
 	lookup: RegisterEntityLookup | undefined,
 	error: RegisterReporter,
 	warning: RegisterReporter,
+	hosts: RegisterHosts,
+	kind: RegisterKind,
 ): EntityChecks {
 	const resolved = new Map<string, ResolvedRegisterEntity>();
 	const columnSets = new WeakMap<RegisterEntityInfo, Set<string> | null>();
@@ -61,17 +71,28 @@ export function createEntityChecks(
 		return columnSets.get(entity) ?? null;
 	};
 
-	const columnAt: EntityChecks["columnAt"] = (path, entity, entityCode, column, what) => {
+	const columnAt: EntityChecks["columnAt"] = (path, column) => {
 		if (typeof column !== "string" || !column.trim()) {
 			return;
 		}
+		// A call site with no row in REGISTER_COLUMN_SLOTS fails open; the "every call site has a slot" test catches it.
+		const slot = registerColumnSlot(path, kind);
+		if (!slot) {
+			return;
+		}
 		if (!REGISTER_COLUMN_NAME.test(column)) {
-			error(path, "column-name", `${what} '${column}' isn't a column name (lowercase letters, digits and '_').`);
+			error(path, "column-name", `${slot.what} '${column}' isn't a column name (lowercase letters, digits and '_').`);
 			return;
 		}
-		const columns = columnsOf(entity);
+		const host = hosts[slot.on];
+		const columns = columnsOf(host?.entity);
 		if (columns && !columns.has(column)) {
-			warning(path, "unknown-column", `${what} '${column}' isn't a stored column of ${entityCode}.`);
+			warning(path, "unknown-column", `${slot.what} '${column}' isn't a stored column of ${host?.code ? `'${host.code}'` : `the ${slot.on} entity`}.`);
+			return;
+		}
+		const datatype = host?.entity?.datatypes?.get(column);
+		if (slot.numeric && datatype && !isNumericDatatype(datatype)) {
+			warning(path, "column-not-numeric", `${slot.what} '${column}' is ${datatype}, not a number.`);
 		}
 	};
 

package/src/registers/index.ts

@@ -11,7 +11,9 @@ export {
 	registerRefusedProps, registerRequiredProps,
 } from "./read";
 export type { RegisterIssue } from "./issues";
-export type { RegisterEntityInfo, RegisterEntityLookup } from "./entities";
+export type { RegisterEntityInfo, RegisterEntityLookup, RegisterHosts } from "./entities";
 export { checkRegister, checkRegisters } from "./check-declaration";
 export { checkRegisterBinding, isPlainColumnRef } from "./check-binding";
 export type { RegisterBindingTarget } from "./check-binding";
+export { REGISTER_COLUMN_SLOTS, registerColumnSlot, registerColumnHost, isNumericDatatype } from "./columns";
+export type { RegisterColumnSlot, RegisterColumnHost, ResolvedColumnSlot } from "./columns";

package/src/registers/read.ts

@@ -50,6 +50,7 @@ const INFO_PROPERTIES = ["period", "recorder", "recordChangesOnly"] as const;
 const ACCOUNTING_PROPERTIES = [
 	"chart", "composition", "analyticFields", "lineMode", "account",
 	"debitAccount", "creditAccount", "debitAnalyticFields", "creditAnalyticFields", "sideDimensions",
+	"importedKeyField",
 ] as const;
 const BALANCE_PROPERTIES = ["allowNegative", "autoCreate"] as const;
 

package/src/registers/types.ts

@@ -90,6 +90,8 @@ export interface RegisterDef {
 	dimensions: string[];
 	/** Two-sided dimensions of a compound register, with the column per side. */
 	sideDimensions?: Record<string, { debitField: string; creditField: string }>;
+	/** Accounting only: the posting column a loaded posting keeps its document's key in, so `exclude` can leave it out. */
+	importedKeyField?: string;
 	resources: Record<string, RegisterResourceDef>;
 	totals?: RegisterTotalsDef;
 	/** `balance`: may the state go below zero (default false). */