@dforge-core/metadata 0.0.44 → 0.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dforge-core/metadata",
-  "version": "0.0.44",
+  "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/entity.schema.json

@@ -428,7 +428,7 @@
 				"fieldTypeCd": {
 					"type": "string",
 					"enum": [
-						"text", "avatar", "email", "phone", "url", "textarea", "number", "currency", "percent",
+						"text", "avatar", "email", "phone", "url", "textarea", "number", "currency", "percent", "filesize",
 						"checkbox", "date", "datetime", "time",
 						"dropdown", "flags", "tags", "json", "hidden", "color", "image", "file",
 						"markdown", "richtext", "lookup", "user", "grid", "list", "entitylink", "code"

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/actions.ts

@@ -60,6 +60,25 @@ export interface ActionDef {
 	 * "Run in Background". A parameterless `isAsync` action is queued directly.
 	 */
 	isAsync?: boolean;
+	/**
+	 * Code of a print template of the action's entity. The run dialog renders it as a PDF beside the params when the
+	 * action is opened on one record, so the user sees the document the action sends before it goes.
+	 */
+	previewTemplate?: string;
+	/**
+	 * Saved parameter sets the module ships for this action, keyed by set name. They install as shared sets owned by
+	 * the module: read-only for users and refreshed on every install, and a user can save a set of their own under the
+	 * same name, which wins for them. Each `values` key must be a param the action declares; a string starting with `=`
+	 * is a formula. Needs the action to declare params.
+	 */
+	paramSets?: Record<string, ActionParamSetDef>;
+}
+
+/** One shipped parameter set of an action. */
+export interface ActionParamSetDef {
+	description?: string;
+	/** Value by param code. */
+	values: Record<string, unknown>;
 }
 
 /** A `ui/actions.json` file: action code → definition. */

package/src/derive.ts

@@ -24,6 +24,7 @@ const TEXT_BACKED = new Set(["textarea", "markdown", "richtext", "code"]);
 const DB_DATATYPE_OVERRIDE: Record<string, string> = {
 	file: "jsonb",
 	image: "jsonb",
+	filesize: "int8",
 };
 
 export interface DeriveOptions {

package/src/dsl/builtins.ts

@@ -151,7 +151,7 @@ export const BUILTINS: Builtin[] = [
 		name: "sendEmail",
 		signature: "sendEmail(to, subjectOrTemplate, dataOrBody?, attachments?)",
 		returns: "void",
-		doc: "Queue an outbound email. Three arguments, and the **second** picks the mode: `sendEmail(to, 'order.shipped', { ref: [code] })` sends a template, `sendEmail(to, 'Your order shipped', '<p>…</p>')` sends raw HTML. A second argument with no spaces that contains `.` or `_` is read as a template code — so a raw subject like `'Shipped.'` silently becomes one; give a raw subject spaces. The optional **fourth** argument attaches files: a `printPdf()` result, or an array of them (`[a, b]`; pass a single file as itself, because a one-name `[a]` reads as a field reference in the DSL). Only a `printPdf()` result can be attached, and only by the user who generated it (or a workspace admin); at most 5 files and 10 MB in all per email (`Email:MaxAttachments`, `Email:MaxAttachmentBytes`). A file the sender may not attach fails the action. Not available in a scheduled job, whose emails with attachments are not queued.",
+		doc: "Queue an outbound email. Three arguments, and the **second** picks the mode: `sendEmail(to, 'order.shipped', { ref: [code] })` sends a template, `sendEmail(to, 'Your order shipped', '<p>…</p>')` sends raw HTML. A second argument with no spaces that contains `.` or `_` is read as a template code — so a raw subject like `'Shipped.'` silently becomes one; give a raw subject spaces. The optional **fourth** argument attaches files: a `printPdf()`, `attachText()` or `attachBase64()` result, or an array of them (`[a, b]`; pass a single file as itself, because a one-name `[a]` reads as a field reference in the DSL). A `printPdf()` file can be attached only by the user who generated it (or a workspace admin) and not in a scheduled job; a file built with `attachText()` / `attachBase64()` has no owner and works everywhere, a scheduled job included. At most 5 files and 10 MB in all per email (`Email:MaxAttachments`, `Email:MaxAttachmentBytes`). A file the sender may not attach fails the action.",
 	},
 
 	// External calls
@@ -206,6 +206,18 @@ export const BUILTINS: Builtin[] = [
 		returns: "string",
 		doc: "`downloadText()` for bytes: decodes `base64` and hands it to the user as `fileName` (`application/octet-stream` unless `mimeType` says otherwise). Returns the signed download URL.",
 	},
+	{
+		name: "attachText",
+		signature: "attachText(content, fileName, encoding?, mimeType?)",
+		returns: "object",
+		doc: "Build a text file to attach to an email: encodes `content` in `encoding` (`utf-8` by default) and returns a descriptor for `sendEmail()`'s fourth argument, e.g. `sendEmail(to, 'Interview', body, attachText(ics, 'invite.ics', 'utf-8', 'text/calendar'))`. The file keeps `mimeType` (`text/plain` by default). It is the script's own output, so no user's rights are involved and it works in a scheduled job. Only the emails of this run can name it. Max 10 MB per file and 10 files per run, shared with `downloadText()` / `downloadBase64()`.",
+	},
+	{
+		name: "attachBase64",
+		signature: "attachBase64(base64, fileName, mimeType?)",
+		returns: "object",
+		doc: "`attachText()` for bytes given as base64 (`application/octet-stream` unless `mimeType` says otherwise).",
+	},
 	{
 		name: "getSetting",
 		signature: "getSetting(settingCd)",

package/src/field-types.ts

@@ -20,6 +20,7 @@ export const fieldTypes = [
 	{ cd: "number", name: "Number", columnType: "D", baseDatatypeCd: "number", supportedAgg: "SCAM", maxLen: null, precision: null, useStringInFilter: false },
 	{ cd: "currency", name: "Currency", columnType: "D", baseDatatypeCd: "number", supportedAgg: "SCAM", maxLen: null, precision: 2, useStringInFilter: false },
 	{ cd: "percent", name: "Percent", columnType: "D", baseDatatypeCd: "number", supportedAgg: "CAM", maxLen: null, precision: 2, useStringInFilter: false },
+	{ cd: "filesize", name: "File Size", columnType: "D", baseDatatypeCd: "number", supportedAgg: "SCAM", maxLen: null, precision: null, useStringInFilter: false },
 	{ cd: "checkbox", name: "Checkbox", columnType: "D", baseDatatypeCd: "bool", supportedAgg: "C", maxLen: null, precision: null, useStringInFilter: false },
 	{ cd: "date", name: "Date", columnType: "D", baseDatatypeCd: "date", supportedAgg: "CM", maxLen: null, precision: null, useStringInFilter: false },
 	{ cd: "datetime", name: "Date & Time", columnType: "D", baseDatatypeCd: "timestamp", supportedAgg: "CM", maxLen: null, precision: null, useStringInFilter: false },

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";
@@ -185,7 +193,7 @@ export type {
 	TabGroupSection,
 } from "./card-layouts";
 export type { SeedDataFile, SeedDataRepeat } from "./seed-data";
-export type { ActionsFile, ActionDef, ActionExecutionMode } from "./actions";
+export type { ActionsFile, ActionDef, ActionParamSetDef, ActionExecutionMode } from "./actions";
 
 // Flag catalog — the only letters valid on an authored column, at field level and
 // on a per-view override alike (both `flags` patterns in entity.schema.json are

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). */

package/src/types.ts

@@ -50,6 +50,7 @@ export type FieldTypeCd =
 	| "number"
 	| "currency"
 	| "percent"
+	| "filesize"
 	| "checkbox"
 	| "date"
 	| "datetime"