@dforge-core/dforge-mcp 0.2.48 → 0.2.49

package/CHANGELOG.md

@@ -4,7 +4,14 @@ All notable changes to `@dforge-core/dforge-mcp`. This project uses semver-ish
 `0.1.0-rc.N` pre-release tags; the published version is set at publish time via
 the release workflow, so committed `package.json` versions are placeholders.
 
-## Unreleased
+## 0.2.49 - 2026-11-03
+
+**Query columns (`columnType: "Q"`).** A column that gives a record a read-only list of rows — a balance register on the
+record's date, or a query written in the column and filled from the record, optionally shown as a report visualization.
+It is shown on the card and read by print forms, with the reader's rights (core #1584). `column-types.md` gains the
+section and the install refusals; `print-templates.md`, `data-views.md`, `reports.md` and `registers.md` say how it
+meets each. `dforge_entity_field_add` accepts `columnType: "Q"` (requires `params`, no `dbDatatype`). The vendored
+entity schema and `@dforge-core/metadata` (^0.0.49) carry it. The model editor cannot add one yet.
 
 **1C migration readiness and regressions.** `delta --apply` now reports per-module
 `ready` / `partial` status and exits 2 if state, totals or imported markers remain

package/dist/server.js

@@ -31243,7 +31243,7 @@ function buildZedTasks() {
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 
-// node_modules/.pnpm/@dforge-core+metadata@0.0.47/node_modules/@dforge-core/metadata/dist/index.js
+// node_modules/.pnpm/@dforge-core+metadata@0.0.49/node_modules/@dforge-core/metadata/dist/index.js
 var AggType = {
   Sum: "sum",
   Count: "count",
@@ -31321,6 +31321,7 @@ var columnTypes = [
   { cd: "F", name: "Formula", description: "A virtual value calculated from a formula expression." },
   { cd: "G", name: "Generated", description: "A physical column auto-maintained by the database (aggregate or expression)." },
   { cd: "A", name: "Accumulation register", description: "Posts this document into a balance entity (single direction)." },
+  { cd: "Q", name: "Query rows", description: "A read-only list of rows this record reads: a register's balance as of its date, or a query filled from its columns." },
   { cd: "L", name: "Ledger register", description: "Posts document lines into movements + balances (double entry)." }
 ];
 var byCd2 = new Map(columnTypes.map((ct) => [ct.cd, ct]));
@@ -33428,7 +33429,7 @@ function checkFieldSpec(where, field) {
     );
   }
   if (typeof v.flags === "string" && v.flags.includes("M") && v.isNullable === true) {
-    const virtual = typeof v.columnType === "string" && ["R", "S", "F"].includes(v.columnType);
+    const virtual = typeof v.columnType === "string" && ["R", "S", "F", "Q"].includes(v.columnType);
     err(
       `flags '${v.flags}' includes 'M' (mandatory) while "isNullable": true \u2014 a contradiction that fails at pack time. 'M' is resolved into isNullable:false at install. Drop 'M' if the column is optional, or remove "isNullable": true if it is required.${virtual ? " (On a virtual column 'M' is inert anyway \u2014 drop it.)" : ""}`
     );
@@ -33443,7 +33444,7 @@ function checkFieldSpec(where, field) {
   const columnType = typeof v.columnType === "string" ? v.columnType : "";
   if (columnType.length > 0 && !getColumnType(columnType)) {
     err(
-      `columnType '${columnType}' is invalid. Use 'R' (reference), 'S' (set/child list), or 'F' (formula) \u2014 or omit it for a plain data column. (A/L/G exist for register columns.)`
+      `columnType '${columnType}' is invalid. Use 'R' (reference), 'S' (set/child list), 'F' (formula) or 'Q' (a list of rows the record reads) \u2014 or omit it for a plain data column. (A/L/G exist for register columns.)`
     );
   }
   if (typeof v.dbDatatype === "string" && v.dbDatatype.length > 0) {
@@ -33477,6 +33478,21 @@ function checkFieldSpec(where, field) {
       );
     }
   }
+  if (columnType === "Q") {
+    if (v.params === void 0 || typeof v.params !== "object" || v.params === null) {
+      err(
+        "query column (columnType 'Q') requires 'params': { register, asOf, dimensions? } or { entity, query, params? }. (See dforge://reference/column-types.)"
+      );
+    }
+    if (v.dbDatatype !== void 0) {
+      err("query column (columnType 'Q') must NOT set 'dbDatatype' \u2014 it owns no physical column.");
+    }
+    if (typeof v.flags === "string" && /[EM]/.test(v.flags)) {
+      warn(
+        `query column has flags '${v.flags}' \u2014 a list the record reads is never edited or required; the platform ignores them.`
+      );
+    }
+  }
   if (columnType === "G") {
     if (typeof v.formula !== "string" || v.formula.trim() === "") {
       err("generated column (columnType 'G') requires a 'formula' expression.");
@@ -34612,7 +34628,7 @@ var path10 = __toESM(require("path"));
 var fs7 = __toESM(require("fs"));
 var path9 = __toESM(require("path"));
 
-// node_modules/.pnpm/@dforge-core+metadata@0.0.47/node_modules/@dforge-core/metadata/dist/dsl/index.js
+// node_modules/.pnpm/@dforge-core+metadata@0.0.49/node_modules/@dforge-core/metadata/dist/dsl/index.js
 var PUNCT3 = ["===", "!=="];
 var PUNCT2 = [
   "==",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dforge-core/dforge-mcp",
-  "version": "0.2.48",
+  "version": "0.2.49",
   "description": "MCP server for dForge module authoring. Exposes 35 scaffold/patch/validate/pack/install tools and schema resources so AI agents (Claude Code, Cursor, Zed) can create and ship dForge modules.",
   "license": "MIT",
   "homepage": "https://github.com/iash44/dForge-core",
@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "@dforge-core/dforge-cli": "^0.2.37",
-    "@dforge-core/metadata": "^0.0.47",
+    "@dforge-core/metadata": "^0.0.49",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "zod": "^4.4.3"
   },

package/resources/schemas/entity.schema.json

@@ -345,11 +345,90 @@
 			},
 			"additionalProperties": false
 		},
+		"queryColumnParams": {
+			"type": "object",
+			"description": "Binding of a query column (columnType Q): a read-only list of rows for the record, with no physical column. It reads either a balance register as of the record's date (register, asOf, dimensions) or a query written in the column and filled from the record (entity, query, params). Shown on the card and read by print forms, with the reader's rights.",
+			"oneOf": [
+				{
+					"required": ["register", "asOf"],
+					"properties": {
+						"register": {
+							"type": "string",
+							"description": "A balance register of this module or of one it depends on, as 'module_cd.register_cd'. It needs a journal that stamps the date and the direction of each movement.",
+							"examples": ["wms-registry.stock"]
+						},
+						"asOf": {
+							"type": "string",
+							"description": "Date (or timestamp) column of this entity the balance is taken on. The day itself is included."
+						},
+						"viz": {
+							"type": "object",
+							"description": "How the card shows the rows: a report visualization by its type (table, a chart, pivot...) and its config as that visualization takes it. Unset: a table. A print form reads the rows as a table whatever this says.",
+							"required": ["type"],
+							"properties": {
+								"type": { "type": "string" },
+								"config": { "type": "object" }
+							},
+							"additionalProperties": false
+						},
+						"dimensions": {
+							"type": "object",
+							"description": "Register dimension → column of this entity that narrows it. A dimension left out is not narrowed, so its tuples all come back. A narrowing column that is empty on the record leaves the list empty.",
+							"additionalProperties": { "type": "string" },
+							"examples": [{ "warehouse_id": "warehouse_id" }]
+						}
+					},
+					"additionalProperties": false
+				},
+				{
+					"required": ["entity", "query"],
+					"properties": {
+						"entity": {
+							"type": "string",
+							"description": "The entity the query reads, as 'module_cd.entity_cd' (a bare code is this module's own). Of this module or of one it depends on.",
+							"examples": ["retail.goods_line"]
+						},
+						"query": {
+							"type": "object",
+							"description": "The query itself, in the shape query.run takes: columns (a plain name, or { c, agg } with agg group / sum / count / avg / min / max — grouped if any column has one), filter and sort. A filter value written '@name' is filled from the record through 'params'. An aggregate is read under its column's code. Written here and not saved elsewhere, so no edit of a shared query can change the form.",
+							"properties": {
+								"columns": { "type": "array" },
+								"filter": {},
+								"sort": { "type": "array" }
+							},
+							"additionalProperties": false
+						},
+						"viz": {
+							"type": "object",
+							"description": "How the card shows the rows: a report visualization by its type (table, a chart, pivot...) and its config as that visualization takes it. Unset: a table. A print form reads the rows as a table whatever this says.",
+							"required": ["type"],
+							"properties": {
+								"type": { "type": "string" },
+								"config": { "type": "object" }
+							},
+							"additionalProperties": false
+						},
+						"params": {
+							"type": "object",
+							"description": "Query parameter (the name after '@' in a filter value) → stored column of this entity that fills it. Every @param of the query is listed, and only those. A column that is empty on the record leaves the list empty rather than widening the query.",
+							"additionalProperties": { "type": "string" },
+							"examples": [{ "doc": "document_id" }]
+						}
+					},
+					"additionalProperties": false
+				}
+			]
+		},
 		"registryColumnParams": {
 			"type": "object",
 			"description": "params of an accumulation (A) or ledger (L) registry column. The lock lists are what BOTH generated guards freeze — the posted-document guard while the document is posted, the period guard while its period is closed — and they are required: install refuses a registry column that omits or empties them. The header's periodDateField and the state column are watched in addition, whatever the list says.",
 			"required": ["lockedFields"],
+			"if": { "required": ["editorMayPost"], "properties": { "editorMayPost": { "const": true } } },
+			"then": { "not": { "anyOf": [ { "required": ["postAction"] }, { "required": ["unpostAction"] } ] } },
 			"properties": {
+				"postAction": { "type": "string", "minLength": 1, "description": "Code of the action (available for this entity) that posts the document. A direct data.insert / data.update that turns the state flag on needs 'E' on it, as the button does, so \"may edit\" and \"may post\" stay two rights through the API too. An action's own writes are not re-checked. Pack refuses a name that no action declared for this entity carries. Unset: the transition needs only Insert/Update." },
+				"unpostAction": { "type": "string", "minLength": 1, "description": "Code of the action that unposts the document; the same gate for a direct write that turns the state flag off." },
+				"editorMayPost": { "type": "boolean", "description": "Declares that Insert/Update on the document includes posting it: no separate right to post is intended, so no postAction / unpostAction is named. Changes nothing at run time; it silences the pack warning for a column that names no posting action. Not together with postAction / unpostAction." },
 				"lockedFields": {
 					"type": "array",
 					"minItems": 1,
@@ -408,6 +487,10 @@
 				{
 					"if": { "required": ["columnType"], "properties": { "columnType": { "enum": ["A", "L"] } } },
 					"then": { "required": ["params"], "properties": { "params": { "$ref": "#/$defs/registryColumnParams" } } }
+				},
+				{
+					"if": { "required": ["columnType"], "properties": { "columnType": { "const": "Q" } } },
+					"then": { "required": ["params"], "properties": { "params": { "$ref": "#/$defs/queryColumnParams" } } }
 				}
 			],
 			"properties": {
@@ -422,8 +505,8 @@
 				},
 				"columnType": {
 					"type": "string",
-					"enum": ["D", "R", "S", "F", "A", "L", "G"],
-					"description": "Column type: D=Data (physical column), R=Reference (N:1 lookup), S=Set (1:N collection), F=Formula (virtual calculated), G=Generated/Computed (physical, auto-maintained), A=Accumulation registry, L=Ledger registry"
+					"enum": ["D", "R", "S", "F", "A", "L", "G", "Q"],
+					"description": "Column type: D=Data (physical column), R=Reference (N:1 lookup), S=Set (1:N collection), F=Formula (virtual calculated), G=Generated/Computed (physical, auto-maintained), A=Accumulation registry, L=Ledger registry, Q=Query (virtual list of rows read from a register, bound to this record)"
 				},
 				"fieldTypeCd": {
 					"type": "string",
@@ -633,6 +716,17 @@
 						"columnType": { "const": "G" },
 						"link": false
 					}
+				},
+				{
+					"title": "Query column (Q)",
+					"description": "Read-only list of rows the record reads, with no physical column (columnType 'Q'): a register's balance as of the record's date, or a query written in 'params' and filled from the record. Requires 'params'. Must NOT have 'dbDatatype', 'fieldTypeCd' or 'link'.",
+					"required": ["columnType", "params"],
+					"properties": {
+						"columnType": { "const": "Q" },
+						"dbDatatype": false,
+						"fieldTypeCd": false,
+						"link": false
+					}
 				}
 			],
 			"required": ["orderNum", "description"],

package/resources/schemas/jobs.schema.json

@@ -52,7 +52,7 @@
 					},
 					"idempotencyKey": {
 						"type": "string",
-						"description": "Template like '{job_cd}:{run.month}'. Resolved at fire time. A successful run with the same key blocks re-dispatch (Phase 3 enforcement)."
+						"description": "Reserved; not enforced yet. Stored but never read by the scheduler, so it does not block re-dispatch. Only the scheduled slot (job, scheduled_at) is deduplicated; guard business-level 'once per period' inside the action."
 					},
 					"class": {
 						"type": "string",

package/resources/schemas/print-templates.schema.json

@@ -55,6 +55,11 @@
 							"left":   { "type": "string" }
 						},
 						"additionalProperties": false
+					},
+					"culture": {
+						"type": "string",
+						"description": "The form's own culture, e.g. 'uk-UA': format_number, format_currency, format_date, _fmt and Yes/No print in it whoever prints the form. Omitted: the user's culture. An unknown culture is refused at pack and install.",
+						"examples": ["uk-UA", "de-CH"]
 					}
 				},
 				"additionalProperties": false

package/skills/dforge-mcp-author/references/column-types.md

@@ -1,6 +1,6 @@
 # Column Types Reference
 
-Every column has a `columnType` (optional for the default physical type). Seven values exist:
+Every column has a `columnType` (optional for the default physical type). Eight values exist:
 
 | `columnType` | Physical DB column? | Description |
 |---|---|---|
@@ -10,9 +10,10 @@ Every column has a `columnType` (optional for the default physical type). Seven
 | `"F"` | No | **Formula column** — virtual computed value. Evaluated by the formula engine. |
 | `"A"` | Yes | **Accumulation register column** — stores posted state for accumulation registers. Advanced (accounting modules). |
 | `"L"` | Yes | **Ledger register column** — stores posted state for double-entry bookkeeping. Advanced (accounting modules). |
+| `"Q"` | No | **Query column** — a read-only list of rows the record reads (a register's balance on its date, or a query filled from its columns). Shown on the card and read by print forms. See below. |
 | `"G"` | Yes | **Generated column** — DB-level computed value. Two strategies, auto-detected from the formula: a **trigger-based aggregate over a child set** (`SUM([lines].[amount])`), or a same-row PostgreSQL `GENERATED ALWAYS AS` (`[qty] * [price]`). This is the correct type for **roll-up totals over child rows** (see below). The aggregated child column **must be physical** (a `D` column, or a same-row `G`) — never a virtual `F`/`R`/`S` column. |
 
-**For most module development, you'll use D, R, S, and F.** Add `G` when you need a **roll-up total over a child set** (`SUM`/`COUNT`/`AVG`/`MIN`/`MAX`) — see below. Types A and L are for advanced accounting/registry modules that use the `postable`, `accumulation`, or `ledger` traits.
+**For most module development, you'll use D, R, S, and F.** Add `Q` for a list a form reads from elsewhere. Add `G` when you need a **roll-up total over a child set** (`SUM`/`COUNT`/`AVG`/`MIN`/`MAX`) — see below. Types A and L are for advanced accounting/registry modules that use the `postable`, `accumulation`, or `ledger` traits.
 
 ## Data columns (`columnType` omitted or `"D"`)
 
@@ -165,6 +166,40 @@ Do **not** include `dbDatatype` on formula columns (there's no physical storage)
 
 See `formulas.md` for syntax.
 
+## Query columns (`columnType: "Q"`)
+
+A read-only list of rows a record reads, with no physical column and no `link`: the card shows it beside the sets, and a print form loops it like a set. Declare it in the entity file; the model editor cannot add one. The binding is `params`, one of two sources:
+
+```json
+// A balance register on the record's date, narrowed by the record's own columns
+"old_stock": {
+    "columnType": "Q",
+    "description": "Balance on the document's date",
+    "params": { "register": "wms-registry.stock", "asOf": "doc_date", "dimensions": { "warehouse_id": "warehouse_id" } }
+},
+// A query written in the column, its @param filled from the record; grouped and summed if the query is
+"lines_by_product": {
+    "columnType": "Q",
+    "description": "Lines by product",
+    "params": {
+        "entity": "retail.document_line",
+        "query": {
+            "columns": [ { "c": "product_id", "agg": "group" }, { "c": "quantity", "agg": "sum" } ],
+            "filter": { "c": "document_id", "o": "eq", "v": "@doc" },
+            "sort": [ { "c": "product_id", "d": "asc" } ]
+        },
+        "params": { "doc": "document_id" }
+    }
+}
+```
+
+- `register` is a `balance` register of this module or one it depends on, with a journal that stamps date and direction. `asOf` is a date column of the record (the day itself is included). `dimensions` maps a register dimension to a record column; a dimension left out is not narrowed.
+- `entity` is `module.entity` (bare for this module's own). `query` takes `columns`, `filter` and `sort` as `query.run` does. Every `@param` of the filter is listed in `params.params`, to a stored column of the record, and only those. State a `sort` on a grouped query. An aggregate is read under its column's code.
+- Optional `params.viz` (`{ "type": "bar", "config": {} }`) shows the card's rows as a report visualization; unset, a table. A print form reads a table whatever it says.
+- Reads use the **reader's** rights: Select on the source, the folder's view and row filter. A reader who may not see it gets the column left out of the card and an empty list with a warning in a print; a PDF or subscription is refused. A record column that is empty gives an empty list, never every row. At most 1000 rows.
+- **Install refuses**: an undeclared register or entity (or one of a module this one does not depend on), a register that is not `balance` or has no dated journal, `asOf` that is not a date, a column the record or the source does not have, an unfilled or extra `@param`, keys of the other source, a `viz` without `type`, a Q column in an extension of another module's entity, a Q column listed in a data view, and a Q column as a report parameter source.
+- A Q column is no field: `data.get` skips it, DSL `select()` refuses it, and it cannot be edited. For a figure over a large table use a `G` column or a record report.
+
 ## Roll-up totals over child rows — use `G`, not `F`
 
 To total a child set on a header (line items → order total, movements → quantity on hand),
@@ -213,5 +248,6 @@ inside one aggregate must point at the **same** set column, and `COUNT(*)` is re
 - **"User picker" (points to admin.user)** → omit `columnType`, use `fieldTypeCd: "user"` (writes user ID directly, no paired FK)
 - **"Polymorphic link to any entity"** → omit `columnType`, use `fieldTypeCd: "entitylink"` (stored as JSON)
 - **"Roll-up total over child rows"** (line items → header total, movements → quantity on hand) → `"G"` with `SUM([set].[field])` (trigger-maintained, stored; see "Roll-up totals" above). Aggregate only a **physical** child column — never an `F`/`R`/`S` column. Do **not** use `"F"` for set aggregation — it silently renders empty.
+- **"List of rows this record reads"** (stock on the document's date, a document's lines by product) → `"Q"` (see "Query columns" above)
 - **"Accumulation register state"** → `"A"` (advanced accounting — requires `postable` + `accumulation` traits)
 - **"Double-entry ledger state"** → `"L"` (advanced accounting — requires `postable` + `ledger` traits)

package/skills/dforge-mcp-author/references/data-views.md

@@ -273,6 +273,8 @@ Each column is either a simple string or an object:
 ]
 ```
 
+A query column (`columnType: "Q"`) is a list the record reads, not a value: a view that lists one is refused at validate/pack. It shows on the record's card instead (column-types.md § Query columns).
+
 ## Filters
 
 Filters use dForge's canonical JSON filter format — see [filters.md](filters.md) for the full grammar. Keys are `c` (column), `o` (operator), `v` (value) for conditions, and `g` (group operator), `i` (items) for groups.

package/skills/dforge-mcp-author/references/formulas.md

@@ -167,6 +167,19 @@ The whole date family evaluates identically **client-side and SQL-time** (report
     `dforge_module_validate` and `dforge_module_pack` (the CLI's static checks) catch only a
     malformed call, such as a name that is not a text literal or a dimension without its value;
     whether the register, resource and dimensions exist is known at install.
+  - The resource and dimensions must be stored columns of the register's entity. Install
+    refuses a register whose dimension or resource is a formula, reference or set column:
+    nothing is stored there to read. A register installed before that rule gives an empty
+    cell with a warning.
+  - A resource or dimension name may follow ONE reference (#1585). This is 1C's
+    `СрезПоследних(...).ФизЛицо.Наименование`. As the resource, `'person_id.name'` reads `name`
+    of what the record in effect references. As a dimension, `'employee_id.person_id', [person_id]`
+    matches the records whose employee is that person's; the newest across them wins. The column
+    followed must be the `thisKey` of a single-key reference column on the register's entity, and
+    the column named must be stored on the target's own table. The target is read with the user's
+    rights (Select, visible columns, row filter). A target the user cannot see gives an empty
+    cell, never an older record. Install refuses a path through a non-reference or to an unstored
+    column; pack refuses two hops.
   - Refused at install in a `G` column: it is computed when a row is written and would not
     follow a record added to the register later. Use an `F` column.
   - Newest record only: there is no `first` mode as `getSlice` has. Each row is one index
@@ -421,7 +434,8 @@ An `F` column is virtual: not stored, not editable. To fill a **stored, editable
 - Using JavaScript syntax like `row.field` or `this.field` — **wrong**. Only `[field]`.
 - Forgetting `baseDatatypeCd` on formula columns — **required**. Without it, filters and SQL don't work.
 - Using SQL syntax like `SELECT`, `JOIN`, `WHERE` — **wrong**. Formulas are expressions, not queries.
-- String concatenation with commas — **wrong**. Use `+` or `CONCAT()`.
+- String concatenation with commas — **wrong**. Use `+` or `CONCAT()`. `+` concatenates when either side is text: a text column or literal, a string function, an `IF` whose branch is text, `COALESCE` / `NULLIF` of text, or a `SLICE()` of a text resource. `CONCAT()` also reads a null as empty, so prefer it when a part may be missing.
+- `[x] != ''` is true when `[x]` is null: comparisons are null-safe. To test "has text", write `COALESCE([x], '') != ''`.
 
 ## Reference
 

package/skills/dforge-mcp-author/references/print-templates.md

@@ -63,12 +63,15 @@ Every column on the entity is a top-level variable. Display formatting is pre-ap
 | `{{ _settings.<cd> }}`  | Folder-resolved module setting. Image/file settings come as base64 data URIs (drop into `<img src>`).   |
 | `{{ _today }}`          | Typed `DateTimeOffset` (UTC); `{{ _fmt._today }}` is the pre-formatted string                          |
 | `{{ <set_name> }}`      | Child set — array, in primary-key order. Loaded wherever the template's Liquid code names it (see below) |
+| `{{ <query_column> }}`  | Query column (`Q`) — the rows the record reads (`{% for r in old_stock %}{{ r.quantity }} {{ r._fmt.quantity }}`). Loaded only where the template's Liquid code names it, like a set; always a table here, whatever the column's `viz` says |
 | `{{ _css }}`            | The CSS string attached to the template (rarely needed in template body)                                |
 
 Inside a child-set loop, the same shape applies per row: `line._fmt.<col>`, `line._raw.<col>`, `line._color.<col>`.
 
 A loop over a document's set can read a set of the line's own entity off each line (`{% for l in lines %}{% for a in l.attributes %}`): detected by the template reading it, loaded for every line in one query under the same rights and row filter, one level deep. The editor preview does not fill it.
 
+A query column's rows are read with the **printer's** rights: without Select on its source the list prints empty and `print.render` says so in `warnings`, while `print.renderPdf`, `printPdf()` and a subscription are refused with 403 (a PDF that is archived or mailed must not silently miss data). A record with an empty date or narrowing column lists nothing, with a warning. The default form (no template) lists no query column. See column-types.md § Query columns.
+
 A printed set, nested or not, needs **Select** on its entity in the folder, as `data.get` does; one the user cannot read prints empty. `print.render` and `print.renderPdf` check Select on the printed entity.
 
 A currency column prints its glyph for the common codes (`EUR` → `€`, `USD` → `$`, `GBP` → `£`, `UAH` → `₴`, `PLN` → `zł`); other codes print as the code. `format_currency` follows the same mapping.
@@ -94,13 +97,14 @@ A value that changes over time — a price, an employee's position, an organizat
 | A value of the record or of a record it references (the organization's requisites as one block) | An `F` column on the entity: references and built-in functions |
 | A value per line (places, weight through the product's units) | An `F` column on the line entity, printed as `line.<col>` |
 | One total over a set | Over a stored line column (`D`, or a `G` on the line): a `G` column on the document (`SUM([lines].[amount])`). Over a line `F` column: a `plus` accumulator in the loop, `{% assign s = 0 %}{% for l in lines %}{% assign s = s \| plus: l.places %}{% endfor %}`, since a `G` cannot sum an `F` child (install fails with `column old.<field> does not exist`) |
-| Lines grouped by a column, totals per group (by product and series, by VAT rate, a packing list by pallet) | **Not available in the print context yet.** It prints the record and its sets as stored |
+| Lines grouped by a column, totals per group (by product and series, by VAT rate, a packing list by pallet) | A `Q` column with a grouped query on the line entity (`group` on the column, `sum` on the amounts, `@doc` filled from the record), printed as `{% for r in lines_by_product %}` (column-types.md § Query columns) |
+| A register's balance on the document's date, per product | A `Q` column with `register` / `asOf` / `dimensions`, printed as `{% for r in old_stock %}` |
 
-For the last row, do not work around it:
+For grouped rows, use a `Q` column; do not work around it:
 
 - **Not in Liquid filters.** `where`, `sum`, `group_by` and `where_exp` run in the LiquidJS preview, but Scriban (the print) fails with "The function `where` was not found". Filter and total with `{% if %}` and `plus` inside a `for`, which both engines run.
 - **Not a print table filled by an action.** It stores a copy of the document that drifts from it.
-- **Not a stored procedure.** The grouping itself is a grouped query (`references/queries.md`): `group` on the column, `sum` over a line `F` column.
+- **Not a stored procedure.** The grouping itself is a grouped query (`references/queries.md`) held in the `Q` column: `group` on the column, `sum` over the amounts.
 
 ## Custom filters
 
@@ -111,7 +115,7 @@ For the last row, do not work around it:
 | `format_date: <strftime>`                       | `{{ invoice_date | format_date: '%B %d, %Y' }}`        | `"May 22, 2026"`             |
 | `qr_code: <size?>, <ecc?>, <margin?>, <format?>`| `{{ payment_url | qr_code: 200, 'M' }}`                | `data:image/png;base64,…`    |
 
-`format_date` supports strftime: `%Y %m %d %B %b %H %M %S %I %p %A %a %e`. `%B` / `%b` / `%A` / `%a` print **English** names whatever the user's language; for a month in another language keep a small snippet that maps `%m` to the name. `format_date` returns a **string**: arithmetic on its result fails ("Operator - not supported on string"), so compute on the raw value and format last.
+`format_date` supports strftime: `%Y %y %m %d %e %B %b %A %a %H %I %M %S %p` and `%%`. A dash drops the leading zero: `%-m %-d %-H %-I %-M %-S` (`'%-H:%M'` → `9:05`). Text around the specifiers prints as written (`'%d.%m.%Y г.'`). Month and weekday names follow the form's culture (`pageSettings.culture`, else the user's). `%B` beside a day of the month is the genitive (`березня`). `format_date` returns a **string**: compute on the raw value and format last.
 
 **Time zones.** A timestamp in `_fmt` and `format_date` on an instant render in the column's `params.timeZone`, else the request's zone (before platform 2026-10-25, always UTC). A bare date or a timestamp without a zone prints as written.
 
@@ -148,7 +152,7 @@ Snippets run on Scriban (print) and LiquidJS (preview), so write them for both:
 - No `floor` on big numbers: Scriban's goes through a double and rounds them up.
 - No `modulo: 1` on a fraction without snapping the whole part with `round`. LiquidJS 10.30 leaves float noise: `0.44 | modulo: 1` is 0.43999999999999995.
 - Round a fraction half up on its decimal digits, read from the number's text (`append: ''`; the server may print a comma; a browser double under 1e-6 prints as `5e-7`), never by `times` / `plus: 0.5` / `floor`. A double's text is the shortest decimal it stands for, so this matches the server's decimals both on a tie (960.015 → 02) and just below one (1000000000.0049999 → 00). No epsilon can do both.
-- No number taken from `split` / `slice`. A digit is read as `'x0123456789' | split: ch | first | size | minus: 1`.
+- A number taken from `split` / `slice` is a string. `plus`, `minus`, `times`, `divided_by` and `modulo` take a numeric string as its number on both engines: `'5' | plus: 0` is `5`, where before platform 2026-10-30 Scriban printed `50`. A list answers `.first` / `.last` as well as `| first`.
 - Plain `{% comment %}` without trim dashes.
 
 ## Module package layout

package/skills/dforge-mcp-author/references/registers.md

@@ -256,6 +256,7 @@ execute:
     var price = getSlice("wms-registry.outlet_price", { warehouse_id: [warehouse_id], product_id: [product_id] }, [order_date])
 ```
 
+- A form that lists what a balance register held on the record's date (a revaluation's old stock) needs no action: a `Q` column (`register`, `asOf`, `dimensions`; column-types.md § Query columns) reads it with the reader's rights.
 - A dimension left out is summed over by `getBalance` and `getTurnover`. `getSlice` refuses an omitted dimension.
 - `getSlice` answers one dimension tuple from an action. A value per row — each line's price on its document's date, in a print form, report or view — is the formula `SLICE()` on an `F` column (formulas.md).
 - As-of reads and `getTurnover` need a journal with both stamps.
@@ -265,6 +266,10 @@ execute:
 - **Balance at a document's moment.** The platform keeps no order between movements stamped in the same second, so "the balance just before this document" is the caller's decision: read `before` the end of that second and `exclude` the document itself plus every document of that second the caller orders after it (1C's МоментВремени orders by date, then reference). `exclude` matches the postings each document wrote by its `source` stamp; postings loaded from another system carry no stamp and are kept unless the register declares `importedKeyField` (below).
 - **Reports:** a dataset with `"datasetType": "R"` reads an accounting register over an interval. It returns one row per chart account with `opening_*`, `turnover_*` and `closing_*` debit and credit for one resource. See [`reports.md`](reports.md) and [`docs/business-logic/gl-ledger-to-declared-register.md`](../../../docs/business-logic/gl-ledger-to-declared-register.md).
 
+### Showing a balance on a record: a `Q` column
+
+`getBalance` answers one tuple inside an action. To show a document its register's balance **on its own date**, as a list on the card and in print forms, declare a query column (`columnType: "Q"`, `params`: `register`, `asOf`, `dimensions`) instead of an action that computes it. Install refuses a register that is not `balance` or has no dated journal. It reads with the reader's rights and cannot read the totals cache. See column-types.md § Query columns.
+
 ## Totals cache
 
 `totals` caches the turnover inside each `day`/`month`/`quarter`/`year`, never a closing balance, so a backdated posting touches one row. Declare an `entity` whose PRIMARY KEY is exactly (dimensions, `periodField`), with `inField`/`outField` per resource (`debitField`/`creditField` and an `accountField` on accounting). Posting maintains it; install rebuilds it when its shape changes. Not available on `info`. Details: registers.md section 8.4.
@@ -288,6 +293,7 @@ For a history loaded from another system, an `accounting` register may declare `
 - **Period missing from the calendar.** With `periodEntity`, a month that has no row in the period entity counts as **closed**, and posting into it fails (`DF003: Period 1999-04 does not exist`). Seed or load the periods before the documents that post into them.
 - **A summed column that isn't a number.** A resource of a `balance`, `turnover` or `accounting` register, and a `totals` cache's columns, must be a scalar number. The editor and language server warn (`registers/column-not-numeric`, metadata 0.0.46) on `varchar`, `integer[]` and the like. An `info` register's resources are returned, not summed, and may be any type.
 - **"May edit" is not "may post".** Without `postAction` / `unpostAction` a role with Insert/Update on the document can post it through the API (`data.update` with the state flag) though it cannot run the Post action. **Unreleased: not in platform 1.28.12**, so do not declare these keys against that platform. Declare both (declaring one leaves the other direction open), and grant `E` on the actions (`"action:post_entry": "E"`) only to the roles that may post. Each name must be declared for that entity in the `ui/actions.json` of the package that owns the column; `module pack` refuses any other, including an action a bridge adds to the host's entity. `E` guards only the direct API path: an action with `E` that calls `update()` on the state flag can still post, so guard that inside its `execute:` (check the role or state and `error()`).
+- **A `Q` column over a register without a stamped journal.** The balance on a date is the state less the later movements, so the journal needs `journalDate` and `journalDirection`; install refuses the column otherwise.
 - **Missing or unlocked `dateField`.** Required once the register has `journalDate` or `period`, and it must be in `lockedFields`.
 - **Key over dimensions.** The journal, a subordinate `info` register's records and an `autoCreate` state table are written by the platform. Each needs **one** surrogate primary key of type `bigint` (`identity`/`cuid`) or `uuid`. A key over dimensions, a multi-column key, a text key and `int4` are refused.
 - **State column narrower than the journal column.** It must hold the journal's value exactly, or unposting cannot take back what posting added.

package/skills/dforge-mcp-author/references/reports.md

@@ -391,7 +391,7 @@ Each entry becomes one attachment row, and the report gains a toolbar entry on t
 | Rule | Detail |
 |---|---|
 | `entityCd` | Qualified `module.entity` for anything outside this module, and that module must be a **declared dependency**. |
-| Source columns | The entity PK, a reference (`R`) column, or a bounded scalar (number, date/datetime, bool, dropdown/radio/flags code). `text`, `json`, `file`/`image` are rejected. |
+| Source columns | The entity PK, a reference (`R`) column, or a bounded scalar (number, date/datetime, bool, dropdown/radio/flags code). `text`, `json`, `file`/`image` are rejected, and so is a set (`S`), formula (`F`) or query (`Q`) column: it holds no value of its own. |
 | Types | Source and target must be compatible; only `lookup`↔`number` and `date`↔`datetime` widen. A names-only match like `{ "customer_id": "created_date" }` is an error, not a runtime surprise. |
 | One per pair | One attachment per (entity, report). Two entries for the same entity overwrite each other. |
 | Unmapped params | Keep their normal behaviour — default value, or prompt the user. |