@lotics/cli 0.207.0 → 0.208.0

package/dist/src/cli.js

@@ -15807,12 +15807,12 @@ var LoticsClient = class {
     const disposition = response.headers.get("content-disposition") ?? "";
     const originalFilename = parseContentDispositionFilename(disposition) ?? fileId;
     const buffer = Buffer.from(await response.arrayBuffer());
-    const { dir, named } = destination === void 0 ? { dir: process.cwd() } : "file" in destination ? {
+    const { dir, named: named2 } = destination === void 0 ? { dir: process.cwd() } : "file" in destination ? {
       dir: path2.dirname(path2.resolve(destination.file)),
       named: path2.basename(destination.file)
     } : { dir: path2.resolve(destination.dir) };
     await fs2.promises.mkdir(dir, { recursive: true });
-    const filename = named ?? findAvailableFilename(dir, originalFilename, options?.reserved);
+    const filename = named2 ?? findAvailableFilename(dir, originalFilename, options?.reserved);
     const absolutePath = path2.join(dir, filename);
     await fs2.promises.writeFile(absolutePath, buffer);
     return { path: absolutePath, filename, stored_filename: originalFilename };
@@ -33624,8 +33624,8 @@ function conditionIssues(node, path23, fieldMap) {
     return [`${path23}: a button field holds no data and cannot be filtered.`];
   }
   if (typeof filterType !== "string" || !VALID_FILTER_TYPES.includes(filterType)) {
-    const named = fieldMap && filterType !== obj.type ? `'${String(filterType)}' (resolved from field '${obj.field_key}')` : `'${String(obj.type)}'`;
-    return [`${path23}: invalid filter type ${named}. Valid: ${VALID_FILTER_TYPES.join(", ")}`];
+    const named2 = fieldMap && filterType !== obj.type ? `'${String(filterType)}' (resolved from field '${obj.field_key}')` : `'${String(obj.type)}'`;
+    return [`${path23}: invalid filter type ${named2}. Valid: ${VALID_FILTER_TYPES.join(", ")}`];
   }
   const validOps = VALID_OPERATORS[filterType];
   if (typeof obj.operator !== "string" || !validOps.includes(obj.operator)) {
@@ -36941,6 +36941,10 @@ var contractFieldSchema = zod_default.discriminatedUnion("type", [
   contractLookupFieldSchema,
   contractAutonumberFieldSchema
 ]);
+function fieldHoldsSeveral(field) {
+  if (field.type === "select") return field.multi === true;
+  return field.type === "select_record_link" && field.cardinality !== "one";
+}
 var contractViewSchema = zod_default.object({
   alias: contractAliasSchema.describe("Stable view alias, unique within the entity"),
   label: zod_default.string().min(1).describe("Display name of the view"),
@@ -37473,8 +37477,8 @@ function checkOutputRefs(output, path23, entityAliases, optionAliases, fieldAlia
     checkOutputRefs(output.items, `${path23}[]`, entityAliases, optionAliases, fieldAliases, errors);
   }
 }
-function checkSourceLinks(source, path23, parentEntity, fieldByEntity, errors) {
-  const recur = (child) => checkSourceLinks(child, path23, parentEntity, fieldByEntity, errors);
+function checkSourceLinks(source, path23, parentEntity2, fieldByEntity, errors) {
+  const recur = (child) => checkSourceLinks(child, path23, parentEntity2, fieldByEntity, errors);
   if (typeof source === "string") return;
   if ("eq" in source) return source.eq.forEach(recur);
   if ("neq" in source) return source.neq.forEach(recur);
@@ -37484,7 +37488,7 @@ function checkSourceLinks(source, path23, parentEntity, fieldByEntity, errors) {
   if ("concat" in source) return source.concat.forEach(recur);
   if (!("link" in source) && !("link_agg" in source)) return;
   const reach = "link" in source ? source.link : source.link_agg;
-  if (parentEntity === null) {
+  if (parentEntity2 === null) {
     errors.push({
       severity: "error",
       path: path23,
@@ -37492,14 +37496,14 @@ function checkSourceLinks(source, path23, parentEntity, fieldByEntity, errors) {
     });
     return;
   }
-  const parentFields = fieldByEntity.get(parentEntity);
+  const parentFields = fieldByEntity.get(parentEntity2);
   if (parentFields === void 0) return;
   const sourceField = parentFields.get(reach.source);
   if (sourceField === void 0) {
     errors.push({
       severity: "error",
       path: path23,
-      message: `link source "${reach.source}" is not a field on entity "${parentEntity}"`
+      message: `link source "${reach.source}" is not a field on entity "${parentEntity2}"`
     });
     return;
   }
@@ -37507,7 +37511,7 @@ function checkSourceLinks(source, path23, parentEntity, fieldByEntity, errors) {
     errors.push({
       severity: "error",
       path: path23,
-      message: `link source "${reach.source}" on entity "${parentEntity}" is a ${sourceField.type} field, not select_record_link`
+      message: `link source "${reach.source}" on entity "${parentEntity2}" is a ${sourceField.type} field, not select_record_link`
     });
     return;
   }
@@ -38265,8 +38269,11 @@ function resolvedFieldType(field, entity, entities, hops = 0) {
 }
 var ANSWER_KEYS = ["true", "false"];
 var requiredBySchema = zod_default.object({
+  from: zod_default.enum(["own", "parent"]).optional().describe(
+    `WHOSE field decides it, which the set's own shape settles: a multi-select holds the whole set, so "own" (the default, this entity's field); a single select is one entry per row, so "parent" \u2014 the record these rows hang under, reached through this entity's \`parent\` link. The other way round is refused`
+  ),
   field: contractAliasSchema.describe(
-    "The field on the same entity whose value decides which entries of this set are required \u2014 a single select, or a yes/no the row answers itself"
+    "The field whose value decides which entries of this set are required \u2014 a single select, or a yes/no answered on that row"
   ),
   options: zod_default.record(contractAliasSchema, zod_default.array(contractAliasSchema)).describe(
     `That field's option alias \u2014 or "true"/"false" where it is a yes/no \u2014 \u2192 the option aliases of THIS set required under it. A value with no entry is omitted, not empty.`
@@ -38285,14 +38292,19 @@ var fieldRoleDeclSchema = zod_default.object({
     'With against: what that limit IS. "fill" (the default) is a WHOLE the level is a share of \u2014 6 of 8 lines shipped. "threshold" is an alarm the level stays one side of \u2014 a reorder minimum, a margin floor \u2014 and every reading on the safe side is inside it, so there is no share to draw'
   ),
   outcomes: zod_default.array(contractAliasSchema).optional().describe("For a lifecycle: the options that END the flow \u2014 a row in one has arrived, not advanced"),
+  due: zod_default.literal(true).optional().describe(
+    "For a when: this date is a DEADLINE the row counts down to, and a row past it is late. Absent, it is the plain day it is \u2014 the day a lead arrived is neither early nor late"
+  ),
   until: contractAliasSchema.optional().describe(
-    "For a when: the option of this entity's lifecycle the countdown STOPS at \u2014 at or past that stage, and at every outcome, the date is drawn plain"
+    "For a when or an obligation: the option of this entity's lifecycle the countdown STOPS at \u2014 at or past that stage, and at every outcome, the date is drawn plain. On a when it also says the date is a deadline"
   ),
   signed_by: contractAliasSchema.optional().describe("For an amount: the select on the same entity that says which direction it moved"),
   outflow: zod_default.array(contractAliasSchema).optional().describe("With signed_by: the options of that select that spend \u2014 the amount reads negative under them"),
   required_by: requiredBySchema.optional().describe("For an expected_set: the select whose value decides which entries a row owes"),
   label: zod_default.string().min(1).optional().describe("For an obligation: what is OWED, as the reader says it \u2014 absent, the date field's own label"),
-  satisfied_by: contractAliasSchema.optional().describe("For an obligation: the field on the same entity that CLOSES it \u2014 the date it was done, or the file that proves it")
+  satisfied_by: contractAliasSchema.optional().describe(
+    "For an obligation: the field on the same entity that CLOSES it \u2014 the date it was done, or the file that proves it. Where nothing is stamped, `until` names the stage the record stops owing it at instead"
+  )
 }).strict();
 var fieldRolesSchema = zod_default.record(
   contractAliasSchema,
@@ -38301,6 +38313,14 @@ var fieldRolesSchema = zod_default.record(
     zod_default.preprocess((value) => typeof value === "string" ? { role: value } : value, fieldRoleDeclSchema).nullable()
   )
 );
+function countsDown(decl) {
+  if (decl?.role === "obligation") return true;
+  return decl?.role === "when" && (decl.due === true || decl.until !== void 0);
+}
+function parentEntity(entity, entities, roles) {
+  const link = entity.fields.find((field) => roleOf(roles, entity.alias, field.alias)?.role === "parent");
+  return link === void 0 ? void 0 : linkTarget(entity, entities, link.alias);
+}
 function roleOf(roles, entity, field) {
   if (!Object.hasOwn(roles, entity)) return void 0;
   const fields = roles[entity];
@@ -38349,9 +38369,10 @@ function checkFieldRoles(entities, roles) {
       errors.push(...checkCurrencyOptions(decl, field, path23));
       errors.push(...checkOutcomes(decl, field, path23));
       errors.push(...checkUntil(decl, entity, roles, path23));
+      errors.push(...checkDue(decl, path23));
       errors.push(...checkSlot(decl, field, path23));
       errors.push(...checkSign(decl, fieldByAlias, entityAlias, path23));
-      errors.push(...checkRequiredBy(decl, field, fieldByAlias, entity, entities, path23));
+      errors.push(...checkRequiredBy(decl, field, entity, entities, roles, path23));
       errors.push(...checkObligation(decl, fieldAlias, fieldByAlias, entityAlias, path23));
       errors.push(...checkCounts(decl, field, entity, entities, path23));
       if (decl.reading !== void 0 && (decl.role !== "measure" || decl.against === void 0)) {
@@ -38509,17 +38530,40 @@ function requiredByReads(condition, entity, entities) {
   if (condition.type === "select") return condition.multi === true ? void 0 : "option";
   return resolvedFieldType(condition, entity, entities) === "boolean" ? "answer" : void 0;
 }
-function checkRequiredBy(decl, field, fieldByAlias, entity, entities, path23) {
+function requiredByFrom(field) {
+  return field.type === "select" && field.multi !== true ? "parent" : "own";
+}
+function checkRequiredBy(decl, field, entity, entities, roles, path23) {
   const requiredBy = decl.required_by;
   if (requiredBy === void 0) return [];
   if (decl.role !== "expected_set") {
     return [{ severity: "error", path: path23, message: `required_by belongs to an expected_set \u2014 this role is "${decl.role}"` }];
   }
-  const condition = fieldByAlias.get(requiredBy.field);
+  const from = requiredByFrom(field);
+  if ((requiredBy.from ?? "own") !== from) {
+    return [
+      {
+        severity: "error",
+        path: path23,
+        message: from === "parent" ? `required_by on "${field.alias}" reads this row's own column \u2014 one row carries one entry of this set, so which entries are owed is stated by the record they hang under: from: "parent"` : `required_by on "${field.alias}" reads the parent's column \u2014 this row carries the whole set, so the value deciding it is this row's own: drop from`
+      }
+    ];
+  }
+  const deciding = from === "parent" ? parentEntity(entity, entities, roles) : entity;
+  if (deciding === void 0) {
+    return [
+      {
+        severity: "error",
+        path: path23,
+        message: `required_by reads the parent's "${requiredBy.field}" \u2014 "${entity.alias}" declares no parent link to reach one through`
+      }
+    ];
+  }
+  const condition = deciding.fields.find((candidate) => candidate.alias === requiredBy.field);
   if (condition === void 0) {
-    return [{ severity: "error", path: path23, message: `required_by names "${requiredBy.field}", which is not a field of "${entity.alias}"` }];
+    return [{ severity: "error", path: path23, message: `required_by names "${requiredBy.field}", which is not a field of "${deciding.alias}"` }];
   }
-  const reads = requiredByReads(condition, entity, entities);
+  const reads = requiredByReads(condition, deciding, entities);
   if (reads === void 0) {
     return [
       {
@@ -38564,11 +38608,12 @@ function checkObligation(decl, fieldAlias, fieldByAlias, entityAlias, path23) {
     return [{ severity: "error", path: path23, message: `label and satisfied_by belong to an obligation \u2014 this role is "${decl.role}"` }];
   }
   if (decl.satisfied_by === void 0) {
+    if (decl.until !== void 0) return [];
     return [
       {
         severity: "error",
         path: path23,
-        message: `an obligation names what CLOSES it \u2014 satisfied_by, the date it was done or the file that proves it; without one every obligation ever met stays on the desk`
+        message: `an obligation names what ENDS it \u2014 satisfied_by, the date it was done or the file that proves it, or until, the stage the record stops owing it at; without one every obligation ever met stays on the desk`
       }
     ];
   }
@@ -38618,8 +38663,8 @@ function checkOutcomes(decl, field, path23) {
 }
 function checkUntil(decl, entity, roles, path23) {
   if (decl.until === void 0) return [];
-  if (decl.role !== "when") {
-    return [{ severity: "error", path: path23, message: `until belongs to a when \u2014 this role is "${decl.role}"` }];
+  if (decl.role !== "when" && decl.role !== "obligation") {
+    return [{ severity: "error", path: path23, message: `until belongs to a when or an obligation \u2014 this role is "${decl.role}"` }];
   }
   const lifecycle = entity.fields.find((field) => roleOf(roles, entity.alias, field.alias)?.role === "lifecycle");
   if (lifecycle === void 0) {
@@ -38630,6 +38675,16 @@ function checkUntil(decl, entity, roles, path23) {
   }
   return [];
 }
+function checkDue(decl, path23) {
+  if (decl.due === void 0 || decl.role === "when") return [];
+  return [
+    {
+      severity: "error",
+      path: path23,
+      message: decl.role === "obligation" ? `due marks a when as a deadline \u2014 an obligation is a day something is OWED by and already counts down` : `due marks a when as a deadline \u2014 this role is "${decl.role}", which holds no day to be late against`
+    }
+  ];
+}
 function checkSlot(decl, field, path23) {
   if (decl.role !== "slot" || field.type !== "date") return [];
   if (field.format === "datetime" || field.format === "datetime_range") return [];
@@ -38908,7 +38963,13 @@ var SHAPE_REGISTRY = {
     slots: {
       // THE ROW IS A GROUP BY — a party, an option or a period — and every
       // column beside it is an aggregate over the set behind it.
-      subject: slot(["category", "party", "when"], true, { subject: true }),
+      //
+      // SEVERAL OF THEM ARE A HIERARCHY. "What is each customer worth" and
+      // "which of their projects" are one question asked at two depths, and a
+      // register per depth is the same figures folded twice with nothing saying
+      // they are the same money — so the slot takes the tiers in order and the
+      // reader walks down them.
+      subject: slot(["category", "party", "when"], true, { subject: true, tiers: true }),
       amount: slot("amount"),
       measure: slot("measure"),
       // WHAT ONE ROW BEHIND A FIGURE IS CALLED. The set is what a group opens
@@ -39034,6 +39095,16 @@ var SHAPE_REGISTRY = {
 };
 var SHAPE_NAMES = Object.keys(SHAPE_REGISTRY);
 var CUSTOM_SHAPE = "custom";
+function slotTakes(shape, name) {
+  if (shape === CUSTOM_SHAPE) return [];
+  const slots = SHAPE_REGISTRY[shape].slots;
+  return slots[name]?.roles ?? [];
+}
+function slotTakesTiers(shape, name) {
+  if (shape === CUSTOM_SHAPE) return false;
+  const slots = SHAPE_REGISTRY[shape].slots;
+  return slots[name]?.tiers === true;
+}
 function shapeDrawsBand(shape, band) {
   if (shape === CUSTOM_SHAPE) return true;
   const declared = SHAPE_REGISTRY[shape];
@@ -39072,16 +39143,25 @@ function shapeFansObligations(shape) {
   const declared = SHAPE_REGISTRY[shape];
   return declared.obligations === true;
 }
+var CONTEXT_COLUMNS = 4;
+var SEATED_COLUMNS = 6;
+function shapeDrawsColumns(shape) {
+  return shapeListsRows(shape) && shapeRowsAreTable(shape) && !shapeFansObligations(shape);
+}
+function shapesDrawingColumns() {
+  return SHAPE_NAMES.filter(shapeDrawsColumns);
+}
 function registerReadsForward(shape) {
   if (shape === CUSTOM_SHAPE) return false;
   const declared = SHAPE_REGISTRY[shape];
   return declared.forward === true;
 }
-var PRESENTATION_LEADS = ["mark", "picture", "figure", "none"];
+var PRESENTATION_LEADS = ["mark", "picture", "paper", "figure", "none"];
 var PRESENTATION_DENSITIES = ["roomy", "dense"];
 var SCREEN_LAYOUTS = ["table", "list", "cards", "gallery", "board", "calendar", "timeline", "gantt"];
-function layoutsFor(roles) {
-  const held = new Set(roles);
+function layoutsFor(drawn) {
+  const columns = [...drawn];
+  const held = new Set(columns.map((column) => column.role));
   const afforded = /* @__PURE__ */ new Set(["table", "list"]);
   if (held.has("mark")) {
     afforded.add("cards");
@@ -39091,7 +39171,7 @@ function layoutsFor(roles) {
   if (held.has("when")) {
     afforded.add("calendar");
     afforded.add("timeline");
-    if (held.has("measure")) afforded.add("gantt");
+    if (columns.some((column) => column.role === "measure" && column.counts === "days")) afforded.add("gantt");
   }
   return SCREEN_LAYOUTS.filter((layout) => afforded.has(layout));
 }
@@ -39127,7 +39207,17 @@ var contractPresentationSchema = zod_default.object({
    * columns to be and a calendar over rows with no date draws every row on no
    * day — so a layout the rows cannot answer is refused with the set they can.
    */
-  layout: screenLayoutSchema.optional().describe("How the rows are arranged \u2014 table, list, cards, gallery, board, calendar, timeline, gantt; absent, a table")
+  layout: screenLayoutSchema.optional().describe("How the rows are arranged \u2014 table, list, cards, gallery, board, calendar, timeline, gantt; absent, a table"),
+  /**
+   * WHERE EACH BAR ENDS, where the rows state the day rather than the span.
+   *
+   * A chart needs a length, and a business records one two ways: a project
+   * says how many days it runs, a lease says the day it is up. The days are
+   * what AFFORDS the chart ({@link layoutsFor}); this is the column the bar is
+   * drawn to when the row states one, which is the more exact answer wherever
+   * a row has both.
+   */
+  until: contractAliasSchema.optional().describe("For a gantt: the date field each bar is drawn TO; absent, the bar runs for the days its measure counts")
 }).strict();
 function leadRefusal(shape, drawn, lead) {
   if (lead === "none") return void 0;
@@ -39136,7 +39226,10 @@ function leadRefusal(shape, drawn, lead) {
   }
   if (!drawn.has("mark")) return `leads with the ${lead}, and no column of these rows is drawn as their mark`;
   if (shapeMarksParty(shape) === (lead === "mark")) return void 0;
-  return lead === "picture" ? "leads with the picture, and these rows are parties \u2014 a party wears its own mark, which carries the picture where there is one" : "leads with the mark, and these rows are things \u2014 a thing has no initials to stand in for a picture, so it leads with `picture`";
+  if (lead === "mark") {
+    return "leads with the mark, and these rows are things \u2014 a thing has no initials to stand in for a picture, so it leads with `picture`";
+  }
+  return `leads with the ${lead}, and these rows are parties \u2014 a party wears its own mark, which carries the picture where there is one`;
 }
 var AGEING_BUCKETS = [30, 60, 90];
 var contractActPlaceSchema = zod_default.literal("cta").describe("Draw this act ON the row rather than in its \u22EF menu \u2014 at most one per screen");
@@ -39154,7 +39247,18 @@ var contractAgentActSchema = zod_default.strictObject({
   fills: zod_default.array(contractAliasSchema).min(1).describe("The fields of this entity the run may write \u2014 reviewed by the reader, then written as ONE update"),
   place: contractActPlaceSchema.optional()
 });
-var contractActSchema = zod_default.union([contractAgentActSchema, contractTemplateActSchema], {
+var RECORD_INPUT = "record";
+var contractWorkflowActSchema = zod_default.strictObject({
+  kind: zod_default.literal("workflow"),
+  label: zod_default.string().min(1).describe("The act's own words, as the reader reads them in the menu"),
+  workflow: contractAliasSchema.describe("A workflow alias the APP declares and binds (package.json#lotics.workflows)"),
+  inputs: zod_default.record(
+    contractAliasSchema,
+    contractAliasSchema.describe('A field of this entity, or "record" \u2014 which names the row itself before any field of that alias')
+  ).describe("What the run is handed: the workflow's own input name \u2192 the value on the row it is pressed on"),
+  place: contractActPlaceSchema.optional()
+});
+var contractActSchema = zod_default.union([contractAgentActSchema, contractWorkflowActSchema, contractTemplateActSchema], {
   error: (issue2) => typeof issue2.input === "object" && issue2.input !== null && "screen" in issue2.input ? "a row act opens this app's record or another app" : void 0
 });
 var contractImportActSchema = zod_default.strictObject({
@@ -39166,6 +39270,7 @@ var contractImportActSchema = zod_default.strictObject({
 });
 var contractSlotSchema = zod_default.union([
   contractAliasSchema,
+  zod_default.array(contractAliasSchema).min(2).describe("The tiers this slot folds by, outermost first \u2014 for a slot that takes a hierarchy"),
   zod_default.strictObject({
     field: contractAliasSchema.describe("The field this slot takes"),
     quick: zod_default.literal(true).describe("Draw the column as its OWN editor \u2014 for a decision the reader makes from the row alone"),
@@ -39214,6 +39319,11 @@ var contractPredicateSchema = zod_default.strictObject({
     "An `and` group of plain conditions over the entity's OWN fields, each `field_key` a field alias \u2014 the rows this predicate keeps"
   )
 });
+var contractSectionDrawSchema = zod_default.strictObject({
+  draw: zod_default.literal("worksheet").describe("Priced lines the reader works down in place, each part footed and the sheet closing under them"),
+  cost: contractAliasSchema.optional().describe("The child's field holding what a line COSTS \u2014 the base the margin is taken against"),
+  sell: contractAliasSchema.optional().describe("The child's field holding what it SELLS for \u2014 the figure the sheet is read for")
+}).describe("How a section of this screen's record is drawn, where its rows are priced lines rather than a register");
 var contractLensSchema = zod_default.strictObject({
   label: zod_default.string().min(1).describe("What the chip is called"),
   predicates: zod_default.array(contractPredicateSchema).min(1).describe("The sets it offers, in this order")
@@ -39231,6 +39341,12 @@ var contractScreenSchema = zod_default.object({
   tabs: contractAliasSchema.nullable().optional().describe("A select field on the entity whose options are the tab strip; null for none; absent, the shape decides"),
   slots: zod_default.record(zod_default.string(), contractSlotSchema).optional().describe("Slot \u2192 the field that fills it, where roles alone cannot decide"),
   roles: zod_default.record(zod_default.string(), fieldRoleSchema).optional().describe(`For "${CUSTOM_SHAPE}" only: slot \u2192 the role that fills it`),
+  // THE SLOTS ARE THE ROW'S ANSWER; THESE ARE ITS CONTEXT — the facts a reader
+  // needs beside that answer and the shape has no slot for. Drawn after the
+  // slots and shed before any of them, so a phone keeps the answer.
+  columns: zod_default.array(contractAliasSchema).min(1).max(CONTEXT_COLUMNS).optional().describe(
+    `Extra fields drawn after the slots, in this order \u2014 at most ${CONTEXT_COLUMNS}, each holding ONE value; never a files field, and never a field a slot already draws`
+  ),
   // Absent IS true: a desk that can only be read is the exception, so the file
   // says that and says nothing in the ordinary case.
   writes: zod_default.boolean().optional().describe("false makes this screen's record read-only \u2014 no field editor, no stage advance; absent, it is operable"),
@@ -39256,6 +39372,7 @@ var contractScreenSchema = zod_default.object({
   section_acts: zod_default.record(contractAliasSchema, zod_default.array(contractActSchema).min(1)).optional().describe(
     "Acts on the RECORD's own sections, keyed by the alias each section is derived from \u2014 a field alias (its progress, its prose, its set, its charge, its files) or a child entity's alias (its register, its desk, its run, its thread)"
   ),
+  sections: zod_default.record(contractAliasSchema, contractSectionDrawSchema).optional().describe("How a section of the RECORD is DRAWN, keyed by the child entity alias its register is derived from"),
   filters: zod_default.array(zod_default.union([contractAliasSchema, contractLensSchema])).min(1).optional().describe(
     "The chips beside the search \u2014 a single-select field's alias, or a lens this model states as predicates over the entity's fields"
   ),
@@ -39276,7 +39393,11 @@ var contractScreenSchema = zod_default.object({
       amount: contractAliasSchema.describe("The figure each bucket adds up \u2014 what is still owed on the row"),
       due: contractAliasSchema.describe("The date the row was owed by; a row is bucketed by how far past it is"),
       buckets: zod_default.array(zod_default.number().int().positive()).min(1).optional().describe(`The bucket edges, in days past due, ascending \u2014 absent, ${AGEING_BUCKETS.join(", ")}`)
-    }).strict().optional().describe("How old the money over this register is \u2014 the amount split by how many days past its date each row is")
+    }).strict().optional().describe("How old the money over this register is \u2014 the amount split by how many days past its date each row is"),
+    trend: zod_default.object({
+      field: contractAliasSchema.describe("The number this register adds up in each bucket of the window"),
+      direction: zod_default.enum(["up", "down"]).describe("Which way is GOOD \u2014 a book wants `up`, a backlog `down`; the arrow follows the change and the colour follows this")
+    }).strict().optional().describe("Which way this figure moved across the window the reader is reading \u2014 needs a `period` to be a window of")
   }).strict().optional().describe("What the rows in view come to, stated before or after their names"),
   period: contractAliasSchema.optional().describe("A date field on the entity the reader narrows the view by; absent, the view is every row"),
   presentation: contractPresentationSchema.optional().describe("How this screen and the record it opens are DRAWN, where the shape's own answer is not the one wanted")
@@ -39342,7 +39463,8 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
   const stated2 = (name) => {
     const clause = screen.slots?.[name];
     if (clause === void 0) return void 0;
-    return typeof clause === "string" ? { field: clause } : clause;
+    if (typeof clause === "string") return { field: clause };
+    return Array.isArray(clause) ? { field: clause[0], tiers: clause.slice(1) } : clause;
   };
   if (entity === void 0) return { type: "invalid", findings };
   const record2 = screen.record ?? recordDoor(screen.shape, entity, roles);
@@ -39356,14 +39478,14 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
   const boundBy = /* @__PURE__ */ new Map();
   for (const [name, spec] of Object.entries(slotSpec)) {
     const clause = stated2(name);
-    const named = clause?.field;
+    const named2 = clause?.field;
     const takes = spec.roles.map((role) => `"${role}"`).join(" or a ");
     let field = null;
     let filled = spec.roles[0];
-    if (named !== void 0) {
-      const candidate = fieldByAlias.get(named);
+    if (named2 !== void 0) {
+      const candidate = fieldByAlias.get(named2);
       if (candidate === void 0) {
-        findings.push({ severity: "error", path: `${path23}.slots.${name}`, message: `names "${named}", which is not a field of entity "${entity.alias}"` });
+        findings.push({ severity: "error", path: `${path23}.slots.${name}`, message: `names "${named2}", which is not a field of entity "${entity.alias}"` });
         continue;
       }
       const role = roleOfField(candidate);
@@ -39371,7 +39493,7 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
         findings.push({
           severity: "error",
           path: `${path23}.slots.${name}`,
-          message: `names "${named}", whose role is ${role === void 0 ? "not declared" : `"${role}"`} \u2014 this slot takes a ${takes} field; declare the role in field_roles`
+          message: `names "${named2}", whose role is ${role === void 0 ? "not declared" : `"${role}"`} \u2014 this slot takes a ${takes} field; declare the role in field_roles`
         });
         continue;
       }
@@ -39388,7 +39510,7 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
           }
           boundBy.set(candidate.alias, name);
         }
-        slots.push({ name, role: spec.roles[0], field: candidates2[0], also: candidates2.slice(1), ambiguous: [] });
+        slots.push({ name, role: spec.roles[0], field: candidates2[0], also: candidates2.slice(1), tiers: [], ambiguous: [] });
         continue;
       }
       if (candidates2.length > 1) {
@@ -39400,7 +39522,7 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
           });
           continue;
         }
-        slots.push({ name, role: filled, field: null, also: [], ambiguous: candidates2.map((f) => f.alias) });
+        slots.push({ name, role: filled, field: null, also: [], tiers: [], ambiguous: candidates2.map((f) => f.alias) });
         continue;
       }
       if (candidates2.length === 0 && spec.required) {
@@ -39418,6 +39540,30 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
       }
       boundBy.set(field.alias, name);
     }
+    const tiers = [];
+    if (clause?.tiers !== void 0) {
+      if (!slotTakesTiers(screen.shape, name)) {
+        findings.push({ severity: "error", path: `${path23}.slots.${name}`, message: `names several fields, and "${shapeLabel}" folds its ${name} by one \u2014 a list is for a slot that takes a hierarchy` });
+        continue;
+      }
+      const refused = clause.tiers.flatMap((alias) => {
+        const candidate = fieldByAlias.get(alias);
+        if (candidate === void 0) return [`"${alias}", which is not a field of entity "${entity.alias}"`];
+        const role = roleOfField(candidate);
+        if (role === void 0 || !spec.roles.includes(role)) {
+          return [`"${alias}", whose role is ${role === void 0 ? "not declared" : `"${role}"`} \u2014 every tier takes a ${takes} field`];
+        }
+        const other = boundBy.get(alias);
+        if (other !== void 0) return [`"${alias}", which already fills ${other} \u2014 a field fills one slot`];
+        boundBy.set(alias, name);
+        tiers.push(candidate);
+        return [];
+      });
+      if (refused.length > 0) {
+        findings.push({ severity: "error", path: `${path23}.slots.${name}`, message: `folds by ${refused.join("; and by ")}` });
+        continue;
+      }
+    }
     if (clause?.quick === true) {
       const refused = quickRefusal(filled, clause.order) ?? (screen.writes === false ? "is `quick` on a screen that states `writes: false` \u2014 a reader who may operate nothing has no decision to take from the row" : void 0);
       if (refused !== void 0) {
@@ -39430,6 +39576,7 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
       role: filled,
       field,
       also: [],
+      tiers,
       ambiguous: [],
       ...clause?.quick === true ? { quick: true } : {},
       ...clause?.order === void 0 ? {} : { order: clause.order }
@@ -39448,6 +39595,7 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
       tabs = field;
     }
   }
+  const columns = resolveColumns(path23, screen, entity, [...entityByAlias.values()], fieldByAlias, boundBy, shapeLabel, findings);
   const acts = resolveActs(path23, screen, entity, entityByAlias, rules, fieldByAlias, templates, findings);
   const sectionActs2 = resolveSectionActs(path23, screen, entity, fieldByAlias, templates, findings);
   const summary = resolveSummary(path23, screen, entity, [...entityByAlias.values()], roles, slots, findings);
@@ -39474,6 +39622,7 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
       tabs,
       slots,
       outcomes,
+      columns,
       acts,
       sectionActs: sectionActs2,
       summary,
@@ -39485,6 +39634,53 @@ function resolveScreen(app, entityByAlias, roles, templates = [], rules = {}) {
     }
   };
 }
+function resolveColumns(path23, screen, entity, entities, fieldByAlias, boundBy, shapeLabel, findings) {
+  const named2 = screen.columns ?? [];
+  if (named2.length === 0) return [];
+  const at2 = `${path23}.columns`;
+  if (!shapeDrawsColumns(screen.shape)) {
+    findings.push({
+      severity: "error",
+      path: at2,
+      message: `names columns, and a ${shapeLabel} does not stand this entity's records in a table \u2014 the shapes that draw columns are ${shapesDrawingColumns().join(", ")}`
+    });
+    return [];
+  }
+  const layout = screen.presentation?.layout;
+  if (layout !== void 0 && layout !== "table") {
+    findings.push({ severity: "error", path: at2, message: `names columns beside \`layout: "${layout}"\`, which draws the rows with a device of its own instead of the register's columns` });
+    return [];
+  }
+  const drawn = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const alias of named2) {
+    const field = fieldByAlias.get(alias);
+    if (field === void 0) {
+      findings.push({ severity: "error", path: at2, message: `names "${alias}", which is not a field of entity "${entity.alias}"` });
+      continue;
+    }
+    const slot2 = boundBy.get(alias);
+    if (slot2 !== void 0) {
+      findings.push({ severity: "error", path: at2, message: `names "${alias}", which already fills ${slot2} \u2014 a column states what the slots do not` });
+      continue;
+    }
+    if (seen.has(alias)) {
+      findings.push({ severity: "error", path: at2, message: `names "${alias}" twice` });
+      continue;
+    }
+    if (resolvedFieldType(field, entity, entities) === "files") {
+      findings.push({ severity: "error", path: at2, message: `names "${alias}", a files field \u2014 files are READ, so they are a section of the record rather than a column beside it` });
+      continue;
+    }
+    if (fieldHoldsSeveral(field)) {
+      findings.push({ severity: "error", path: at2, message: `names "${alias}", which holds SEVERAL values \u2014 a column of comma lists cannot be compared down its own column` });
+      continue;
+    }
+    seen.add(alias);
+    drawn.push(field);
+  }
+  return drawn;
+}
 function resolveScope(app, entity, entityByAlias, findings) {
   const declared = app.scope;
   if (declared === void 0) return null;
@@ -39573,9 +39769,13 @@ function resolveObligations(path23, screen, entity, shapeLabel, roles, fieldByAl
   if (!shapeFansObligations(screen.shape)) return [];
   const found = entity.fields.flatMap((field) => {
     const decl = roleOf(roles, entity.alias, field.alias);
-    if (decl?.role !== "obligation" || decl.satisfied_by === void 0) return [];
+    if (decl?.role !== "obligation") return [];
+    const label = decl.label ?? field.label;
+    if (decl.satisfied_by === void 0) {
+      return recordUntil(entity, roles, field) === void 0 ? [] : [{ field, label }];
+    }
     const satisfiedBy = fieldByAlias.get(decl.satisfied_by);
-    return satisfiedBy === void 0 ? [] : [{ field, label: decl.label ?? field.label, satisfiedBy }];
+    return satisfiedBy === void 0 ? [] : [{ field, label, satisfiedBy }];
   });
   if (found.length === 0) {
     findings.push({
@@ -39608,20 +39808,33 @@ function resolveFactGroups(path23, screen, entity, fieldByAlias, findings) {
     })
   }));
 }
+function actDuplicates(acts, at2, menu, findings) {
+  const refuse = (dups, said) => {
+    for (const dup of dups) findings.push({ severity: "error", path: at2, message: said(dup) });
+  };
+  refuse(
+    findDuplicates(acts.map((act) => act.label)),
+    (dup) => `two acts are both called "${dup}" \u2014 ${menu} reads one line per act`
+  );
+  refuse(
+    findDuplicates(acts.flatMap((act) => "kind" in act ? [] : [act.template])),
+    (dup) => `two acts both generate "${dup}" \u2014 one template is one paper, however it is worded`
+  );
+  refuse(
+    findDuplicates(acts.flatMap((act) => "kind" in act && act.kind === "agent" ? [act.agent] : [])),
+    (dup) => `two acts both run "${dup}" \u2014 one agent is one run, however it is worded`
+  );
+  refuse(
+    findDuplicates(acts.flatMap((act) => "kind" in act && act.kind === "workflow" ? [act.workflow] : [])),
+    (dup) => `two acts both hand off through "${dup}" \u2014 one workflow is one hand-off, however it is worded`
+  );
+}
 function resolveActs(path23, screen, entity, entityByAlias, rules, fieldByAlias, templates, findings) {
   const declared = screen.acts;
   if (declared === void 0) return { row: [], selection: [], record: [], export: null, import: null };
   const stated2 = declared.row ?? [];
   const at2 = `${path23}.acts.row`;
-  for (const dup of findDuplicates(stated2.map((act) => act.label))) {
-    findings.push({ severity: "error", path: at2, message: `two acts are both called "${dup}" \u2014 a row's menu reads one line per act` });
-  }
-  for (const dup of findDuplicates(stated2.flatMap((act) => "kind" in act ? [] : [act.template]))) {
-    findings.push({ severity: "error", path: at2, message: `two acts both generate "${dup}" \u2014 one template is one paper, however it is worded` });
-  }
-  for (const dup of findDuplicates(stated2.flatMap((act) => "kind" in act ? [act.agent] : []))) {
-    findings.push({ severity: "error", path: at2, message: `two acts both run "${dup}" \u2014 one agent is one run, however it is worded` });
-  }
+  actDuplicates(stated2, at2, "a row's menu", findings);
   for (const refusal of ctaRefusals(declared)) {
     findings.push({ severity: "error", path: `${path23}.acts.${refusal.reach}`, message: refusal.message });
   }
@@ -39704,9 +39917,7 @@ function resolveSectionActs(path23, screen, entity, fieldByAlias, templates, fin
   const resolved = /* @__PURE__ */ new Map();
   for (const [alias, acts] of Object.entries(screen.section_acts ?? {})) {
     const at2 = `${path23}.section_acts.${alias}`;
-    for (const dup of findDuplicates(acts.map((act) => act.label))) {
-      findings.push({ severity: "error", path: at2, message: `two acts are both called "${dup}" \u2014 a section's menu reads one line per act` });
-    }
+    actDuplicates(acts, at2, "a section's menu", findings);
     for (const act of acts) {
       if (act.place === "cta") {
         findings.push({
@@ -39724,15 +39935,7 @@ function resolveRecordActs(path23, screen, entity, fieldByAlias, templates, find
   const declared = screen.acts?.record;
   if (declared === void 0) return [];
   const at2 = `${path23}.acts.record`;
-  for (const dup of findDuplicates(declared.map((act) => act.label))) {
-    findings.push({ severity: "error", path: at2, message: `two acts are both called "${dup}" \u2014 the record's menu reads one line per act` });
-  }
-  for (const dup of findDuplicates(declared.flatMap((act) => "kind" in act ? [] : [act.template]))) {
-    findings.push({ severity: "error", path: at2, message: `two acts both generate "${dup}" \u2014 one template is one paper, however it is worded` });
-  }
-  for (const dup of findDuplicates(declared.flatMap((act) => "kind" in act ? [act.agent] : []))) {
-    findings.push({ severity: "error", path: at2, message: `two acts both run "${dup}" \u2014 one agent is one run, however it is worded` });
-  }
+  actDuplicates(declared, at2, "the record's menu", findings);
   for (const act of declared) {
     if (act.place === "cta") {
       findings.push({ severity: "error", path: at2, message: `"${act.label}" states \`place: "cta"\` \u2014 a record's acts are its header menu, and there is no row to draw a verb on` });
@@ -39752,6 +39955,10 @@ function resolveAct(act, at2, screen, entity, fieldByAlias, templates, findings)
     const template = resolveTemplateAct(act.template, templates, at2, findings);
     return template === void 0 ? [] : [{ kind: "template", label: act.label, ...place, template }];
   }
+  if (act.kind === "workflow") {
+    const inputs = resolveActInputs(act.inputs, at2, entity, fieldByAlias, findings);
+    return inputs === void 0 ? [] : [{ kind: "workflow", label: act.label, ...place, workflow: act.workflow, inputs }];
+  }
   if (screen.writes === false) {
     findings.push({
       severity: "error",
@@ -39777,6 +39984,31 @@ function resolveAct(act, at2, screen, entity, fieldByAlias, templates, findings)
   });
   return fills.length === 0 ? [] : [{ kind: "agent", label: act.label, ...place, agent: act.agent, fills }];
 }
+function resolveActInputs(declared, at2, entity, fieldByAlias, findings) {
+  const stated2 = Object.entries(declared);
+  if (stated2.length === 0) {
+    findings.push({ severity: "error", path: at2, message: `hands its workflow nothing \u2014 name the input the row is sent under, as \`{"<input>": "record"}\`` });
+    return void 0;
+  }
+  const inputs = [];
+  for (const [name, alias] of stated2) {
+    if (alias === RECORD_INPUT) {
+      inputs.push({ name, field: null });
+      continue;
+    }
+    const field = fieldByAlias.get(alias);
+    if (field === void 0) {
+      findings.push({ severity: "error", path: at2, message: `sends "${alias}", which is not a field of entity "${entity.alias}"` });
+      return void 0;
+    }
+    if (field.type === "files") {
+      findings.push({ severity: "error", path: at2, message: `sends "${alias}", a files column \u2014 an input takes a value, and the body reads the row's files off the row it is handed` });
+      return void 0;
+    }
+    inputs.push({ name, field });
+  }
+  return inputs;
+}
 function resolveSelectionActs(path23, screen, entity, fieldByAlias, templates, findings) {
   const declared = screen.acts?.selection;
   if (declared === void 0) return [];
@@ -39789,14 +40021,15 @@ function resolveSelectionActs(path23, screen, entity, fieldByAlias, templates, f
     });
     return [];
   }
-  for (const dup of findDuplicates(declared.map((act) => act.label))) {
-    findings.push({ severity: "error", path: at2, message: `two acts are both called "${dup}" \u2014 the selection bar reads one line per act` });
-  }
-  for (const dup of findDuplicates(declared.flatMap((act) => "kind" in act ? [] : [act.template]))) {
-    findings.push({ severity: "error", path: at2, message: `two acts both generate "${dup}" \u2014 one template is one paper, however it is worded` });
-  }
-  for (const dup of findDuplicates(declared.flatMap((act) => "kind" in act ? [act.agent] : []))) {
-    findings.push({ severity: "error", path: at2, message: `two acts both run "${dup}" \u2014 one agent is one run, however it is worded` });
+  actDuplicates(declared, at2, "the selection bar", findings);
+  for (const act of declared) {
+    if (!("kind" in act)) continue;
+    const verb = act.kind === "agent" ? `runs "${act.agent}"` : `hands the row to "${act.workflow}"`;
+    findings.push({
+      severity: "error",
+      path: at2,
+      message: `"${act.label}" ${verb}, which is about ONE row \u2014 the bar makes one paper from many, so a per-row verb belongs in the row's \u22EF`
+    });
   }
   return declared.flatMap((act, index) => resolveAct(act, `${at2}.${index}`, screen, entity, fieldByAlias, templates, findings));
 }
@@ -39837,7 +40070,7 @@ function resolveSummary(path23, screen, entity, entities, roles, slots, findings
   const declared = screen.summary;
   const fieldByAlias = new Map(entity.fields.map((field) => [field.alias, field]));
   if (declared === void 0) {
-    return { columnTotals: [], bandTotals: [], above: defaultAbove(screen, entity, entities, roles, slots), ageing: null };
+    return { columnTotals: [], bandTotals: [], above: defaultAbove(screen, entity, entities, roles, slots), ageing: null, trend: null };
   }
   const figures = (aliases, at2) => aliases.flatMap((alias) => {
     const field = fieldByAlias.get(alias);
@@ -39874,10 +40107,10 @@ function resolveSummary(path23, screen, entity, entities, roles, slots, findings
     });
     return false;
   };
-  const named = declared.totals === void 0 || !bandSaid("totals", `${path23}.summary.totals`) ? [] : figures(declared.totals, `${path23}.summary.totals`);
+  const named2 = declared.totals === void 0 || !bandSaid("totals", `${path23}.summary.totals`) ? [] : figures(declared.totals, `${path23}.summary.totals`);
   const drawn = new Set(slots.flatMap((slot2) => slot2.field === null ? [] : [slot2.field.alias]));
-  const columnTotals = named.filter((field) => drawn.has(field.alias));
-  const bandTotals = named.filter((field) => !drawn.has(field.alias));
+  const columnTotals = named2.filter((field) => drawn.has(field.alias));
+  const bandTotals = named2.filter((field) => !drawn.has(field.alias));
   if (screen.shape !== CUSTOM_SHAPE && columnTotals.length > 0) {
     findings.push({
       severity: "error",
@@ -39903,7 +40136,32 @@ function resolveSummary(path23, screen, entity, entities, roles, slots, findings
   };
   const above = declared.above === void 0 ? defaultAbove(screen, entity, entities, roles, slots) : !bandSaid("above", `${path23}.summary.above`) ? null : declared.above === "counts" ? "counts" : fanned(`${path23}.summary.above`) ? null : bandFigures(declared.above, `${path23}.summary.above`, screen, figures, findings);
   const ageing = declared.ageing !== void 0 && fanned(`${path23}.summary.ageing`) ? null : resolveAgeing(path23, declared.ageing, entity, entities, figures, bandSaid, findings);
-  return { columnTotals, bandTotals, above, ageing };
+  const trend = declared.trend !== void 0 && fanned(`${path23}.summary.trend`) ? null : resolveTrend(path23, declared.trend, screen, figures, bandSaid, findings);
+  return { columnTotals, bandTotals, above, ageing, trend };
+}
+function resolveTrend(path23, declared, screen, figures, bandSaid, findings) {
+  if (declared === void 0) return null;
+  const at2 = `${path23}.summary.trend`;
+  const already2 = shapePeriod(screen.shape);
+  if (already2 !== void 0) {
+    findings.push({
+      severity: "error",
+      path: at2,
+      message: already2 === "own" ? `a "${screen.shape}" draws its own series over its own period \u2014 a second reading of one window states the same movement twice` : `a "${screen.shape}" answers what is true NOW \u2014 it reads no window, so there is nothing for a movement to be across`
+    });
+    return null;
+  }
+  if (screen.period === void 0) {
+    findings.push({
+      severity: "error",
+      path: at2,
+      message: `reads "${declared.field}" across the window, and this screen states no \`period\` \u2014 there is no window to cut into buckets`
+    });
+    return null;
+  }
+  if (!bandSaid("above", at2)) return null;
+  const field = figures([declared.field], at2)[0];
+  return field === void 0 ? null : { field, direction: declared.direction };
 }
 function bandFigures(declared, at2, screen, figures, findings) {
   return declared.flatMap((one) => {
@@ -40098,13 +40356,17 @@ function mirrorsOwnOneLink(entity, child, link) {
   );
   return back.length === 1 && own.length === 1 && own[0].cardinality === "one";
 }
-function requiredSubset(entity, entities, roles, field) {
+function requiredSubset(entity, entities, roles, field, parent) {
   const requiredBy = roleOf(roles, entity.alias, field.alias)?.required_by;
   if (requiredBy === void 0) return void 0;
-  const condition = entity.fields.find((candidate) => candidate.alias === requiredBy.field);
+  const from = requiredByFrom(field);
+  if ((requiredBy.from ?? "own") !== from) return void 0;
+  const deciding = from === "parent" ? parentEntity(entity, entities, roles) : entity;
+  if (deciding === void 0 || from === "parent" && deciding.alias !== parent?.alias) return void 0;
+  const condition = deciding.fields.find((candidate) => candidate.alias === requiredBy.field);
   if (condition === void 0) return void 0;
-  const reads = requiredByReads(condition, entity, entities);
-  return reads === void 0 ? void 0 : { field: condition, reads, options: requiredBy.options };
+  const reads = requiredByReads(condition, deciding, entities);
+  return reads === void 0 ? void 0 : { field: condition, from, reads, options: requiredBy.options };
 }
 function owedRows(entity, roles, child, link) {
   for (const field of entity.fields) {
@@ -40154,8 +40416,17 @@ function childThread(child, roles, via) {
     ...awaiting === void 0 ? {} : { awaiting }
   };
 }
+function threadShortOf(child, roles) {
+  if (fieldsWithRole(child, roles, "identity").length > 0) return void 0;
+  if (!child.fields.some((field) => field.type === "text" && field.format === "markdown")) return void 0;
+  const missing = [
+    { name: 'a "party"', has: fieldsWithRole(child, roles, "party").length > 0 },
+    { name: 'a "when"', has: fieldsWithRole(child, roles, "when").length > 0 }
+  ].filter((one) => !one.has);
+  return missing.length === 1 ? missing[0].name : void 0;
+}
 function recordDeadline(entity, roles) {
-  return fieldsWithRole(entity, roles, "obligation")[0] ?? fieldsWithRole(entity, roles, "when")[0];
+  return fieldsWithRole(entity, roles, "obligation")[0] ?? fieldsWithRole(entity, roles, "when").find((field) => countsDown(roleOf(roles, entity.alias, field.alias)));
 }
 function fileFields(entity, roles) {
   const files = entity.fields.filter((field) => field.type === "files");
@@ -40169,9 +40440,9 @@ function filesVerdict(entity, roles, files) {
     (field) => field.type === "formula" && parseFieldRefTokens(field.formula.expression).some((ref) => piles.has(ref))
   );
 }
-function recordKey(entity, roles, named) {
+function recordKey(entity, roles, named2) {
   const role = (field) => roleOf(roles, entity.alias, field.alias)?.role;
-  const spare = entity.fields.filter((field) => field.alias !== named && role(field) !== "identity");
+  const spare = entity.fields.filter((field) => field.alias !== named2 && role(field) !== "identity");
   return spare.find((field) => role(field) === "parent") ?? spare.find((field) => role(field) === "reference") ?? spare.find((field) => field.type === "autonumber" && role(field) === void 0) ?? spare.find((field) => field.type === "formula" && formulaResultType(field.formula) === "text" && role(field) === void 0);
 }
 function recordHeader(screen, roles) {
@@ -40234,26 +40505,26 @@ function recordSections(entity, entities, roles, header, shape = CUSTOM_SHAPE, d
             link,
             setField,
             filesField: fileFields(child, roles)[0],
-            requiredBy: requiredSubset(child, entities, roles, setField)
+            requiredBy: requiredSubset(child, entities, roles, setField, entity)
           });
           continue;
         }
-        const byRole = CHILD_COLUMN_ROLES.flatMap((role) => fieldsWithRole(child, roles, role)).filter(
+        const byRole2 = CHILD_COLUMN_ROLES.flatMap((role) => fieldsWithRole(child, roles, role)).filter(
           (field) => field.alias !== link.alias
         );
         const stops = childTimeline(child, entities, roles);
         if (stops !== void 0) {
-          children.push({ kind: "timeline", child, via, link, fields: byRole, ...stops });
+          children.push({ kind: "timeline", child, via, link, fields: byRole2, ...stops });
           continue;
         }
         const said = childThread(child, roles, via);
         if (said !== void 0) {
           const clock = via === "parent" ? recordDeadline(entity, roles) : void 0;
-          children.push({ kind: "thread", child, via, link, fields: byRole, ...said, ...clock === void 0 ? {} : { clock } });
+          children.push({ kind: "thread", child, via, link, fields: byRole2, ...said, ...clock === void 0 ? {} : { clock } });
           continue;
         }
         const expected = owedRows(entity, roles, child, link);
-        children.push({ kind: "children", child, via, link, fields: byRole, ...expected === void 0 ? {} : { expected } });
+        children.push({ kind: "children", child, via, link, fields: byRole2, ...expected === void 0 ? {} : { expected } });
       }
     }
   }
@@ -40372,10 +40643,10 @@ function recordCharge(shape, entity, roles, door = recordDoor(shape, entity, rol
     (token) => entity.fields.find((field) => field.alias === token)
   );
   if (operands.length !== 2) return void 0;
-  const named = operands.filter((field) => field !== void 0);
-  if (named.length !== 2) return void 0;
-  const priced = named.filter((field) => field.type === "number" && field.format === "currency");
-  const counted = named.filter((field) => field.type === "number" && field.format !== "currency");
+  const named2 = operands.filter((field) => field !== void 0);
+  if (named2.length !== 2) return void 0;
+  const priced = named2.filter((field) => field.type === "number" && field.format === "currency");
+  const counted = named2.filter((field) => field.type === "number" && field.format !== "currency");
   if (priced.length !== 1 || counted.length !== 1) return void 0;
   return { amount, quantity: counted[0], unitPrice: priced[0] };
 }
@@ -40607,6 +40878,7 @@ function validateWorkspacePlan(model, roles, apps, rules = {}) {
     findings.push({ severity: "error", path: "apps", message: `duplicate app name "${dup}"` });
   }
   const entityByAlias = new Map(model.entities.map((entity) => [entity.alias, entity]));
+  const registered = new Set(apps.map((app) => app.screen.entity));
   for (const app of apps) {
     const byReach = /* @__PURE__ */ new Map();
     for (const [reach, acts] of [
@@ -40641,8 +40913,11 @@ function validateWorkspacePlan(model, roles, apps, rules = {}) {
     }
     findings.push(...checkFactGroups(resolved.screen, model.entities, roles));
     findings.push(...checkSectionActs(resolved.screen, model.entities, roles));
+    findings.push(...checkSectionDraws(resolved.screen, model.entities, roles));
+    findings.push(...checkChildRegisters(resolved.screen, model.entities, roles, registered));
     findings.push(...checkDeskStages(resolved.screen));
-    findings.push(...checkPresentation(resolved.screen));
+    findings.push(...checkSeatedColumns(resolved.screen));
+    findings.push(...checkPresentation(resolved.screen, roles, model.entities));
   }
   return findings;
 }
@@ -40661,16 +40936,53 @@ function checkDeskStages(screen) {
     }
   ];
 }
-function checkPresentation(screen) {
+function checkSeatedColumns(screen) {
+  const context = screen.columns.length;
+  const bySlots = screen.slots.filter((slot2) => slot2.field !== null && slot2.role !== "mark").length;
+  if (context === 0 || bySlots + context <= SEATED_COLUMNS) return [];
+  return [
+    {
+      severity: "note",
+      path: `apps.${screen.app.alias}.screen.columns`,
+      message: `adds ${context} column${context === 1 ? "" : "s"} to the ${bySlots} this ${screen.shapeLabel}'s slots already draw, and a register seats about ${SEATED_COLUMNS} at any width \u2014 the context is given up before a slot, so these draw only while the rows are short; leave a slot unbound or drop a column`
+    }
+  ];
+}
+function drawnColumns(screen, roles) {
+  return screen.slots.flatMap((slot2) => {
+    if (slot2.field === null) return [];
+    const counts = roleOf(roles, screen.entity.alias, slot2.field.alias)?.counts;
+    return [{ role: slot2.role, ...counts === void 0 ? {} : { counts } }];
+  });
+}
+function checkPresentation(screen, roles, entities) {
   const stated2 = screen.screen.presentation;
   if (stated2 === void 0) return [];
   const path23 = `apps.${screen.app.alias}.screen.presentation`;
-  const drawn = new Set(screen.slots.flatMap((slot2) => slot2.field === null ? [] : [slot2.role]));
+  const drawn = drawnColumns(screen, roles);
+  const held = new Set(drawn.map((column) => column.role));
   return [
-    ...stated2.lead === void 0 ? [] : [leadRefusal(screen.screen.shape, drawn, stated2.lead)],
-    ...stated2.layout === void 0 ? [] : [layoutRefusal(drawn, stated2.layout)]
+    ...stated2.lead === void 0 ? [] : [leadRefusal(screen.screen.shape, held, stated2.lead)],
+    ...stated2.layout === void 0 ? [] : [layoutRefusal(drawn, stated2.layout)],
+    ...stated2.until === void 0 ? [] : [untilRefusal(screen, entities, drawn, stated2.until)]
   ].flatMap((message2) => message2 === void 0 ? [] : [{ severity: "error", path: path23, message: message2 }]);
 }
+function untilRefusal(screen, entities, drawn, until) {
+  if (!layoutsFor(drawn).includes("gantt")) {
+    return `ends its bars at "${until}", and these rows cannot be drawn as a gantt \u2014 a bar needs a date to start on and a measure counted in days`;
+  }
+  const field = screen.entity.fields.find((candidate) => candidate.alias === until);
+  if (field === void 0) return `ends its bars at "${until}", which is not a field of entity "${screen.entity.alias}"`;
+  const resolved = resolvedFieldType(field, screen.entity, entities);
+  if (resolved !== "date") {
+    return `ends its bars at "${until}", a ${resolved ?? field.type} \u2014 a bar ends on a day`;
+  }
+  const start = screen.slots.find((slot2) => slot2.role === "when")?.field ?? null;
+  if (start !== null && start.alias === until) {
+    return `ends its bars at "${until}", which is the day they start on \u2014 a bar between one date and itself has no length`;
+  }
+  return void 0;
+}
 function checkFactGroups(screen, entities, roles) {
   if (screen.factGroups.length === 0) return [];
   const path23 = `apps.${screen.app.alias}.screen.facts.groups`;
@@ -40688,6 +41000,93 @@ function checkFactGroups(screen, entities, roles) {
     )
   );
 }
+function childRegisters(screen, entities, roles) {
+  const sections = recordSections(screen.entity, entities, roles, recordHeader(screen, roles), screen.screen.shape, screen.record);
+  return new Map(sections.flatMap((section) => section.kind === "children" ? [[section.child.alias, section]] : []));
+}
+function checkSectionDraws(screen, entities, roles) {
+  const drawn = Object.entries(screen.screen.sections ?? {});
+  if (drawn.length === 0) return [];
+  const registers = childRegisters(screen, entities, roles);
+  const takes = SHAPE_REGISTRY.worksheet.slots.sell.roles;
+  return drawn.flatMap(([alias, clause]) => {
+    const at2 = `apps.${screen.app.alias}.screen.sections.${alias}`;
+    const section = registers.get(alias);
+    if (section === void 0) {
+      const offered = [...registers.keys()];
+      return [
+        {
+          severity: "error",
+          path: at2,
+          message: offered.length === 0 ? `names "${alias}", and this record draws no register of a child's rows for a sheet to be worked down` : `names "${alias}", which this record draws no register of \u2014 its registers are addressed by ${offered.join(", ")}`
+        }
+      ];
+    }
+    if (section.via !== "parent") {
+      return [
+        {
+          severity: "error",
+          path: at2,
+          message: `names "${alias}", whose rows this record is merely the ${section.via} of \u2014 a sheet prices the lines a record OWNS, and a line added to a history belongs to the job it is about rather than to what is reading it`
+        }
+      ];
+    }
+    const named2 = [["cost", clause.cost], ["sell", clause.sell]].flatMap(([slot2, field]) => field === void 0 ? [] : [{ slot: slot2, field }]);
+    if (named2.length === 0) {
+      return [
+        {
+          severity: "error",
+          path: at2,
+          message: "states neither a cost nor a sell \u2014 a sheet with no figure to work down is the register it is already drawn as"
+        }
+      ];
+    }
+    const findings = named2.flatMap(({ slot: slot2, field }) => {
+      const carried = section.child.fields.find((one) => one.alias === field);
+      if (carried === void 0) {
+        return [{ severity: "error", path: `${at2}.${slot2}`, message: `names "${field}", which is not a field of entity "${alias}"` }];
+      }
+      const role = roleOf(roles, alias, field)?.role;
+      return role !== void 0 && takes.includes(role) ? [] : [
+        {
+          severity: "error",
+          path: `${at2}.${slot2}`,
+          message: `names "${field}", whose role is ${role === void 0 ? "not declared" : `"${role}"`} \u2014 a sheet's figures are ${takes.map((one) => `"${one}"`).join(" or ")} fields; declare the role in field_roles`
+        }
+      ];
+    });
+    const both = clause.cost;
+    if (findings.length === 0 && both !== void 0 && both === clause.sell) {
+      return [
+        {
+          severity: "error",
+          path: at2,
+          message: `prices "${both}" as both its cost and its sell \u2014 the margin between a figure and itself is nothing, drawn down every line`
+        }
+      ];
+    }
+    return findings;
+  });
+}
+function unregisteredChildren(screen, entities, roles, registered) {
+  const entries2 = recordRecipe(screen.screen.shape, screen.entity, entities, roles, recordHeader(screen, roles), screen.record);
+  const priced = new Set(Object.keys(screen.screen.sections ?? {}));
+  const read2 = new Set(
+    entries2.flatMap(({ draw, section }) => {
+      if (draw !== "open") return [];
+      if (section.kind === "children" || section.kind === "timeline") return [section.child.alias];
+      return section.kind === "expected_set" && section.source === "child" ? [section.child.alias] : [];
+    })
+  );
+  return [...read2].filter((alias) => !registered.has(alias) && !priced.has(alias));
+}
+function checkChildRegisters(screen, entities, roles, registered) {
+  return unregisteredChildren(screen, entities, roles, registered).map((alias) => ({
+    severity: "note",
+    path: `apps.${screen.app.alias}.screen`,
+    message: `"${alias}" has no register \u2014 its rows are read here and created nowhere`
+  }));
+}
 function sectionActTargets(screen, entities, roles) {
   const sections = recordSections(screen.entity, entities, roles, recordHeader(screen, roles), screen.screen.shape, screen.record);
   const found = /* @__PURE__ */ new Map();
@@ -40722,7 +41121,7 @@ function checkSectionActs(screen, entities, roles) {
 function reachableEntries(decl, field, entityRows) {
   const all = new Set(field.type === "select" ? field.options.map((option) => option.alias) : []);
   const requiredBy = decl.required_by;
-  if (decl.role !== "expected_set" || requiredBy === void 0) return all;
+  if (decl.role !== "expected_set" || requiredBy === void 0 || requiredByFrom(field) === "parent") return all;
   const reachable = /* @__PURE__ */ new Set();
   for (const row of entityRows) {
     const said = row.fields[requiredBy.field];
@@ -40809,6 +41208,16 @@ function roleCoverage(model, roles, rows) {
           message: `${section.child.label} hangs under ${entity.label} and declares no identity \u2014 its rows on the record have no name`
         });
       }
+      if (section.kind === "children") {
+        const short = threadShortOf(section.child, roles);
+        if (short !== void 0) {
+          notes.push({
+            severity: "note",
+            path: `field_roles.${section.child.alias}`,
+            message: `${section.child.label} hangs under ${entity.label} and is ${short} short of a thread \u2014 its rows read as a register until it declares one`
+          });
+        }
+      }
       if (section.kind === "expected_set" && section.source === "child" && section.filesField === void 0) {
         notes.push({
           severity: "note",
@@ -40860,9 +41269,17 @@ function optionsWhereConditions(filter2, target) {
   }
   return out.length === 0 ? void 0 : out;
 }
-var LENS_OPERATORS = Object.fromEntries(
-  Object.entries(OPTIONS_WHERE_OPERATORS).map(([type, operators]) => [type, [...operators, "is_empty", "is_not_empty"]])
-);
+var lensRelativePointSchema = zod_default.object({ type: zod_default.literal("relative"), offset: zod_default.number().int(), unit: zod_default.enum(["days", "weeks", "months", "years"]) }).strict();
+function lensRelativePoint(value) {
+  const read2 = lensRelativePointSchema.safeParse(value);
+  return read2.success ? { offset: read2.data.offset, unit: read2.data.unit } : void 0;
+}
+var LENS_OPERATORS = {
+  ...Object.fromEntries(
+    Object.entries(OPTIONS_WHERE_OPERATORS).map(([type, operators]) => [type, [...operators, "is_empty", "is_not_empty"]])
+  ),
+  date: ["before", "after", "on_or_before", "on_or_after", "on", "is_empty", "is_not_empty"]
+};
 function lensOperatorSentence() {
   return Object.entries(LENS_OPERATORS).map(([type, operators]) => `${type} ${operators.join("/")}`).join("; ");
 }
@@ -40886,6 +41303,9 @@ function lensConditions(filter2, entity, entities) {
     if (!(LENS_OPERATORS[type] ?? []).includes(child.operator)) {
       return `reading "${field.alias}" as a ${type} with "${child.operator}" \u2014 a lens is read off the row, so its operators are ${lensOperatorSentence()}`;
     }
+    if (type === "date" && child.operator !== "is_empty" && child.operator !== "is_not_empty" && lensRelativePoint(child.value) === void 0) {
+      return `reading "${field.alias}" against a day this app would carry forever \u2014 a dated lens names a point relative to the reader's clock, as \`{ "type": "relative", "offset": 0, "unit": "days" }\``;
+    }
     out.push({ type, field, operator: child.operator, value: child.value });
   }
   return out.length === 0 ? `keeping every row \u2014 a predicate that narrows nothing is not a set` : out;
@@ -40998,12 +41418,12 @@ function checkWriteRules(entities, rules, roles) {
           continue;
         }
         const declared = new Set(condition.field.options.map((option) => option.alias));
-        for (const named of condition.value) {
-          if (typeof named === "string" && declared.has(named)) continue;
+        for (const named2 of condition.value) {
+          if (typeof named2 === "string" && declared.has(named2)) continue;
           findings.push({
             severity: "error",
             path: at3,
-            message: `names option "${String(named)}", which "${condition.field.label}" does not declare (${[...declared].join(", ")})`
+            message: `names option "${String(named2)}", which "${condition.field.label}" does not declare (${[...declared].join(", ")})`
           });
         }
       }
@@ -41292,12 +41712,12 @@ function checkValue(field, value, path23, refs, errors) {
           });
           continue;
         }
-        const named = raw.slice(0, raw.indexOf(":"));
-        if (named === field.target_entity) continue;
+        const named2 = raw.slice(0, raw.indexOf(":"));
+        if (named2 === field.target_entity) continue;
         errors.push({
           severity: "error",
           path: path23,
-          message: `names a row of entity "${named}", but this field links to "${field.target_entity}"`
+          message: `names a row of entity "${named2}", but this field links to "${field.target_entity}"`
         });
       }
       return;
@@ -41641,7 +42061,7 @@ function resultSideEffects(result) {
 }
 
 // src/version.ts
-var VERSION = "0.207.0";
+var VERSION = "0.208.0";
 
 // src/timezone.ts
 function machineTimezone() {
@@ -49957,9 +50377,9 @@ function declaredTable(aliased, key) {
     (candidate) => candidate.table.id === key || candidate.alias === key || candidate.alias === slugifyAlias(key, true) || candidate.table.name === key
   );
 }
-function declaredField(table, named) {
+function declaredField(table, named2) {
   return table.fields.find(
-    (candidate) => candidate.field.id === named || candidate.alias === named || candidate.alias === slugifyAlias(named, false) || candidate.field.name === named
+    (candidate) => candidate.field.id === named2 || candidate.alias === named2 || candidate.alias === slugifyAlias(named2, false) || candidate.field.name === named2
   );
 }
 function carriedWrites(declaration, tables) {
@@ -50087,12 +50507,12 @@ function writeFindings(declaration, bodies, tables) {
     }
     const fields = /* @__PURE__ */ new Set();
     for (const entry of entries2) {
-      const named = writtenField(entry);
-      const field = declaredField(table, named);
+      const named2 = writtenField(entry);
+      const field = declaredField(table, named2);
       if (field === void 0) {
         findings.push({
           where: key,
-          message: `package.json#lotics.writes declares ${key}.${named}, which ${table.table.name} does not carry \u2014 it was renamed or removed, so the declaration covers nothing.`
+          message: `package.json#lotics.writes declares ${key}.${named2}, which ${table.table.name} does not carry \u2014 it was renamed or removed, so the declaration covers nothing.`
         });
         continue;
       }
@@ -50104,15 +50524,15 @@ function writeFindings(declaration, bodies, tables) {
   const labelById = new Map(aliased.map((table) => [table.table.id, table.table.name]));
   const unknownTools = /* @__PURE__ */ new Set();
   for (const body of bodies) {
-    const named = /* @__PURE__ */ new Set();
+    const named2 = /* @__PURE__ */ new Set();
     const scanned = bodyWrites(body.source);
     for (const tool of scanned.unknownTools) unknownTools.add(tool);
     for (const write of scanned.writes) {
       const declared = write.table === null ? anyDeclared : byTable.get(write.table) ?? /* @__PURE__ */ new Set();
       if (declared.has(write.field)) continue;
       const fieldName2 = fieldLabel(aliased, write.table, write.field);
-      if (named.has(fieldName2)) continue;
-      named.add(fieldName2);
+      if (named2.has(fieldName2)) continue;
+      named2.add(fieldName2);
       const table = write.table === null ? null : labelById.get(write.table) ?? write.table;
       findings.push({
         where: body.alias,
@@ -50183,8 +50603,8 @@ function whereValue(at2, bound, condition, missing) {
     missing.push(`${at2} narrows "${bound.label}" by no option at all \u2014 a select narrowing names the options it admits`);
     return void 0;
   }
-  const named = condition.value;
-  const ids = named.flatMap((option) => {
+  const named2 = condition.value;
+  const ids = named2.flatMap((option) => {
     const live = typeof option === "string" ? bound.options?.get(option) : void 0;
     if (live === void 0) {
       missing.push(`${at2} names option "${String(option)}", which "${bound.label}" does not carry in this workspace`);
@@ -50192,7 +50612,7 @@ function whereValue(at2, bound, condition, missing) {
     }
     return [live.id];
   });
-  return ids.length === named.length ? { value: ids } : void 0;
+  return ids.length === named2.length ? { value: ids } : void 0;
 }
 var WORDS = {
   plain: {
@@ -50287,8 +50707,9 @@ function childSurfaceScreen(parent, entry, mounts) {
     tabs: null,
     slots: [],
     outcomes: {},
+    columns: [],
     acts: { row: [], selection: [], record: [], export: null, import: null },
-    summary: { columnTotals: [], bandTotals: [], above: null, ageing: null },
+    summary: { columnTotals: [], bandTotals: [], above: null, ageing: null, trend: null },
     period: null,
     filters: [],
     obligations: [],
@@ -50479,6 +50900,12 @@ function namingField2(child, link, entities, roles) {
     (field) => field.type === "formula" && roleOf(roles, child.alias, field.alias) === void 0 && resolvedFieldType(field, child, entities) === "text"
   ) ?? own("text") ?? own("select_record_link");
 }
+function drawnColumns2(child, fields, roles) {
+  return fields.filter((field) => {
+    const role = roleOf(roles, child.alias, field.alias)?.role;
+    return role !== void 0 && drawnAsColumn(role, field);
+  });
+}
 function withScope(own, scope) {
   if (scope === void 0) return own;
   if (own === void 0) return scope.filter;
@@ -50557,7 +50984,7 @@ function bindScreen(screen, live, roles, entities, rules, groups = /* @__PURE__
       // A slot's own field, then the further fields an ORDERED role reads after
       // it: they are the same slot, so they lead the entity's own list together.
       ...screen2.slots.flatMap(
-        (slot2) => slot2.field === null ? [] : [...slot2.field === identity ? [] : [slot2.field], ...slot2.also]
+        (slot2) => slot2.field === null ? [] : [...slot2.field === identity ? [] : [slot2.field], ...slot2.also, ...slot2.tiers]
       ),
       ...screen2.tabs === null ? [] : [screen2.tabs]
     ];
@@ -50587,21 +51014,16 @@ function bindScreen(screen, live, roles, entities, rules, groups = /* @__PURE__
       ...factLinkTargets(screen2, planned, entities, roles, owns).map((one) => ({ ...one, on: "fact" })),
       ...createLinkTargets(screen2, entities, roles, owns, under).map((one) => ({ ...one, on: "create" }))
     ];
-    for (const { field, target, display, on } of linkTargets) {
-      const bound = links.get(field.alias);
-      if (on === "create" && bound !== void 0) {
-        createLinks.set(field.alias, bound);
-        continue;
-      }
+    const bindPicker = (owner, field, target, display) => {
       const scoped = new Set((target.read_scope?.any ?? []).flatMap((clause) => "field" in clause ? [clause.field] : []));
       const declared = rules[target.alias]?.natural_key ?? [];
       const keyFields = target.fields.filter((candidate) => declared.includes(candidate.alias));
       const mintFields = mintedWith(target, display, keyFields);
-      const narrowing2 = writeRuleOf(rules, screen2.entity.alias, field.alias)?.options_where;
+      const narrowing2 = writeRuleOf(rules, owner.alias, field.alias)?.options_where;
       const conditions = narrowing2 === void 0 ? void 0 : optionsWhereConditions(narrowing2, target);
       const sourceAliases = new Set(
-        screen2.entity.fields.flatMap((candidate) => {
-          const stated2 = writeRuleOf(rules, screen2.entity.alias, candidate.alias)?.default_from;
+        owner.fields.flatMap((candidate) => {
+          const stated2 = writeRuleOf(rules, owner.alias, candidate.alias)?.default_from;
           return stated2 === void 0 || !stated2.startsWith(`${field.alias}.`) ? [] : [stated2.slice(field.alias.length + 1)];
         })
       );
@@ -50615,22 +51037,22 @@ function bindScreen(screen, live, roles, entities, rules, groups = /* @__PURE__
         ...target.fields.filter((candidate) => scoped.has(candidate.alias))
       ];
       const found = bindTable(`${at2}.${field.alias}`, target, entities, roles, wantedOnTarget, aliased, live, missing);
-      if (found === void 0) continue;
+      if (found === void 0) return void 0;
       const shown = found.fields.get(display.alias);
-      if (shown === void 0) continue;
+      if (shown === void 0) return void 0;
       const rule = scopeOf(target, found.fields);
       const boundOf = (fields) => fields.flatMap((candidate) => {
         const one = found.fields.get(candidate.alias);
         return one === void 0 ? [] : [one];
       });
-      const narrowedAt = `write_rules.${screen2.entity.alias}.fields.${field.alias}.options_where`;
+      const narrowedAt = `write_rules.${owner.alias}.fields.${field.alias}.options_where`;
       const where = (conditions ?? []).flatMap((condition) => {
         const one = found.fields.get(condition.field.alias);
         if (one === void 0) return [];
         const resolved = whereValue(narrowedAt, one, condition, missing);
         return resolved === void 0 ? [] : [{ field: one, type: condition.type, operator: condition.operator, value: resolved.value }];
       });
-      const link = {
+      return {
         alias: optionsQueryAlias(target.alias, display.alias),
         param: OPTIONS_SEARCH_PARAM,
         table: found.table,
@@ -50651,11 +51073,20 @@ function bindScreen(screen, live, roles, entities, rules, groups = /* @__PURE__
         ...rule === void 0 ? {} : { scope: rule },
         ...where.length === 0 ? {} : { where }
       };
+    };
+    for (const { field, target, display, on } of linkTargets) {
+      const bound = links.get(field.alias);
+      if (on === "create" && bound !== void 0) {
+        createLinks.set(field.alias, bound);
+        continue;
+      }
+      const link = bindPicker(screen2.entity, field, target, display);
+      if (link === void 0) continue;
       if (on === "fact") links.set(field.alias, link);
       createLinks.set(field.alias, link);
     }
     const children = /* @__PURE__ */ new Map();
-    const bindChild = (entry2, drawn, set2, files, named, reads = []) => {
+    const bindChild = (entry2, drawn, set2, files, named2, reads = []) => {
       const relation = sectionRelation(entry2.section);
       if (relation === void 0) return;
       const { slot: step, draw } = entry2;
@@ -50702,7 +51133,7 @@ function bindScreen(screen, live, roles, entities, rules, groups = /* @__PURE__
         const boundField = found.fields.get(field.alias);
         if (boundField === void 0) continue;
         fields.set(field.alias, boundField);
-        const role = field.alias === named?.alias ? "identity" : roleOf(roles, child.alias, field.alias)?.role;
+        const role = field.alias === named2?.alias ? "identity" : roleOf(roles, child.alias, field.alias)?.role;
         if (role !== void 0) drawnRoles.set(field.alias, role);
       }
       const operands = /* @__PURE__ */ new Map([[linkField.alias, link]]);
@@ -50738,7 +51169,7 @@ function bindScreen(screen, live, roles, entities, rules, groups = /* @__PURE__
         fields,
         operands,
         roles: drawnRoles,
-        identity: named?.alias ?? child.fields.find((field) => roleOf(roles, child.alias, field.alias)?.role === "identity")?.alias,
+        identity: named2?.alias ?? child.fields.find((field) => roleOf(roles, child.alias, field.alias)?.role === "identity")?.alias,
         set: set2?.alias,
         files: files?.alias,
         ...itinerary === void 0 ? {} : { itinerary },
@@ -50758,22 +51189,19 @@ function bindScreen(screen, live, roles, entities, rules, groups = /* @__PURE__
         continue;
       }
       if (section.kind === "children") {
-        const drawn = section.fields.filter((field) => {
-          const role = roleOf(roles, section.child.alias, field.alias)?.role;
-          return role !== void 0 && drawnAsColumn(role, field);
-        });
+        const drawn = drawnColumns2(section.child, section.fields, roles);
         if (drawn.length > 0) {
           bindChild(entry2, drawn);
           continue;
         }
-        const named = namingField2(section.child, section.link, entities, roles);
-        if (named === void 0) {
+        const named2 = namingField2(section.child, section.link, entities, roles);
+        if (named2 === void 0) {
           missing.push(
             `${at2}.${section.child.alias}: its rows cannot be drawn \u2014 "${section.child.label}" declares no role and carries no reference, autonumber, text formula, text or link field beside "${section.link.label}"`
           );
           continue;
         }
-        bindChild(entry2, [named], void 0, void 0, named);
+        bindChild(entry2, [named2], void 0, void 0, named2);
         continue;
       }
       if (section.kind !== "expected_set" || section.source !== "child") continue;
@@ -50855,14 +51283,15 @@ function stated(entry, field) {
 }
 function factLinkTargets(screen, sections, entities, roles, owns) {
   if (screen.screen.writes === false || !owns) return [];
-  return sections.flatMap((section) => section.kind === "facts" ? section.fields : []).flatMap((field) => {
-    if (field.type !== "select_record_link" || !isEditable(field)) return [];
-    const target = entities.find((candidate) => candidate.alias === field.target_entity);
-    if (target === void 0) return [];
-    const named = field.display_field_aliases?.[0];
-    const display = named === void 0 ? target.fields.find((candidate) => roleOf(roles, target.alias, candidate.alias)?.role === "identity") : target.fields.find((candidate) => candidate.alias === named);
-    return display === void 0 ? [] : [{ field, target, display }];
-  });
+  return sections.flatMap((section) => section.kind === "facts" ? section.fields : []).flatMap((field) => linkTarget2(field, entities, roles));
+}
+function linkTarget2(field, entities, roles) {
+  if (field.type !== "select_record_link" || !isEditable(field)) return [];
+  const target = entities.find((candidate) => candidate.alias === field.target_entity);
+  if (target === void 0) return [];
+  const named2 = field.display_field_aliases?.[0];
+  const display = named2 === void 0 ? target.fields.find((candidate) => roleOf(roles, target.alias, candidate.alias)?.role === "identity") : target.fields.find((candidate) => candidate.alias === named2);
+  return display === void 0 ? [] : [{ field, target, display }];
 }
 function parentLink(entity, roles) {
   const field = entity.fields.find((candidate) => roleOf(roles, entity.alias, candidate.alias)?.role === "parent");
@@ -50870,14 +51299,7 @@ function parentLink(entity, roles) {
 }
 function createLinkTargets(screen, entities, roles, owns, under) {
   if (screen.screen.writes === false || !owns) return [];
-  return screen.entity.fields.flatMap((field) => {
-    if (field.type !== "select_record_link" || !isEditable(field) || field.alias === under?.alias) return [];
-    const target = entities.find((candidate) => candidate.alias === field.target_entity);
-    if (target === void 0) return [];
-    const named = field.display_field_aliases?.[0];
-    const display = named === void 0 ? target.fields.find((candidate) => roleOf(roles, target.alias, candidate.alias)?.role === "identity") : target.fields.find((candidate) => candidate.alias === named);
-    return display === void 0 ? [] : [{ field, target, display }];
-  });
+  return screen.entity.fields.flatMap((field) => field.alias === under?.alias ? [] : linkTarget2(field, entities, roles));
 }
 function mintedWith(target, display, keys2) {
   const keyed = new Set(keys2.map((field) => field.alias));
@@ -51220,14 +51642,37 @@ var specFieldSchema = zod_default.object({
   zeroWhenEmpty: zod_default.literal(true).optional(),
   sign: specSignSchema.optional(),
   level: specLevelSchema.optional(),
-  until: specUntilSchema.optional()
-}).strict();
+  /**
+   * THIS DATE IS A DEADLINE — the row counts down to it and a row past it is
+   * late. The MODEL's statement and the only one any surface reads: derived
+   * from the row instead, the day a lead arrived read as overdue on every desk
+   * it was drawn on. `until` says where the countdown stops.
+   */
+  due: zod_default.literal(true).optional(),
+  until: specUntilSchema.optional(),
+  /**
+   * WHAT THIS MEASURE'S NUMBER COUNTS, where the unit decides how a surface
+   * DRAWS the row — days are what give a bar its length, and a figure with no
+   * unit is drawn as the number it is.
+   */
+  counts: zod_default.literal("days").optional()
+}).strict().check((ctx) => {
+  if (ctx.value.until !== void 0 && ctx.value.due !== true) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`until` says where a countdown stops \u2014 declare `due: true` beside it, or drop it"
+    });
+  }
+});
 var specFieldsSchema = zod_default.record(specColumnAliasSchema, specFieldSchema);
 var specPresentationSchema = zod_default.object({
   lead: presentationLeadSchema.optional(),
   density: presentationDensitySchema.optional(),
   /** How the rows are ARRANGED — the same rows and the same slots in a different geometry. */
-  layout: screenLayoutSchema.optional()
+  layout: screenLayoutSchema.optional(),
+  /** WHERE EACH BAR ENDS on a gantt — the column holding the day it is done, rather than the span it runs. */
+  until: specColumnAliasSchema.optional()
 }).strict();
 var specActPlaceSchema = zod_default.literal("cta");
 var specTemplateActSchema = zod_default.object({
@@ -51267,7 +51712,23 @@ var specAgentActSchema = zod_default.object({
   fills: zod_default.array(specColumnAliasSchema).min(1),
   place: specActPlaceSchema.optional()
 }).strict();
-var specActSchema = zod_default.discriminatedUnion("kind", [specTemplateActSchema, specAgentActSchema]);
+var RECORD_ID_COLUMN = "__source_record_id";
+var specActInputSchema = zod_default.object({
+  name: zod_default.string().min(1),
+  field: specColumnAliasSchema
+}).strict();
+var specWorkflowActSchema = zod_default.object({
+  kind: zod_default.literal("workflow"),
+  label: zod_default.string().min(1),
+  /** The act's own key, stable across renders — the workflow's alias. */
+  key: contractAliasSchema,
+  /** The alias `package.json#lotics.workflows` binds this body under. */
+  workflow: runtimeAliasSchema,
+  /** What the press hands the run, in the order the act named them. */
+  inputs: zod_default.array(specActInputSchema).min(1),
+  place: specActPlaceSchema.optional()
+}).strict();
+var specActSchema = zod_default.discriminatedUnion("kind", [specTemplateActSchema, specAgentActSchema, specWorkflowActSchema]);
 var specColumnsExportSchema = zod_default.object({
   kind: zod_default.literal("columns"),
   /** Each drawn column, in the order the register draws them: the sheet's heading, and the column it reads. */
@@ -51305,13 +51766,23 @@ var specSlotSchema = zod_default.object({
    * rest states it on every line rather than drawing a blank on most.
    */
   also: zod_default.array(specColumnAliasSchema).min(1).optional(),
+  /**
+   * THE TIERS UNDER THE ONE IN `field`, outermost first — a hierarchy the slot
+   * folds by rather than second homes for one value.
+   *
+   * Two lists and not one, because they are two readings: `also` is read
+   * ACROSS, one value wherever the row happens to state it, and this is read
+   * DOWN, a narrower question at each depth.
+   */
+  tiers: zod_default.array(specColumnAliasSchema).min(1).optional(),
   /**
    * THE COLUMN IS THE READER'S OWN CONTROL FOR THIS VALUE — pressed, it writes
    * that single field as a diff through the record's update, blockers and an
    * outcome's confirm included.
    *
    * Only where the decision is one a reader takes FROM THE ROW ALONE, which is
-   * why `app check` refuses it on every role but `lifecycle` and `verdict`.
+   * why `app check` refuses it on every role but `lifecycle`, `verdict` and
+   * `measure` (`quickRefusal`, the one rule both the plan and the spec ask).
    */
   quick: zod_default.literal(true).optional(),
   /** A quick lifecycle whose stages are a WALK — the cell advances to the next rather than offering them all. */
@@ -51339,11 +51810,18 @@ var specSummarySchema = zod_default.object({
     /** Ascending edges in days past due; the last is open-ended. */
     buckets: zod_default.array(zod_default.number().int().positive()).min(1)
   }).strict().optional(),
-  directions: specDirectionsSchema.optional()
+  directions: specDirectionsSchema.optional(),
+  /**
+   * WHICH WAY THE FIGURE MOVED ACROSS THE WINDOW — read over the screen's own
+   * `period`, which the plan refuses this clause without. `direction` is which
+   * way is GOOD: the arrow follows the change, the colour follows this.
+   */
+  trend: zod_default.object({ field: specColumnAliasSchema, direction: zod_default.enum(["up", "down"]) }).strict().optional()
 }).strict();
+var specRelativePointSchema = zod_default.object({ offset: zod_default.number().int(), unit: zod_default.enum(["days", "weeks", "months", "years"]) }).strict();
 var specConditionSchema = zod_default.object({
   field: specColumnAliasSchema,
-  type: zod_default.enum(["number", "text", "boolean", "select"]),
+  type: zod_default.enum(["number", "text", "boolean", "select", "date"]),
   operator: zod_default.enum([
     "equals",
     "not_equals",
@@ -51353,11 +51831,20 @@ var specConditionSchema = zod_default.object({
     "less_than_or_equal_to",
     "has_any_of",
     "has_none_of",
+    "before",
+    "after",
+    "on_or_before",
+    "on_or_after",
+    "on",
     "is_empty",
     "is_not_empty"
   ]),
-  /** What the operator compares against — absent where it compares against nothing. */
-  value: zod_default.union([zod_default.number(), zod_default.string(), zod_default.boolean(), zod_default.array(zod_default.string())]).optional()
+  /**
+   * What the operator compares against — absent where it compares against
+   * nothing. A DATE's is an offset from today and never a day: a lens written
+   * as a date is a set that stops meaning what it said tomorrow.
+   */
+  value: zod_default.union([zod_default.number(), zod_default.string(), zod_default.boolean(), zod_default.array(zod_default.string()), specRelativePointSchema]).optional()
 }).strict();
 var specPredicateSchema = zod_default.object({
   label: zod_default.string().min(1),
@@ -51372,14 +51859,24 @@ var specLensSchema = zod_default.union([
 var specObligationSchema = zod_default.object({
   label: zod_default.string().min(1),
   due: specColumnAliasSchema,
-  /** Filled, this obligation is met and its row leaves the desk. */
-  satisfiedBy: specColumnAliasSchema
+  /**
+   * Filled, this obligation is met and its row leaves the desk — absent where
+   * the business stamps nothing and the LIFECYCLE ends it instead, which the
+   * `due` column's own `until` says and the same read decides.
+   */
+  satisfiedBy: specColumnAliasSchema.optional()
 }).strict();
 var specScreenSchema = zod_default.object({
   alias: contractAliasSchema,
   label: zod_default.string().min(1),
   /** The entity this screen's rows are of — the key of its record in `records`. */
   entity: contractAliasSchema,
+  /**
+   * WHAT A SET OF THESE ROWS IS CALLED — the entity's own noun, for the column
+   * a shape heads with a count. Optional: an app deployed before this clause
+   * carries none and the frame's own word stands in.
+   */
+  rows: zod_default.string().min(1).optional(),
   table: specTableIdSchema,
   shape: specShapeSchema,
   /** How one record opens from the list — a page, a drawer, or revealed in the row itself. */
@@ -51390,6 +51887,16 @@ var specScreenSchema = zod_default.object({
   writes: zod_default.boolean(),
   fields: specFieldsSchema,
   slots: zod_default.array(specSlotSchema),
+  /**
+   * THE CONTEXT COLUMNS — extra facts this register draws AFTER its slots, in
+   * the plan's order, each by what its column IS rather than by a role.
+   *
+   * They carry no rank: the frame ranks every one of them beneath every column
+   * the shape drew, so a width that cannot seat the row sheds the context
+   * before the answer. Bounded here as well as in the plan, because a spec is
+   * also written by hand.
+   */
+  columns: zod_default.array(specColumnAliasSchema).min(1).max(CONTEXT_COLUMNS).optional(),
   /**
    * For each lifecycle this screen draws, the options that END the flow. A row
    * in one has ARRIVED, so the ladder draws it beside the flow rather than as
@@ -51454,16 +51961,21 @@ var specContactSchema = zod_default.discriminatedUnion("kind", [
     reach: zod_default.enum(["email", "phone", "place", "link", "handle"])
   }).strict()
 ]);
+var requiredByFrom2 = {
+  from: zod_default.literal("parent").optional()
+};
 var specRequiredBySchema = zod_default.discriminatedUnion("reads", [
   zod_default.object({
     reads: zod_default.literal("option"),
     field: specColumnAliasSchema,
+    ...requiredByFrom2,
     /** The conditioning option → the entries required under it. */
     options: zod_default.record(specOptionIdSchema, zod_default.array(specOptionIdSchema).min(1))
   }).strict(),
   zod_default.object({
     reads: zod_default.literal("answer"),
     field: specColumnAliasSchema,
+    ...requiredByFrom2,
     /**
      * The row's own answer → the entries required under it. PARTIAL, because
      * an answer that owes nothing is omitted rather than named with an empty
@@ -51498,6 +52010,24 @@ var specItinerarySchema = zod_default.object({
   /** The closing line's label, where the record's band does not already state that sum. */
   total: zod_default.string().min(1).optional()
 }).strict();
+var specWorksheetSchema = zod_default.object({
+  /** HOW MANY the line is for — never summed, because two units have no sum. */
+  quantity: specColumnAliasSchema.optional(),
+  /** What the line COSTS — the base the margin is taken against. */
+  cost: specColumnAliasSchema.optional(),
+  /** What it SELLS for — the figure the sheet closes on. */
+  sell: specColumnAliasSchema.optional(),
+  /** The part of the job each line falls under, and the run its own foot closes. */
+  group: specColumnAliasSchema.optional()
+}).strict().check((ctx) => {
+  if (ctx.value.cost === void 0 && ctx.value.sell === void 0) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "states neither a cost nor a sell \u2014 a sheet works one of the two down"
+    });
+  }
+});
 var specChildSchema = zod_default.object({
   entity: contractAliasSchema,
   table: specTableIdSchema,
@@ -51537,6 +52067,7 @@ var specChildSchema = zod_default.object({
    */
   write: zod_default.object({ alias: runtimeAliasSchema, param: zod_default.string().min(1) }).strict().optional()
 }).strict();
+var specPricedChildSchema = specChildSchema.extend({ worksheet: specWorksheetSchema });
 var sectionActs = { acts: zod_default.array(specActSchema).min(1).optional() };
 var specSectionSchema = zod_default.discriminatedUnion("kind", [
   zod_default.object({ kind: zod_default.literal("facts"), key: zod_default.string().min(1), groups: zod_default.array(specFactGroupSchema), ...sectionActs }).strict(),
@@ -51558,16 +52089,39 @@ var specSectionSchema = zod_default.discriminatedUnion("kind", [
     ...sectionActs
   }).strict(),
   /** A child whose rows carry one entry of the set each — a document desk. */
-  zod_default.object({ kind: zod_default.literal("desk"), key: zod_default.string().min(1), heading: zod_default.string().min(1), child: specChildSchema, ...sectionActs }).strict(),
-  /** The record's own rows, as a register, a run, or a book of movements. */
   zod_default.object({
-    kind: zod_default.literal("children"),
+    kind: zod_default.literal("desk"),
     key: zod_default.string().min(1),
     heading: zod_default.string().min(1),
-    draw: zod_default.enum(["register", "itinerary", "ledger"]),
     child: specChildSchema,
+    /**
+     * WHICH ENTRIES THIS RECORD OWES, where its own column decides them —
+     * read off the record's row, because how many documents an order needs is
+     * a fact about the order and no paper states it.
+     */
+    requiredBy: specRequiredBySchema.optional(),
     ...sectionActs
   }).strict(),
+  /** The record's own rows, as a register, a run, a book of movements, or a priced sheet. */
+  zod_default.discriminatedUnion("draw", [
+    zod_default.object({
+      kind: zod_default.literal("children"),
+      key: zod_default.string().min(1),
+      heading: zod_default.string().min(1),
+      draw: zod_default.enum(["register", "itinerary", "ledger"]),
+      child: specChildSchema,
+      ...sectionActs
+    }).strict(),
+    /** THE SHEET AND ITS FIGURES ARE ONE CLAUSE — neither is declarable without the other. */
+    zod_default.object({
+      kind: zod_default.literal("children"),
+      key: zod_default.string().min(1),
+      heading: zod_default.string().min(1),
+      draw: zod_default.literal("worksheet"),
+      child: specPricedChildSchema,
+      ...sectionActs
+    }).strict()
+  ]),
   /**
    * WHERE THE RECORD IS AGAINST WHERE IT SHOULD BE — a child whose rows are the
    * ordered stops, each carrying the day it was promised for and the day it
@@ -51820,9 +52374,9 @@ function specActSites(spec) {
 function specAllActs(spec) {
   return specActSites(spec).map((site) => site.act);
 }
-function actsPointedAt(spec, named) {
+function actsPointedAt(spec, named2) {
   const paper = (at2, act) => {
-    const component = named.get(at2);
+    const component = named2.get(at2);
     return component === void 0 ? act : { ...act, component };
   };
   const point = (at2, act) => act.kind === "template" ? paper(at2, act) : act;
@@ -51861,9 +52415,11 @@ function specWorkflowAliases(spec) {
   const taken = spec.screen.acts?.import;
   return [
     .../* @__PURE__ */ new Set([
-      // AN AGENT ACT NAMES NO WORKFLOW — what it lands is the record's own
-      // update, which `record.write` below already declares.
-      ...specAllActs(spec).flatMap((act) => act.kind === "template" ? [act.workflow] : []),
+      // THE TWO ARMS THAT NAME A BODY — a paper the one the generator wrote, a
+      // hand-off the one the author binds, both called by alias from the same
+      // press. An agent act lands the record's own update, which `record.write`
+      // below already declares.
+      ...specAllActs(spec).flatMap((act) => act.kind === "template" || act.kind === "workflow" ? [act.workflow] : []),
       ...taken === void 0 ? [] : [taken.workflow],
       ...Object.values(spec.records).flatMap((record2) => [
         ...record2.write === void 0 ? [] : [record2.write.alias],
@@ -52102,6 +52658,43 @@ function sourceOnTarget(link, alias) {
   return link.sources.get(alias);
 }
 
+// src/plan_worksheets.ts
+function byRole(child, role, taken) {
+  for (const [alias, bound] of child.fields) {
+    if (child.roles.get(alias) === role && !taken.has(alias)) return { alias, bound };
+  }
+  return void 0;
+}
+function named(child, alias) {
+  const bound = alias === void 0 ? void 0 : child.fields.get(alias);
+  return alias === void 0 || bound === void 0 ? void 0 : { alias, bound };
+}
+function planWorksheets(entry) {
+  const drawn = entry.screen.screen.sections ?? {};
+  return entry.sections.flatMap(({ draw, section }) => {
+    if (draw === "related" || section.kind !== "children" || section.via !== "parent") return [];
+    const clause = drawn[section.child.alias];
+    if (clause === void 0) return [];
+    const child = entry.children.get(childKey(section.child.alias, section.link.alias));
+    if (child === void 0) return [];
+    const cost = named(child, clause.cost);
+    const sell = named(child, clause.sell);
+    const priced = new Set([cost, sell].flatMap((figure) => figure === void 0 ? [] : [figure.alias]));
+    const quantity = byRole(child, "measure", priced);
+    const group = byRole(child, "category", priced);
+    return [
+      {
+        child,
+        key: `${child.entity.alias}_${child.linkAlias}`,
+        ...quantity === void 0 ? {} : { quantity },
+        ...cost === void 0 ? {} : { cost },
+        ...sell === void 0 ? {} : { sell },
+        ...group === void 0 ? {} : { group }
+      }
+    ];
+  });
+}
+
 // src/plan_record_facts.ts
 function factOrder(screen, roles, fields) {
   const slots = new Set(screen.slots.flatMap((slot2) => slot2.field === null ? [] : [slot2.field.alias]));
@@ -52130,8 +52723,8 @@ function factsPlan(screen, roles, fields) {
   if (screen.factGroups.length === 0) return derived(fields);
   const own = new Set(fields.map((field) => field.alias));
   const claimed = new Set(screen.factGroups.flatMap((group) => group.fields.map((field) => field.alias)));
-  const named = screen.factGroups.map((group) => ({ caption: group.caption, fields: group.fields.filter((field) => own.has(field.alias)) }));
-  return [...named.filter((group) => group.fields.length > 0), ...derived(fields.filter((field) => !claimed.has(field.alias)))];
+  const named2 = screen.factGroups.map((group) => ({ caption: group.caption, fields: group.fields.filter((field) => own.has(field.alias)) }));
+  return [...named2.filter((group) => group.fields.length > 0), ...derived(fields.filter((field) => !claimed.has(field.alias)))];
 }
 
 // src/plan_record_children.ts
@@ -52156,8 +52749,8 @@ var surfaceOf = (fields) => ({
   ref: (alias) => fields.get(alias)?.alias
 });
 var childReads = (child) => child.surface?.fields ?? new Map([...child.fields, ...child.operands]);
-function optionIds(field, named) {
-  return (named ?? []).flatMap((alias) => {
+function optionIds(field, named2) {
+  return (named2 ?? []).flatMap((alias) => {
     const live = field?.options?.get(alias);
     return live === void 0 ? [] : [live.id];
   });
@@ -52187,7 +52780,7 @@ function untilOf(entry, roles, field) {
   return lifecycle === void 0 || settled.length === 0 ? void 0 : { lifecycle: lifecycle.alias, settled };
 }
 function specField(bound, declared, extras = {}) {
-  const multi = declared === void 0 ? false : declared.type === "select" ? declared.multi === true : declared.type === "select_record_link" && declared.cardinality !== "one";
+  const multi = declared !== void 0 && fieldHoldsSeveral(declared);
   const money = bound.money === void 0 ? void 0 : {
     ...bound.money.currency === void 0 ? {} : { currency: bound.money.currency },
     ...bound.money.row === void 0 ? {} : { row: bound.money.row }
@@ -52207,7 +52800,9 @@ function specField(bound, declared, extras = {}) {
     ...bound.zeroWhenEmpty === true ? { zeroWhenEmpty: true } : {},
     ...extras.sign === void 0 ? {} : { sign: extras.sign },
     ...extras.level === void 0 ? {} : { level: extras.level },
-    ...extras.until === void 0 ? {} : { until: extras.until }
+    ...extras.due === void 0 ? {} : { due: extras.due },
+    ...extras.until === void 0 ? {} : { until: extras.until },
+    ...extras.counts === void 0 ? {} : { counts: extras.counts }
   };
 }
 function specFields(fields, declared, extras = () => ({})) {
@@ -52225,11 +52820,21 @@ function screenExtras(entry, roles) {
   const declared = new Map(entry.screen.entity.fields.map((field) => [field.alias, field]));
   return (modelAlias) => {
     const field = declared.get(modelAlias);
-    const role = roleOf(roles, entry.screen.entity.alias, modelAlias)?.role;
+    const decl = roleOf(roles, entry.screen.entity.alias, modelAlias);
+    const role = decl?.role;
     return {
       ...signOf(entry.screen.entity, roles, modelAlias, over) === void 0 ? {} : { sign: signOf(entry.screen.entity, roles, modelAlias, over) },
       ...role === "measure" && levelOf(entry, roles, modelAlias) !== void 0 ? { level: levelOf(entry, roles, modelAlias) } : {},
-      ...field === void 0 || untilOf(entry, roles, field) === void 0 ? {} : { until: untilOf(entry, roles, field) }
+      // A DATE IS A DEADLINE BECAUSE THE MODEL SAID SO. Carried on the column so
+      // every surface drawing the value reads one answer — the register's cell,
+      // the band's countdown, a board's hatching — instead of each deciding it
+      // off the row and tinting a lead's arrival red.
+      ...countsDown(decl) ? { due: true } : {},
+      ...field === void 0 || untilOf(entry, roles, field) === void 0 ? {} : { until: untilOf(entry, roles, field) },
+      // WHAT THE NUMBER COUNTS, where the model said — the unit decides whether
+      // a surface may draw this measure as a LENGTH, and a figure whose unit
+      // never reached the spec is a bar of dollars.
+      ...role === "measure" && decl?.counts !== void 0 ? { counts: decl.counts } : {}
     };
   };
 }
@@ -52256,6 +52861,14 @@ function childExtras(child, roles) {
 }
 function boundAct(entry, templates, act, input) {
   const place = act.place === void 0 ? {} : { place: act.place };
+  if (act.kind === "workflow") {
+    const inputs = act.inputs.flatMap((taken) => {
+      if (taken.field === null) return [{ name: taken.name, field: RECORD_ID_COLUMN }];
+      const bound = entry.fields.get(taken.field.alias);
+      return bound === void 0 ? [] : [{ name: taken.name, field: bound.alias }];
+    });
+    return inputs.length < act.inputs.length ? void 0 : { kind: "workflow", label: act.label, key: act.workflow, workflow: act.workflow, inputs, ...place };
+  }
   if (act.kind === "agent") {
     const fills = act.fills.flatMap((field) => {
       const bound = entry.fields.get(field.alias);
@@ -52292,7 +52905,7 @@ function specActs(entry, templates) {
   });
   const saved = entry.screen.acts.export;
   const paper = saved === null || saved === true ? void 0 : one(saved, recordsParam(entity));
-  const columns = saved === true ? drawnColumns(entry) : [];
+  const columns = saved === true ? drawnColumns3(entry) : [];
   const exported = columns.length > 0 ? { kind: "columns", columns } : paper?.kind === "template" ? paper : void 0;
   const taken = specImport(entry);
   if (row.length === 0 && selection.length === 0 && exported === void 0 && taken === void 0) return void 0;
@@ -52303,11 +52916,11 @@ function specActs(entry, templates) {
     ...taken === void 0 ? {} : { import: taken }
   };
 }
-function drawnColumns(entry) {
+function drawnColumns3(entry) {
   const seen = /* @__PURE__ */ new Set();
-  return entry.screen.slots.flatMap((slot2) => {
-    if (slot2.field === null) return [];
-    const bound = entry.fields.get(slot2.field.alias);
+  const drawn = [...entry.screen.slots.flatMap((slot2) => slot2.field === null ? [] : [slot2.field]), ...entry.screen.columns];
+  return drawn.flatMap((field) => {
+    const bound = entry.fields.get(field.alias);
     if (bound === void 0 || seen.has(bound.alias)) return [];
     seen.add(bound.alias);
     return [{ label: bound.label, field: bound.alias }];
@@ -52318,11 +52931,11 @@ function specImport(entry) {
   if (taken === null) return void 0;
   const key = entry.fields.get(taken.key.alias);
   if (key === void 0) return void 0;
-  const named = taken.columns.flatMap((field) => {
+  const named2 = taken.columns.flatMap((field) => {
     const bound = entry.fields.get(field.alias);
     return bound === void 0 ? [] : [specField(bound, field)];
   });
-  const columns = named.length > 0 ? named : entry.screen.entity.fields.flatMap((field) => {
+  const columns = named2.length > 0 ? named2 : entry.screen.entity.fields.flatMap((field) => {
     const bound = entry.fields.get(field.alias);
     return bound === void 0 || !stated(entry, field) || !importableField(field) ? [] : [specField(bound, field)];
   });
@@ -52350,7 +52963,7 @@ function specDirections(entry, roles) {
   const outflow = words(true);
   return inflow === "" || outflow === "" ? void 0 : { field: bound.alias, inflow, outflow };
 }
-var LENS_TYPES = ["number", "text", "boolean", "select"];
+var LENS_TYPES = ["number", "text", "boolean", "select", "date"];
 var LENS_OPERATORS2 = [
   "equals",
   "not_equals",
@@ -52360,6 +52973,11 @@ var LENS_OPERATORS2 = [
   "less_than_or_equal_to",
   "has_any_of",
   "has_none_of",
+  "before",
+  "after",
+  "on_or_before",
+  "on_or_after",
+  "on",
   "is_empty",
   "is_not_empty"
 ];
@@ -52375,6 +52993,10 @@ function lensValue(field, type, value) {
     const ids = value.map((alias) => field.options?.get(alias)?.id);
     return ids.every((id) => id !== void 0) ? { value: ids.filter((id) => id !== void 0) } : void 0;
   }
+  if (type === "date") {
+    const point = lensRelativePoint(value);
+    return point === void 0 ? value == null ? {} : void 0 : { value: point };
+  }
   if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") return { value };
   return {};
 }
@@ -52403,11 +53025,11 @@ function specSummary(entry, roles) {
     const bound = entry.fields.get(field.alias);
     return bound === void 0 ? [] : [bound.alias];
   });
-  const named = summary.above === null || summary.above === "counts" ? void 0 : summary.above.flatMap((figure) => {
+  const named2 = summary.above === null || summary.above === "counts" ? void 0 : summary.above.flatMap((figure) => {
     const bound = entry.fields.get(figure.field.alias);
     return bound === void 0 ? [] : [figure.at === void 0 ? bound.alias : { field: bound.alias, at: figure.at }];
   });
-  const above = summary.above === "counts" ? "counts" : named === void 0 || named.length === 0 ? void 0 : named;
+  const above = summary.above === "counts" ? "counts" : named2 === void 0 || named2.length === 0 ? void 0 : named2;
   const columnTotals = refs(summary.columnTotals);
   const bandTotals = refs(summary.bandTotals);
   const plan = summary.ageing;
@@ -52415,7 +53037,10 @@ function specSummary(entry, roles) {
   const due = plan === null ? void 0 : entry.fields.get(plan.due.alias);
   const ageing = plan === null || amount === void 0 || due === void 0 ? void 0 : { amount: amount.alias, due: due.alias, buckets: [...plan.buckets] };
   const directions = specDirections(entry, roles);
-  if (above === void 0 && columnTotals.length === 0 && bandTotals.length === 0 && ageing === void 0 && directions === void 0) {
+  const moved = summary.trend;
+  const moving = moved === null ? void 0 : entry.fields.get(moved.field.alias);
+  const trend = moved === null || moving === void 0 ? void 0 : { field: moving.alias, direction: moved.direction };
+  if (above === void 0 && columnTotals.length === 0 && bandTotals.length === 0 && ageing === void 0 && directions === void 0 && trend === void 0) {
     return void 0;
   }
   return {
@@ -52423,7 +53048,8 @@ function specSummary(entry, roles) {
     ...columnTotals.length === 0 ? {} : { columnTotals },
     ...bandTotals.length === 0 ? {} : { bandTotals },
     ...ageing === void 0 ? {} : { ageing },
-    ...directions === void 0 ? {} : { directions }
+    ...directions === void 0 ? {} : { directions },
+    ...trend === void 0 ? {} : { trend }
   };
 }
 function specScreen(entry, roles, templates, inbound) {
@@ -52438,21 +53064,30 @@ function specScreen(entry, roles, templates, inbound) {
       const bound = ref(other);
       return bound === void 0 ? [] : [bound];
     });
+    const tiers = slot2.tiers.flatMap((under) => {
+      const bound = ref(under);
+      return bound === void 0 ? [] : [bound];
+    });
     return [
       {
         name: slot2.name,
         role: slot2.role,
         field,
         ...also.length === 0 ? {} : { also },
+        ...tiers.length === 0 ? {} : { tiers },
         ...slot2.quick === void 0 ? {} : { quick: slot2.quick },
         ...slot2.order === void 0 ? {} : { order: slot2.order }
       }
     ];
   });
+  const columns = screen.columns.flatMap((field) => {
+    const bound = ref(field);
+    return bound === void 0 ? [] : [bound];
+  });
   const outcomes = {};
-  for (const [fieldAlias, named] of Object.entries(screen.outcomes)) {
+  for (const [fieldAlias, named2] of Object.entries(screen.outcomes)) {
     const bound = entry.fields.get(fieldAlias);
-    const ids = optionIds(bound, named);
+    const ids = optionIds(bound, named2);
     if (bound !== void 0 && ids.length > 0) outcomes[bound.alias] = ids;
   }
   const lenses = screen.filters.flatMap((lens) => specLens(entry, lens));
@@ -52469,8 +53104,10 @@ function specScreen(entry, roles, templates, inbound) {
   ];
   const obligations = screen.obligations.flatMap((owed) => {
     const due = ref(owed.field);
-    const satisfiedBy = ref(owed.satisfiedBy);
-    return due === void 0 || satisfiedBy === void 0 ? [] : [{ label: owed.label, due, satisfiedBy }];
+    if (due === void 0) return [];
+    const satisfiedBy = owed.satisfiedBy === void 0 ? void 0 : ref(owed.satisfiedBy);
+    if (satisfiedBy !== void 0) return [{ label: owed.label, due, satisfiedBy }];
+    return owed.satisfiedBy === void 0 && untilOf(entry, roles, owed.field) !== void 0 ? [{ label: owed.label, due }] : [];
   });
   const runs = entry.day === void 0 || entry.runSlot === void 0 ? void 0 : { day: entry.day.alias, slot: entry.runSlot.alias };
   const acts = specActs(entry, templates);
@@ -52481,6 +53118,9 @@ function specScreen(entry, roles, templates, inbound) {
     alias,
     label: screen.screen.label,
     entity,
+    // THE ENTITY'S OWN NOUN, for the column a shape heads with a count — the
+    // entity label names the SET, which is what a count is of.
+    rows: screen.entity.label,
     table: entry.table.id,
     shape: screen.screen.shape,
     record: screen.record,
@@ -52488,6 +53128,7 @@ function specScreen(entry, roles, templates, inbound) {
     writes: screen.screen.writes !== false,
     fields: specFields(entry.fields, screen.entity.fields, screenExtras(entry, roles)),
     slots,
+    ...columns.length === 0 ? {} : { columns },
     ...Object.keys(outcomes).length === 0 ? {} : { outcomes },
     ...tabs === void 0 ? {} : { tabs },
     ...lenses.length === 0 ? {} : { lenses },
@@ -52505,11 +53146,13 @@ function specScreen(entry, roles, templates, inbound) {
 function specPresentation(entry) {
   const stated2 = entry.screen.screen.presentation;
   if (stated2 === void 0 || Object.values(stated2).every((clause) => clause === void 0)) return {};
+  const until = stated2.until === void 0 ? void 0 : entry.fields.get(stated2.until)?.alias;
   return {
     presentation: {
       ...stated2.lead === void 0 ? {} : { lead: stated2.lead },
       ...stated2.density === void 0 ? {} : { density: stated2.density },
-      ...stated2.layout === void 0 ? {} : { layout: stated2.layout }
+      ...stated2.layout === void 0 ? {} : { layout: stated2.layout },
+      ...until === void 0 ? {} : { until }
     }
   };
 }
@@ -52563,7 +53206,8 @@ function specRequiredBy(entry, field, requiredBy) {
     if (entries2.length > 0) options[key] = entries2;
   }
   if (Object.keys(options).length === 0) return void 0;
-  return requiredBy.reads === "answer" ? { reads: "answer", field: by.alias, options } : { reads: "option", field: by.alias, options };
+  const from = requiredBy.from === "parent" ? { from: "parent" } : {};
+  return requiredBy.reads === "answer" ? { reads: "answer", field: by.alias, ...from, options } : { reads: "option", field: by.alias, ...from, options };
 }
 function specChild(child, roles, archetype, slot2, entry, expected) {
   const reads = childReads(child);
@@ -52614,6 +53258,14 @@ function specChild(child, roles, archetype, slot2, entry, expected) {
     ...written === void 0 ? {} : { write: { alias: writeAlias(written), param: recordParam(written) } }
   };
 }
+function specWorksheet(sheet) {
+  return {
+    ...sheet.quantity === void 0 ? {} : { quantity: sheet.quantity.bound.alias },
+    ...sheet.cost === void 0 ? {} : { cost: sheet.cost.bound.alias },
+    ...sheet.sell === void 0 ? {} : { sell: sheet.sell.bound.alias },
+    ...sheet.group === void 0 ? {} : { group: sheet.group.bound.alias }
+  };
+}
 function itineraryTotal(entry, child) {
   const amountAlias = [...child.fields.keys()].find((alias) => child.roles.get(alias) === "amount");
   const amount = amountAlias === void 0 ? void 0 : child.fields.get(amountAlias);
@@ -52720,11 +53372,14 @@ function specRecord(entry, roles, templates) {
         }
         const child = entry.children.get(childKey(section.child.alias, section.link.alias));
         if (child === void 0 || child.set === void 0) break;
+        const setField = child.fields.get(child.set);
+        const deskRequiredBy = setField === void 0 ? void 0 : specRequiredBy(entry, setField, section.requiredBy);
         sections.push({
           kind: "desk",
           key: sectionKey(child.entity.alias, child.linkAlias),
           heading: child.heading,
           child: specChild(child, roles, archetype, slot2, entry, void 0),
+          ...deskRequiredBy === void 0 ? {} : { requiredBy: deskRequiredBy },
           ...stands
         });
         break;
@@ -52744,12 +53399,19 @@ function specRecord(entry, roles, templates) {
           break;
         }
         const ledger = slot2 === "ledger" && section.via === "parent";
+        const sheet = planWorksheets(entry).find((one) => one.child === child);
+        const key = sectionKey(child.entity.alias, child.linkAlias);
+        const bound = specChild(child, roles, archetype, slot2, entry, section.expected);
+        if (sheet !== void 0) {
+          sections.push({ kind: "children", key, heading: child.heading, draw: "worksheet", child: { ...bound, worksheet: specWorksheet(sheet) }, ...stands });
+          break;
+        }
         sections.push({
           kind: "children",
-          key: sectionKey(child.entity.alias, child.linkAlias),
+          key,
           heading: child.heading,
           draw: ledger ? "ledger" : child.itinerary === void 0 ? "register" : "itinerary",
-          child: specChild(child, roles, archetype, slot2, entry, section.expected),
+          child: bound,
           ...stands
         });
         break;
@@ -53036,6 +53698,12 @@ function checkRecord(spec, key, record2, manifest) {
     if (section.kind === "thread" && section.clock !== void 0 && !Object.hasOwn(record2.fields, section.clock)) {
       findings.push({ at: childAt, message: `counts down to "${section.clock}", which this record does not project` });
     }
+    const priced = section.kind === "children" && section.draw === "worksheet" ? section.child.worksheet : {};
+    for (const alias of Object.values(priced)) {
+      if (!Object.hasOwn(child.fields, alias)) {
+        findings.push({ at: childAt, message: `prices "${alias}", which "${child.query}" does not project` });
+      }
+    }
     if (child.write !== void 0 && manifest.workflows?.[child.write.alias] === void 0) {
       findings.push({ at: childAt, message: `changes its rows through "${child.write.alias}", which package.json#lotics.workflows does not declare` });
     }
@@ -53089,6 +53757,17 @@ function checkAct(at2, act, fields, manifest, surface) {
   if (declared === void 0) {
     return [{ at: at2, message: `an act runs "${act.workflow}", which package.json#lotics.workflows does not declare` }];
   }
+  if (act.kind === "workflow") {
+    for (const taken of act.inputs) {
+      if (!Object.hasOwn(declared.inputs ?? {}, taken.name)) {
+        findings.push({ at: at2, message: `an act sends "${taken.name}" to "${act.workflow}", which declares no such input` });
+      }
+      if (taken.field !== RECORD_ID_COLUMN && !Object.hasOwn(fields, taken.field)) {
+        findings.push({ at: at2, message: `the "${act.label}" act sends "${taken.field}", which this ${surface} does not project` });
+      }
+    }
+    return findings;
+  }
   if (!Object.hasOwn(declared.inputs ?? {}, act.input)) {
     findings.push({ at: at2, message: `an act sends "${act.input}" to "${act.workflow}", which declares no such input` });
   }
@@ -53114,11 +53793,19 @@ function checkAppSpec(spec, manifest, components) {
     const refused = leadRefusal(screen.shape, bound, lead);
     if (refused !== void 0) findings.push({ at: at2, message: refused });
   }
+  const drawnColumns4 = screen.slots.map((slot2) => {
+    const counts = screen.fields[slot2.field]?.counts;
+    return { role: slot2.role, ...counts === void 0 ? {} : { counts } };
+  });
   const layout = screen.presentation?.layout;
   if (layout !== void 0) {
-    const refused = layoutRefusal(bound, layout);
+    const refused = layoutRefusal(drawnColumns4, layout);
     if (refused !== void 0) findings.push({ at: at2, message: refused });
   }
+  const until = screen.presentation?.until;
+  if (until !== void 0 && screen.fields[until] === void 0) {
+    findings.push({ at: at2, message: `ends its bars at "${until}", which "${screen.query}" does not project` });
+  }
   const scope = spec.scope;
   if (scope !== void 0) {
     findings.push(
@@ -53156,6 +53843,19 @@ function checkAppSpec(spec, manifest, components) {
     const refused = quickRefusal(slot2.role, slot2.order);
     if (refused !== void 0) findings.push({ at: at2, message: `the "${slot2.name}" slot ${refused}` });
   }
+  const columns = screen.columns ?? [];
+  if (columns.length > 0 && !shapeDrawsColumns(screen.shape)) {
+    findings.push({
+      at: at2,
+      message: `names columns, and a "${screen.shape}" does not stand this entity's records in a table \u2014 the shapes that draw columns are ${shapesDrawingColumns().join(", ")}`
+    });
+  } else if (columns.length > 0 && layout !== void 0 && layout !== "table") {
+    findings.push({ at: at2, message: `names columns beside \`layout: "${layout}"\`, which draws the rows with a device of its own instead of the register's columns` });
+  }
+  for (const alias of columns) {
+    if (Object.hasOwn(screen.fields, alias)) continue;
+    findings.push({ at: at2, message: `draws the column "${alias}", which this register does not project` });
+  }
   for (const lens of screen.lenses ?? []) {
     if (typeof lens === "string") continue;
     for (const predicate of lens.predicates) {
@@ -53175,6 +53875,15 @@ function checkAppSpec(spec, manifest, components) {
       findings.push({ at: at2, message: `reads "${figure.field}" at the window's end, and this screen states no period to be the end of` });
     }
   }
+  const moved = screen.summary?.trend;
+  if (moved !== void 0) {
+    if (screen.period === void 0) {
+      findings.push({ at: at2, message: `reads "${moved.field}" across the window, and this screen states no period to be the window` });
+    }
+    if (!Object.hasOwn(screen.fields, moved.field)) {
+      findings.push({ at: at2, message: `reads "${moved.field}" across the window, which this register does not project` });
+    }
+  }
   const revealed = expandRefusal(screen.shape, screen.record);
   if (revealed !== void 0) findings.push({ at: at2, message: revealed });
   const arranged = revealedLayoutRefusal(screen.record, screen.presentation?.layout);
@@ -53295,8 +54004,8 @@ function componentsIn(projectDir) {
       }
       for (const block of text.matchAll(/\bexport\s*\{([^}]*)\}/g)) {
         for (const part of block[1].split(",")) {
-          const named = /(?:\bas\s+)?([A-Za-z_$][\w$]*)\s*$/.exec(part.trim());
-          if (named !== null) names.add(named[1]);
+          const named2 = /(?:\bas\s+)?([A-Za-z_$][\w$]*)\s*$/.exec(part.trim());
+          if (named2 !== null) names.add(named2[1]);
         }
       }
     }
@@ -54408,7 +55117,7 @@ Captured ${totalRows} row${totalRows === 1 ? "" : "s"} across ${result.captured.
 }
 
 // src/model_reference.md
-var model_reference_default = '# The Lotics workspace model (`model.json`)\n\nOne JSON file describing the tables, fields, options, views, roles and first rows\na workspace starts with. `lotics scaffold check model.json` proves it offline \u2014\nno account, no network. `lotics setup model.json --email you@company.com` creates\nthe account and applies it. `lotics scaffold apply model.json` applies it again,\ninto the workspace the credential names.\n\n**There are two forms of this file.** The full one, below, spells the model out.\nThe `from` one names a published preset and carries only what this business\ndiffers by \u2014 see \xA7 Starting from a preset, and prefer it whenever a preset fits\nthe trade.\n\nApps are PLANNED here and built afterwards: `apps` names each app\'s screens as a\nshape over an entity, checked against the roles `field_roles` gives its fields,\nso the plan is refused before anyone builds a screen (\xA7 Apps and screens). The\nbuilt app lives in the workspace; publishing that workspace as a package is how\nit ships.\n\n## The rules\n\n- **At least one entity, at most 50.** More tables than that is a data model\n  being designed, not scaffolded \u2014 scaffold the rest in a second call.\n- **Adoption is explicit.** `lotics setup` REFUSES an entity whose `label`\n  already names a table in the workspace, naming every colliding label at once.\n  `lotics scaffold apply` adopts those tables and adds the fields, options and\n  views they are missing. Nothing is ever modified or deleted, so applying the\n  same model twice creates nothing the second time.\n- **Adoption is by LABEL, not alias.** Change an entity\'s `label` and the next\n  run asks for a NEW table beside the old one. Renaming a FIELD is\n  `lotics field rename <table> <field> "<new label>" --model <this file>`, which\n  moves the platform, this file and every app bound to it together; deleting is\n  `lotics run delete_table`. Neither goes through the file.\n- **The file\'s own majority is the language.** A model names no locale \u2014 which\n  language it is in is what it mostly says, and `scaffold check` notes the label\n  written the other way. The generated screens read the kit\'s pack, and a\n  generated WRITE cannot: its refusals run on the server, so they are worded in\n  that same majority. Mix the two and the workspace answers in two languages.\n- **`lotics scaffold diff model.json` says where the file and the workspace have\n  come apart**, joined on label, entity then field \u2014 the join adoption itself\n  makes. It exits 1 on any difference, so a model that is about to be published\n  as a preset carries the labels in use rather than the ones it was written with.\n- **Rows land only where every bound table is empty.** One table already holding\n  records and no rows are written anywhere, and the result says\n  `rows_skipped: true`: sample rows landing among a customer\'s real ones cannot\n  be told apart from them.\n- **After the first run the WORKSPACE is the source of truth.** The file is an\n  authoring input, not a mirror \u2014 scaffold never deletes what the file stopped\n  naming.\n- **`lotics scaffold check` decides all of it offline**, and reports every\n  problem in one run rather than the first: an alias that resolves to nothing, a\n  link whose pair is not symmetric, and the rows themselves \u2014 a field the entity\n  does not declare, an option alias the field does not declare, a link naming no\n  row in the file, a `ref` used twice, a date that is not one, a value on a\n  platform-computed field, and a files cell that is neither a relative path\n  beside this file nor a `fil_` id.\n\n## Top level\n\n```jsonc\n{\n  "entities": [ /* the tables */ ],\n  "roles":    [ /* workspace groups to create */ ],    // optional\n  "templates":[ /* inline html / email templates */ ], // optional\n  "rows":     { /* first records, keyed by entity alias */ },  // optional\n  "field_roles": { /* the reporting role each field plays, keyed by entity then field */ }, // optional\n  "write_rules": { /* what a CREATE finds, defaults and refuses, keyed by entity */ }, // optional\n  "apps":     [ /* the screens each app will have, as shapes over entities */ ], // optional\n  "apply":    [ /* published packages to copy in afterwards */ ], // optional\n  "preset":   { /* a trade\'s branches, for a PUBLISHED model */ } // optional\n}\n```\n\nThe other form names a preset instead of restating one:\n\n```jsonc\n{\n  "from":     "field_service",             // the preset this model starts from, by slug\n  "variants": ["crews"],                   // optional \u2014 its branches to merge in, in order\n  "rename":   {                            // optional \u2014 what THIS business calls each table\n    "job": { "label": "\u0110\u01A1n h\xE0ng", "fields": { "code": "M\xE3 \u0111\u01A1n" } }\n  },\n  "entities": [ /* tables the preset does not declare */ ],    // optional\n  "rows":     { /* first records, keyed by entity alias */ },  // optional\n  "field_roles": { /* roles on the preset\'s fields and this business\'s own */ }, // optional\n  "write_rules": { /* create-time clauses on the preset\'s entities and its own */ }, // optional\n  "apps":     [ /* the screens each app will have */ ],        // optional\n  "apply":    [ /* published packages to copy in afterwards */ ] // optional\n}\n```\n\n**A model may not carry** `fixtures`, `knowledge` or `knowledge_expects`, and no\n`excel` / `word` / `pdf-form` template: each of those is content that lives in a\npublished bundle, which a model has none of. `apps` here is a plan of screens,\nnever built code. An unknown top-level key is an error, never ignored.\n\n### Aliases\n\nEvery `alias` is a lowercase slug \u2014 a letter, then letters, digits and\nunderscores (`unit_price`, `so_1001`). Aliases are how the file cross-references\nitself; they are never shown to anyone. `label` is what a person sees.\n\nLabels must be unique within their namespace \u2014 two entities, two fields on one\nentity, two options on one field, two views on one entity, two roles or two\ntemplates cannot share a label, because scaffold matches by label.\n\n## Entity\n\n```jsonc\n{\n  "alias": "order",\n  "label": "Orders",            // the table\'s name, which names the SET it holds\n  "singular": "Order",          // optional \u2014 ONE of them, for the act that opens one\n  "description": "\u2026",           // optional\n  "fields": [ /* at least one */ ],\n  "views":  [ /* optional; an entity with none still gets the default grid */ ],\n  "read_scope": { /* optional; absent, everyone with access to the table reads every row */\n    "any": [\n      { "member_of": "sales" },                       // a role alias this model declares\n      { "field": "scope", "is": ["shared"] }          // a single select on this entity, by option alias\n    ]\n  }\n}\n```\n\n**`singular` is what a create says.** A register\'s own act and the panel it\nopens name the row being made \u2014 `New Order`, `H\u1ED3 s\u01A1 m\u1EDBi` \u2014 while `label` names\nthe table, so without it the button reads `New Orders`. Nothing derives it\n(English plurals are irregular), and most models need none: a Vietnamese noun is\nthe same word either way. `scaffold check` prints it beside the table under *Who\nwrites what* and NOTES a table that will name the set. An act on a child section\nkeeps the label: it adds a line to the register under the record the reader is\nalready standing in.\n\n**`read_scope` is a ROW rule, enforced by the platform.** A row is readable when\nANY clause holds: the reader is in that role\'s group, or the named select carries\none of those options. It is resolved at scaffold into the table\'s own row\nfilters, so an app, a workflow reading for a viewer, and the API all answer the\nsame rows \u2014 a per-record visibility field the app merely honours is a convention,\nnot a gate. `any` may not be empty (a rule nobody satisfies hides the table), and\nevery role alias and option alias in it must be one this model declares.\n\n## Field\n\nEvery field carries `alias`, `label`, an optional `description`, and an optional\n`required` \u2014 advisory only, read by app forms and workflows; the table itself has\nno required constraint. `label` may not contain `{` or `}` (formulas reference\nfields by label at the platform level).\n\n`default` is the value pre-filled into a NEW record. It applies on create only;\nexisting records are never backfilled. Only the types listed below accept one.\n\n### `text`\n\n```jsonc\n{ "alias": "name", "label": "Name", "type": "text",\n  "unique": false,              // optional \u2014 require distinct values\n  "format": "text",             // optional \u2014 "text" | "link" | "markdown"\n  "default": "" }               // optional\n```\n\n### `number`\n\n```jsonc\n{ "alias": "amount", "label": "Amount", "type": "number",\n  "format": "currency",         // optional \u2014 "number" | "currency" | "percentage"\n  "currency": "VND",            // optional \u2014 ISO 4217\n  "default": 0 }                // optional\n```\n\n`format` is what the number IS, and every surface reads it: `currency` prints as\nmoney in the code the row or the field states, `percentage` as a whole percent\nwith its sign. An ABSENT number is drawn absent \u2014 the one exception is a\n`sum` or count rollup the plan reads as a **`measure`**: that is the thing\naccumulated toward a bound, so nothing accumulated yet is zero and the meter\ndraws it. The same rollup read as an `amount` keeps its blank, and so does every\nother role: nothing added to what a row is WORTH means unpriced, not free. A\n`min`, an `avg`, a percentage of nothing and every FORMULA stay blank in any\nrole, because none of them has an answer to give. This is why the pair on one\nscreen reads two ways \u2014 what has come in against what is owed \u2014 and why a\nmeasure\'s own LIMIT, an amount, leaves an unquoted row out of the count rather\nthan reporting it as nothing collected. **AND WHERE THAT LIMIT IS ABSENT THERE IS\nNO LEVEL AT ALL**: a level is a reading AGAINST a bound, so a row that states no\nbound draws nothing \u2014 cell, fact and all \u2014 rather than a numerator whose whole\nmeaning was the comparison. "Collected 0" beside a blank total reads as money\nagainst a job worth nothing. A measure the model gives no limit is a plain figure\nand is unaffected. A share is stored in percent units \u2014 68.1 is 68.1 % \u2014 and the\ncolumn, the fact behind it, the meter it is judged by and the figure over the\nregister all say so.\n\n### `date`\n\n```jsonc\n{ "alias": "placed_on", "label": "Placed on", "type": "date",\n  "format": "date",             // optional \u2014 "date" | "datetime" | "date_range" | "datetime_range"\n  "timezone": "Asia/Ho_Chi_Minh",  // optional \u2014 IANA name\n  "derive_from": "created_at",  // optional \u2014 "created_at" | "updated_at"; makes the field read-only\n  "default": "2026-01-01" }     // optional; refused together with derive_from\n```\n\n### `boolean`\n\n```jsonc\n{ "alias": "paid", "label": "Paid", "type": "boolean", "default": false }\n```\n\n### `select`\n\n```jsonc\n{ "alias": "tier", "label": "Tier", "type": "select",\n  "options": [                                     // at least one\n    { "alias": "standard", "label": "Standard", "color": "slate" },\n    { "alias": "gold",     "label": "Gold",     "color": "amber" }\n  ],\n  "multi": false,               // optional\n  "default": ["standard"] }     // optional \u2014 option ALIASES; one unless multi\n```\n\n`color` is one of: `red`, `orange`, `amber`, `yellow`, `lime`, `green`,\n`emerald`, `teal`, `cyan`, `sky`, `blue`, `indigo`, `violet`, `purple`,\n`fuchsia`, `pink`, `rose`, `slate`, `gray`, `zinc`, `neutral`, `stone`.\n\n### `select_member`\n\nA person picker over the workspace\'s members. No default: a model cannot name\nmembers of a workspace that does not exist yet.\n\n```jsonc\n{ "alias": "owner", "label": "Owner", "type": "select_member", "multi": false }\n```\n\n### `select_record_link`\n\n```jsonc\n{ "alias": "customer", "label": "Customer", "type": "select_record_link",\n  "target_entity": "customer",        // an entity alias this model declares\n  "cardinality": "one",               // optional \u2014 "one" | "many" (default "many")\n  "sync_both_ways": true,             // optional \u2014 keep a paired field on the target\n  "paired_field_alias": "orders",     // the partner field ON THE TARGET entity\n  "display_field_aliases": ["name"] } // optional \u2014 what the link shows / the picker\'s columns\n```\n\nA two-way link is declared on BOTH sides, each naming the other as its\n`paired_field_alias`; the pair must be symmetric or the model is refused.\n\n**A single-valued link needs no partner.** `"cardinality": "one"` on its own is a\nlink that holds one row \u2014 one customer on an invoice, one project on a device \u2014\nand nothing is created on the target. The mirror invariant belongs to a PAIRED\nlink: pair a link when the target\'s own record should list what points at it, and\nleave it unpaired when it should not. Either way the record plan draws the\nrelation as a section on the side it points at, so an unpaired link costs the\ntarget nothing.\n\n### `files`\n\n```jsonc\n{ "alias": "attachments", "label": "Attachments", "type": "files" }\n```\n\n### `formula`\n\n```jsonc\n{ "alias": "total", "label": "Total", "type": "formula",\n  "formula": {\n    "expression": "{amount} * 1.1",  // fields on THIS entity, by alias, in braces\n    "output_type": "number",         // optional \u2014 what it YIELDS: "number" | "text" | "date" | "datetime" | "boolean"\n    "format": "currency",            // optional \u2014 how that result is DRAWN: "number" | "currency" | "percentage" | "link"\n    "currency": "VND"                // optional\n  } }\n```\n\n`output_type` is what the expression answers WITH; `format` is how it is printed.\nThe platform infers the result at write time and ignores what you declare, so\nthis is a statement the offline checks read \u2014 which is what lets a role or a\nscreen clause accept a computed value: a caption over a derived name\n(`output_type: "text"`), a period over a settled date (`"date"`). A formula\ndeclaring neither says nothing about its result, and every rule that needs one\nrefuses it by name. `lotics scaffold export` writes the result a live workspace\ncomputed, so exporting a workspace fills these in.\n\n### `rollup`\n\nAggregates the records reached through a link on this entity.\n\n```jsonc\n{ "alias": "total_ordered", "label": "Total ordered", "type": "rollup",\n  "source_field_alias": "orders",    // a select_record_link field on THIS entity\n  "aggregate_option": {\n    "operation": "sum",              // count | sum | avg | median | min | max | range |\n                                     // empty | filled | percent_empty | percent_filled |\n                                     // unique | percent_unique |\n                                     // earliest | latest | date_range |\n                                     // checked | unchecked | percent_checked |\n                                     // percent_unchecked\n    "field_key": "amount"            // a field ALIAS on the linked entity ("count" may omit it)\n  },\n  "filter": { /* optional \u2014 see Views; every field_key is an alias on the LINKED entity */ } }\n```\n\nThe operation must be one the aggregated field\'s type allows \u2014 `sum` over a\nnumber, `earliest` over a date, `filled` over anything.\n\n### `lookup`\n\nDisplays a field from the linked records.\n\n```jsonc\n{ "alias": "customer_tier", "label": "Customer tier", "type": "lookup",\n  "source_field_alias": "customer",  // a select_record_link field on THIS entity\n  "lookup_field_alias": "tier",      // a field alias on the linked entity\n  "order_by": { "field_key": "placed_on", "direction": "desc" } }  // optional \u2014 pick the single extreme row\n```\n\n### `autonumber`\n\n```jsonc\n{ "alias": "seq", "label": "No.", "type": "autonumber",\n  "prefix": "SO-",     // optional \u2014 ignored when template is set\n  "padding": 4,        // optional \u2014 1..20, zero-pads the integer\n  "template": "SO-{YEAR}-{N:4}" }  // optional \u2014 {N}, {N:W}, {YEAR}, {YEAR:2}, {MONTH}, {DAY}\n```\n\n## Views\n\nSaved views live under the entity they belong to. Every field reference is a\nfield ALIAS on that entity.\n\n```jsonc\n{\n  "alias": "gold",\n  "label": "Gold customers",\n  "description": "\u2026",                       // optional\n  "columns": [                              // optional \u2014 omit to show every field\n    { "field_alias": "name", "visibility": "visible", "width": 240 },\n    { "field_alias": "tier", "visibility": "hidden" }\n  ],\n  "filters": {                              // optional\n    "node_type": "group",\n    "logic": "and",                         // "and" | "or"\n    "children": [\n      { "node_type": "condition", "type": "select", "field_key": "tier",\n        "operator": "has_any_of", "value": ["gold"] }\n    ]\n  },\n  "sort": [ { "field_key": "name", "order": "asc" } ],  // optional; order is "asc" | "desc" | null\n  "summary": { "amount": "sum" },           // optional \u2014 field alias \u2192 footer operation\n  "frozen_columns": 1                       // optional\n}\n```\n\nA condition\'s `type` is the field\'s type and its `operator` is one that type\nadmits \u2014 `has_any_of` / `has_none_of` / `has_all_of` / `is_empty` /\n`is_not_empty` for a select, `equals` / `greater_than` / `less_than` for a\nnumber, `on` / `before` / `after` / `between` for a date, `contains` /\n`is_any_of` for text. A select condition\'s `value` names option ALIASES.\n\n`columns`, when present, is exhaustive and must not be empty: a view renders\nexactly the entries it holds. Omit the key to show every field.\n\n## Roles\n\nA role becomes a workspace group. Members are added afterwards, in the app.\n\n```jsonc\n{ "alias": "sales", "label": "Sales" }\n```\n\n## Templates\n\nOnly inline `html` and `email` templates \u2014 the rest are file-backed and a model\nhas no bytes. An `html` template renders to a PDF when a workflow generates\nfrom it; `{{name}}` is filled from the workflow\'s data.\n\n```jsonc\n{ "alias": "order_ack", "label": "Order acknowledgement", "type": "email",\n  "content": "<p>Hello {{customer}}\u2026</p>" }\n```\n\nA paper that has to look like a counterparty produced it \u2014 an official letter,\nan acceptance minute, a supplier\'s bill \u2014 is the same `html` template with a\nshell around the body: a letterhead, a reference line, a seal and a signature\nblock, and paper grain over everything. One shell, many bodies; the data is the\nonly thing that changes, so a workflow can re-issue it over any record.\n\n```jsonc\n{ "alias": "cong_van", "label": "C\xF4ng v\u0103n", "type": "html",\n  "content": "\u2026the page below, as one JSON string\u2026" }\n```\n\n```html\n<style>\n    .sheet{position:relative;width:718px;padding:44px 58px 30px;background:#fbfaf6;color:#111;font:14.2px/1.5 \'Liberation Serif\',serif}\n    .grain{position:absolute;inset:0;opacity:.34;mix-blend-mode:multiply;background:url("data:image/svg+xml;utf8,<svg xmlns=\'http://www.w3.org/2000/svg\' width=\'140\' height=\'140\'><filter id=\'f\'><feTurbulence baseFrequency=\'.9\' numOctaves=\'2\'/><feColorMatrix values=\'0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .35 0\'/></filter><rect width=\'140\' height=\'140\' filter=\'url(%23f)\'/></svg>")}\n    .top{display:flex;text-align:center;font-size:13.4px} .top>div{flex:1} .u{display:inline-block;border-bottom:1px solid #111;font-weight:700}\n    .ref{display:flex;text-align:center;font-size:13.4px;margin-top:6px} .ref>div{flex:1} .ref .r{font-style:italic}\n    h1{text-align:center;font-size:15.6px;margin:26px 0 18px} p{text-align:justify;text-indent:26px;margin:0 0 9px}\n    .sig{display:flex;margin-top:20px} .sig .l{flex:1} .sig .r{width:290px;text-align:center;position:relative}\n    .sig .nm{font-weight:700;margin-top:96px} .seal{position:absolute;left:4px;top:8px;width:166px;height:166px;opacity:.66;mix-blend-mode:multiply;transform:rotate(-17deg)}\n  </style>\n  <div class=\'sheet\'><div class=\'grain\'></div>\n    <div class=\'top\'><div><b>{{issuer_parent}}</b><br><span class=\'u\'>{{issuer}}</span></div>\n      <div><b>C\u1ED8NG H\xD2A X\xC3 H\u1ED8I CH\u1EE6 NGH\u0128A VI\u1EC6T NAM</b><br><span class=\'u\'>\u0110\u1ED9c l\u1EADp - T\u1EF1 do - H\u1EA1nh ph\xFAc</span></div></div>\n    <div class=\'ref\'><div>S\u1ED1: {{number}}</div><div class=\'r\'>{{place}}, ng\xE0y {{day}} th\xE1ng {{month}} n\u0103m {{year}}</div></div>\n    <h1>{{title}}</h1>\n    <p>K\xEDnh g\u1EEDi: {{recipient}}.</p>\n    {{{body}}}\n    <div class=\'sig\'><div class=\'l\'><b>N\u01A1i nh\u1EADn:</b><br>- Nh\u01B0 tr\xEAn;<br>- L\u01B0u VT.</div>\n      <div class=\'r\'><img class=\'seal\' src=\'{{seal_url}}\'><b>{{signer_title}}</b><div class=\'nm\'>{{signer}}</div></div></div>\n  </div>\n```\n\n`lotics preview <file.html>` renders any such page to a PNG the way a demo\'s\nprops are made, sized to its content, so a paper can be looked at before it is\nput in a template.\n\n## Rows\n\nFirst records, keyed by entity alias. Up to 200 rows per entity and 2000 across\nthe model, attaching at most 2000 documents between them \u2014 a real data set\nbelongs in an import, not a model.\n\n```jsonc\n"rows": {\n  "customer": [\n    { "ref": "acme", "fields": { "name": "Acme Trading", "tier": "gold" } }\n  ]\n}\n```\n\n`ref` is a local handle (lowercase letters, digits, underscores) that other rows\'\nlink fields address. It is never persisted.\n\nA `files` cell attaches documents: paths relative to this file (no `..`, never\nabsolute), which `check` proves exist and `apply` uploads into the workspace\nbefore any row is written \u2014 a paperwork business seeds its papers with its\nrows. The server accepts only `fil_` ids of files this workspace owns, which is\nwhat the upload leaves behind. After a run that wrote rows, `apply` writes the\nrecord ids beside the file (`<model>.last_run.json`): `delete_records` over\nthem is how a seeded set is reset, and applying again re-dates it.\n\n`fields` is keyed by field alias, and every value is read against the field\'s\nDECLARED type:\n\n| Field type | Value |\n|---|---|\n| `text` / `number` / `boolean` | the value itself |\n| `date` | `"2026-03-14"`, or a relative expression (below) |\n| `select` | the option ALIAS \u2014 `"gold"`, or `["gold","vip"]` for a multi-select |\n| `select_record_link` | `"<entity-alias>:<ref>"` naming another row in this file \u2014 `"customer:acme"`, or an array for several |\n| `select_member` | `"self"` only \u2014 the person applying the model |\n| `files` | paths beside this file \u2014 `["scans/pccc_letter.png"]` \u2014 uploaded by `apply`/`setup` before the rows are posted; or `fil_` ids of files already in this workspace |\n| `formula`, `rollup`, `lookup`, `autonumber` | not allowed \u2014 the platform writes these |\n\n**Documents can be attached on their own, afterwards.** Rows land only into empty\ntables, so a model whose binaries were added after the first apply has no second\napply to carry them: `lotics scaffold apply model.json --documents` writes ONLY\nthe `files` cells, onto the records the first run created, joined through the\n`<model>.last_run.json` beside the file. Running it twice attaches nothing the\nsecond time \u2014 the same path keeps the same file, and a cell is a set.\n\n### Relative dates\n\nA date cell holds a literal `YYYY-MM-DD`, or an expression relative to the day\nthe model is applied, so a screen that opens on "this month" is not empty a month\nlater:\n\n- `@today` \u2014 the day of the run, in the workspace\'s timezone\n- `@month-start` \u2014 the 1st of that month\n- either with a whole-day offset: `@today-14`, `@month-start+9`\n\n`@month-start` exists because `@today-N` cannot promise a month: applied on the\n2nd, `@today-3` lands in the previous one.\n\n## Field roles\n\n`field_roles` names the reporting role a field plays on its entity \u2014 keyed by\nentity alias, then field alias \u2014 so every screen over the entity agrees on\nwhich column names the row and which select is the stage. A shape\'s slot binds\nto it (\xA7 Apps and screens). Like `rows` and `apps`, it is this file\'s: `check`\nproves it and the workspace never sees it. Each role sits on the types that can\nanswer it:\n\n| Role | On | Meaning |\n|---|---|---|\n| `identity` | `text`, `autonumber`, `select_record_link`, `formula` | names the row \u2014 the register\'s first column; a link where the row is "the product, at this branch"; a formula where the name is computed, and then it may not be `format`ted as a figure. One per entity |\n| `reference` | `text`, `autonumber`, `formula` | the key the SYSTEM files the row under \u2014 a booking number, a container code \u2014 drawn as the supporting line under the name rather than as a column of its own. One per entity |\n| `mark` | `files`, or a `lookup`/`rollup` that resolves to one | the row\'s picture \u2014 its own, or the linked record\'s. One per entity |\n| `lifecycle` | single `select` | the ordered stages a row walks; option order is the order. Which of them END the flow is `outcomes`. One per entity |\n| `category` | single `select` | what the row IS \u2014 a kind, a service, a book. One badge in the field\'s own colour, with no ladder behind it and no flow to advance. Repeats: a row can be of two kinds of thing |\n| `measure` | `number`, `formula`, `rollup` | a level read against a limit \u2014 see `against` and `alert`. Money where the model says so, and then it prints as money |\n| `expected_set` | `select` | its OPTIONS are the required set (documents, checks, services); an option no row has is a gap to show, not nothing. A multi-select draws as a ring and a fraction wherever it is drawn \u2014 absence is the information, and a list of what IS there says nothing about what is missing |\n| `amount` | `number`, `formula`, `rollup` | THE money of a ledger row; `signed_by` says which way it moved, `against` names the reference it is quoted off. One per entity |\n| `when` | `date`, or a `formula`/`rollup`/`lookup` that yields one | the ledger or timeline date \u2014 stated, or derived: the day money MOVED is a formula over the two columns that could hold it. `until` names the stage of this entity\'s own `lifecycle` at which its COUNTDOWN is spent. One per entity |\n| `slot` | single `select`, or a `datetime` `date` | where in the DAY a row sits \u2014 the run it is read in under its day\'s heading on an itinerary. A select\'s option order IS the run\'s order; a time is ordered by the clock. A plain `date` is refused: that is the day itself. One per entity |\n| `party` | `select_record_link` | the counterparty. One per entity |\n| `parent` | `select_record_link` | the record this row belongs to \u2014 a line\'s order, a paper\'s case. The parent\'s record shows these rows; the row shows the parent as a fact. One per entity, and it links to an entity this model declares |\n| `contact` | `text` | a way to reach a party \u2014 an address, a number, the town it is in. The record draws them as ONE row of links under the name, so the role sits on every field that is one of them. Repeats |\n| `currency` | single `select` whose option LABELS are ISO 4217 codes | the money THIS ROW\'s figures are in. Every amount and every money measure on the entity is then printed per row rather than in one code for the whole column, and the select is not drawn as a fact of its own. One per entity |\n| `verdict` | `boolean`, `formula` | a settled pass/fail \u2014 ticked, or computed. TRUE is the PASSING side wherever it is drawn, a register\'s risk flag included, so a field whose true means trouble is the same fact asked the other way round. One per entity |\n| `obligation` | `date` | a day something is OWED by \u2014 a cut-off, a permit expiry, a payment due. `satisfied_by` names what CLOSES it, `label` what is owed. Repeats: a row owes several things, and a shape that fans them draws one row each |\n\n**`until` stops a countdown where the work is DONE.** A deadline counts down so\nsomebody acts on it, and a row that has arrived needs nothing: without the clause\na delivered order is tinted for a date it met, and every settled row past its day\njoins the urgent ones in the reader\'s glance. It names one option of the entity\'s\n`lifecycle`; at that stage, at every stage past it and at every `outcome`, the\ndate is drawn as the plain day it is.\n\n"One per entity" is one COLUMN, never one value on screen. A second counterparty\nor a second parent stays a ROLELESS `select_record_link`: which field fills a\nslot is the screen\'s answer (\xA7 Apps and screens), and the extra link is a fact on\nthe row with its own section on the record, headed by that link\'s own label. A\nrole naming two fields would move the ambiguity into every shape that reads it.\n\nA COMPUTED field is admitted where its RESULT is what the role needs, and\nrefused where it is not: `identity` and `reference` need `text`, `when` a `date`,\n`mark` `files`. A formula\'s result is its `output_type`; a rollup\'s and a\nlookup\'s is read through the walk. So a formula yielding a number is refused in a\nname\'s place, a lookup landing on anything but `files` is refused as a `mark`, and\na formula declaring NO result is refused by all four \u2014 naming `output_type` as\nthe remedy, because a value drawn as a type nobody stated is the wrong cell with\nnothing saying so. The result also decides the DEVICE every screen draws the value\nwith: a rollup taking the `latest` of a set of dates is drawn as a date, a lookup\nof a select as the words it holds.\n\nA bare role name is the common form. A role that is read against a SECOND field\ntakes the object form:\n\n- **`measure`** names its limit: `against` \u2014 a constant, or a field on the same\n  entity the row states as a number (a `number`, or a formula or rollup whose\n  result is one) \u2014 and `alert`, which side of it needs attention, `over` a\n  capacity or `under` a minimum. The two come together.\n- **`measure`** names what its number COUNTS, where the unit changes how the row\n  is DRAWN rather than how the figure reads: `counts: "days"` spans a stop across\n  that many days of a run, so a three-night stay fills three of its days instead\n  of only the one it starts on. Stated, never inferred \u2014 nothing about a `3` says\n  whether it is nights, pallets or hours, and a quantity drawn across a week is a\n  run nobody can read.\n- **`lifecycle`** names the stages that END the flow: `outcomes`, option aliases\n  of that select. A row in one has ARRIVED \u2014 delivered, cancelled, written off \u2014\n  so a desk draws them apart from the ladder instead of chaining them after each\n  other. Not every option may be an outcome, and terminal-ness belongs here, never\n  written into a stage\'s label.\n- **`amount`** names the REFERENCE it is read against: `against`, a field on the\n  same entity the row states as a number. A price against the list it is quoted\n  off, a rate against the going one \u2014 and the catalogue item\'s record draws the\n  pair on one axis with the gap said in words. Never a constant (a price typed\n  into the model ages with nothing to update it) and never an `alert`: a limit is\n  a ceiling a row can pass, and beating a reference is the point.\n- **`amount`** names the select that SIGNS it: `signed_by`, a select on the same\n  entity, and `outflow`, the options of that select under which the amount is\n  money going out. Without it every shape over the ledger adds both directions\n  together: a month whose net was small reads as the total of everything that\n  moved, and the trend plots one rising line. The two come together, and\n  `outflow` is some of that select\'s options, never all.\n- **`expected_set`** names what CONDITIONS the set: `required_by`, a field on the\n  same entity, and `options`, which of that field\'s values require which entries.\n  A row whose value is not named requires nothing. Without it the denominator is\n  every option, so a set whose entries are mutually exclusive by kind reads\n  `1 of 4` on every complete row \u2014 a denominator no row can reach is worse than\n  no role. The field is a single `select`, keyed by its option aliases \u2014 or a\n  YES/NO the row answers itself (a `boolean`, or a formula resolving to one),\n  keyed by `"true"` and `"false"`: a check that FAILED owes its consequence \u2014 the\n  photograph, the owner, the day it is due \u2014 and there is no select of the record\n  that says so.\n- **`obligation`** names what CLOSES it: `satisfied_by`, a `date` or a `files`\n  field on the same entity \u2014 the day it was done, or the paper that proves it \u2014\n  and optionally `label`, what is OWED as the reader says it ("G\u1EEDi SI"), which is\n  not what the column holding the date is called ("SI cut-off"). Both are\n  required in the sense that matters: without the stamp every obligation the\n  business ever met stays on the desk, so the role is refused without one.\n\n```jsonc\n"field_roles": {\n  "product": { "name": "identity", "photo": "mark" },\n  "stock":   { "on_hand": { "role": "measure", "against": "minimum", "alert": "under" },\n               "uptime":  { "role": "measure", "against": 80, "alert": "under" } },\n  "order":   { "stage": { "role": "lifecycle", "outcomes": ["delivered", "cancelled"] },\n               // The day the papers are owed by, and the day they went.\n               "papers_due": { "role": "obligation", "label": "File the papers", "satisfied_by": "papers_sent" } },\n  // `kind` is the direction select \u2014 options `received` and `paid_out`, no role of its own.\n  // Every figure on a quotation is in the currency that row names.\n  "quote":   { "unit": "currency", "total": "amount" },\n  // What the price is quoted off, so the item\'s page reads one against the other.\n  "service": { "price": { "role": "amount", "against": "list_price" } },\n  "payment": { "value": { "role": "amount", "signed_by": "kind", "outflow": ["paid_out"] },\n               // A receipt owes a receipt voucher; a payment owes an invoice and a payment voucher.\n               "papers": { "role": "expected_set",\n                           "required_by": { "field": "kind",\n                                            "options": { "received": ["receipt_voucher"],\n                                                         "paid_out": ["invoice", "payment_voucher"] } } } },\n  // A CHECK THAT FAILED OWES ITS CONSEQUENCE \u2014 keyed by the row\'s own answer,\n  // and the answer that owes nothing is omitted rather than named with an empty list.\n  "check":   { "passed": "verdict",\n               "evidence": { "role": "expected_set",\n                             "required_by": { "field": "passed",\n                                              "options": { "false": ["photo", "owner", "due"] } } } }\n}\n```\n\nIn a file that starts from a preset (\xA7 Starting from a preset), `field_roles`\nmay name the preset\'s fields as well as this business\'s own; a role the preset\ndeclares itself is kept unless this file names the same field, and `null`\nclears it.\n\n## Write rules\n\n`write_rules` is what only a CREATE meets \u2014 keyed by entity alias, like\n`field_roles`, and this file\'s in the same way: `check` proves it and the\nworkspace never sees it. An update names one field that moved; a create takes a\ndraft whole, so it has to know which row a name already belongs to, where a\nvalue comes from when nobody types it, and what a figure or a picker may hold.\nThe generator writes one `create_<entity>` workflow and one `New<Entity>Dialog`\nper entity an app can operate, from these clauses and the fields\' own\n`required`.\n\n```jsonc\n"write_rules": {\n  // A customer is RECOGNISED by their address. Where an entity names a customer\n  // as its `party`, the create takes the email instead of a picker, reuses the\n  // row it matches and mints one only where nothing does \u2014 so the book never\n  // grows a second Acme because somebody typed the name differently.\n  "customer": { "natural_key": ["email"] },\n  "order_line": {\n    "fields": {\n      // A line of nothing is not a line. Refused on create and on update, at\n      // the control the figure was typed into.\n      "quantity": { "min": 1, "max": 9999 },\n      // The price is fixed at the moment of ordering \u2014 COPIED off the product,\n      // not looked up for ever after, so the price list moving next week does\n      // not silently reprice an order already placed.\n      "unit_price": { "default_from": "product.price" },\n      // And nothing is sold off an empty shelf. The picker reads only the rows\n      // that answer this, and the write refuses the same rows again \u2014 a caller\n      // who never opened the picker is bound by it too.\n      "product": {\n        "options_where": {\n          "node_type": "group", "logic": "and",\n          "children": [{ "node_type": "condition", "type": "number",\n                         "field_key": "in_stock", "operator": "greater_than", "value": 0 }]\n        }\n      }\n    }\n  }\n}\n```\n\n| Clause | On | Meaning |\n|---|---|---|\n| `natural_key` | the entity | the field aliases a row is recognised by. A `text` key declares `unique: true` on the field itself \u2014 two rows sharing it would make find-or-create pick whichever the read answered first \u2014 and a key is `text` or `number`, because a person types it back |\n| `default_from` | a field | `"<link alias>.<field alias>"` \u2014 the value is copied from the linked row when the row is created, never asked. The link is a one-row link on this entity and `required`, because there has to be a row to read, and the two field types must match |\n| `min` / `max` | a `number` | the figure is refused outside them, on create and on update |\n| `options_where` | a `select_record_link` | an `and` group of plain conditions over the TARGET\'s own fields, each `field_key` a field alias. It narrows the picker\'s read and is refused again where the write lands, so the link is `required` |\n\nA field\'s own `required` is not here: the contract carries it, every write path\nrefuses the row by field name from it, and the generated panel stands its commit\ndown until the same set is filled. `unique` is the text field\'s own clause\n(\xA7 `text`) \u2014 the create says so at the control before the column does.\n\nWhat a create asks is what a person STATES. A `default_from` field is not drawn,\na `lifecycle` opens at its first rung, the stamp an obligation\'s `satisfied_by`\nnames is not asked (the row is only now taking that on), and files are attached\nto the row afterwards \u2014 one fact, one place. `scaffold check` prints every clause\nunder its entity in **Who writes what**.\n\n**The `parent` is prefilled only in the door that mounts the act.** A row opened\nfrom the record it hangs under takes that record from the door it was pressed\nin, so the link is neither asked for nor drawn. The same entity\'s act on its own\nregister has no such row, so there the parent is an ordinary picker the draft\ncannot be committed without \u2014 a payment opened from a money app belongs to a\ncase either way.\n\n## Apps and screens\n\n`apps` is the plan: each app the reader will build, as ONE REGISTER \u2014 a SHAPE\nover an ENTITY \u2014 under `screen`. Nothing here is built by the scaffold: the plan\nis what `lotics scaffold check` prints back, register by register with the field\nin every slot, so it is read and corrected before a screen exists.\n\n**ONE APP IS ONE REGISTER AND THE RECORDS IT OPENS.** A second register beside\nit is a second job on one page: the reader arrives on whichever the nav listed\nfirst and decides, every time, which of the two they came for. So an app has one\ndestination and everything else about a row is DISCLOSED by opening it \u2014 the\nfacts by tier, the children as lists, the related as counts, one primary act, and\na filter or a group where a strip of destinations would have been. What used to\nbe a second screen is a section of the record, or another app; a model still\nsaying `screens` is refused by name.\n\n**The unit of an app is a JOB, not a person and not a table.** A job has its\nown outcome (something exists or is settled when it is done), its own subject\n(the record it advances), and an end that does not wait on the rest of the\nwork. Two tasks are ONE job when neither finishes without the other and both\nadvance the same record. One app per job, and that is what makes an app a\nwrite-ownership boundary: what the job settles is its app\'s alone to write,\nplus everything it must read to settle it well. A person holding several jobs\nopens several apps \u2014 one app for everything one person does is the dump. A step\nof the job is a section of the record, never a register beside it; a reference\nthe job needs at hand is read inside the record it is about.\n\n**Two people signing is two jobs**, because the outcome belongs to the signer:\nthe desk that prepares against the gate that releases. So is a different\ncadence \u2014 reference data edited monthly and read by the public site, beside a\ndaily desk \u2014 and a different reader, the owner\'s read-only questions. Device,\nplace and step never split a job. A super app holds more than one job; an\nover-split holds less than one, a job cut by device, place or step. The count\nper workspace falls out of the jobs, typically two to six, and is never the\ninput: review the plan app by app, naming who holds it, the job in one\nsentence, what it writes and what it reads.\n\n*A two-van appliance repair shop.* The technician\'s job is the call-out: the\noutcome is a visit done, the subject is the call-out record, and quoting it and\nscheduling it are one job, because neither finishes without the other and both\nadvance that record. The owner holds two of his own \u2014 billing the month\n(outcome invoiced, subject the invoice, settled against visits already closed)\nand the price list the booking page quotes from, edited monthly. Three jobs,\nthree apps, and the owner opens two of them.\n\n**Inside a job the caps hold**: six flow stages on a desk, seven facts before a\nrecord\'s fold. Past them, look for the second job hiding inside. And a job\'s app\nis DENSE: every create the job needs lives in it, so its user never leaves it to\ncorrect a figure the screen in front of them is stating \u2014 three workflows is a\nscreen, not a desk.\n\n**A handoff is a stage change.** Where one job ends the record moves stage and\nthe next job\'s desk opens on it; a field two jobs must both write is declared\nshared at the split, naming the stage each may write it in.\n\n**Name an app for the JOB, in the trade\'s own words, never for who it is for.**\nA title on the door says nothing about what the person who opened it came to\ndo, and it is wrong the day the org chart moves.\n\n```jsonc\n"apps": [\n  {\n    "alias": "sales", "name": "Sales",\n    "description": "\u2026", "icon": "briefcase", "theme": { "color": "blue" }, // optional\n    "screen":\n      { "alias": "orders",    "label": "Orders",    "shape": "lifecycle_desk", "entity": "order",\n        "record": "drawer",                  // optional \u2014 "drawer" | "page"; absent, the shape decides\n        "tabs": "stage",                     // optional \u2014 a select on the entity, or null; absent, the shape decides\n        "writes": false,                     // optional \u2014 default TRUE; false makes this screen a reader\n        "period": "due_date",                // optional \u2014 any field whose value is a date, derived ones included\n        "filters": ["kind",                  // optional \u2014 a single-select, or a lens the model states itself\n                    { "label": "Qu\xE1 h\u1EA1n l\u01B0u", "predicates": [\n                      { "label": "\u0110\xE3 qu\xE1", "tone": "red",\n                        "where": { "node_type": "group", "logic": "and", "children": [\n                          { "node_type": "condition", "field_key": "owed", "operator": "greater_than", "value": 0 }] } }] }],\n        "summary": { "totals": ["total"], "above": ["total", { "field": "owed", "at": "end" }],\n                     "ageing": { "amount": "owed", "due": "due_date", "buckets": [30, 60, 90] } },  // optional \u2014 see below\n        "facts": { "groups": [{ "caption": "Pricing", "fields": ["rate", "surcharge"] }] },  // optional \u2014 the record\'s named bands\n        "presentation": { "lead": "none", "density": "dense" },  // optional \u2014 how it is DRAWN; absent, what the rows are decides\n        "acts": { "row": [{ "label": "Issue the note", "template": "debit_note", "place": "cta" },\n                          { "kind": "agent", "label": "Read the papers", "agent": "reader", "fills": ["ref", "due_date"] }],\n                  "record": [{ "label": "Print the file", "template": "dossier" }],  // optional \u2014 the record\'s own header menu\n                  "selection": [{ "label": "Statement", "template": "statement" }],  // optional \u2014 the work it hands on\n                  "export": true,                                                    // optional \u2014 the rows in view, saved\n                  "import": { "kind": "import", "label": "Upload the sheet",         // optional \u2014 a file turned into rows\n                              "entity": "order", "key": "code", "columns": ["rate"] } },\n        "section_acts": { "line": [{ "label": "Chase the lines", "template": "chaser" }] },  // optional \u2014 a verb on one section\n        "slots": { "identity": "code",       // optional \u2014 slot \u2192 field, where the roles cannot decide alone\n                   "stage": { "field": "state", "quick": true } } }  // \u2026or the field AND the reader\'s own control for it\n  }\n]\n```\n\nA shape is a proven screen with named SLOTS, each filled by a field carrying a\nrole (\xA7 Field roles). A slot with exactly one candidate on the entity binds by itself;\ntwo candidates need naming in `slots`; a field fills one slot; a required slot\nwith none is refused \u2014 a lifecycle desk over an entity with no `lifecycle`\nselect cannot be built.\n\n**A QUICK SLOT IS FOR A DECISION THE READER MAKES FROM THE ROW ALONE.** A slot\'s\nvalue in `slots` is normally the field\'s alias; `{"field": \u2026, "quick": true}`\nsays the column is not a reading of that value but the CONTROL for it \u2014 pressed,\nit writes that one field as a diff through the record\'s own update, so the\nregister and the page behind it land the same write. Only two roles are such a\ndecision, and `quick` on any other is refused: a `lifecycle`, which rests as the\nstage chip and opens the field\'s own stages with the ones that END the flow last,\nand a `verdict`, which is the switch. Both carry the record\'s own blockers \u2014 a\nmove the ladder holds is a move the cell holds, and it names the entries the row\nstill owes \u2014 and an outcome asks before it commits. Add `"order": "sequence"`\nwhere the stages are a WALK rather than a set of destinations: the cell is then\nthe next step alone, the same advance `RecordProgress` draws under the run, and\nthe doors out of the flow stay on the record. A screen stating `writes: false`\nrefuses `quick`: a reader who may operate nothing has no decision to take.\n\n| Shape | Answers | Required | Also fills | Record | Tabs |\n|---|---|---|---|---|---|\n| `lifecycle_desk` | what is stuck, what do I move next | `lifecycle`, `identity` | `mark`, `party`, `amount`, `measure` (level), `when` | page, or drawer where the entity carries `parent` | the lifecycle\'s stages |\n| `party_register` | who is this, our history, is there a risk | `identity` | `mark`, `contact`, `measure` (worth), `verdict` (risk) | page | none |\n| `offering_register` | what do we offer, at what price, can I sell it | `identity` | `mark`, `amount` (price), `measure` (availability) | page | none |\n| `transaction_ledger` | does this period reconcile, what is unexplained | `when`, `amount` | `identity` (reference \u2014 the line\'s own number), `party`, `lifecycle` (classification), `expected_set` (document) | drawer | none |\n| `monitored_asset_set` | what needs attention, is that number normal | `identity`, `measure` (level) | `mark`, `lifecycle` | drawer | none |\n| `obligation_desk` | what is due next, and has it been done | `identity`, and at least one `obligation` on the entity | `when` (runway) | page | none |\n| `trend_deep_dive` | how did the period go, and why | `when` | `measure`, `amount` | drawer | none |\n| `reconciliation_desk` | what does not match, and by how much | `identity` (reference), and two figures \u2014 `ours` and `theirs`, each an `amount` or a `measure` | `category` (reason), `verdict`, `when` | drawer, on the PAIR | the dated runs, where the model names a select |\n| `entry_matrix` | one value per subject per period | `identity` (subject), `across` \u2014 a `when`, or a `category` for a fixed column set | `measure` (value), `lifecycle` (state), `category` (note) | drawer, on the cell\'s row | none |\n| `guided_run` | complete an ordered sequence, a step at a time | `identity` (step) | `slot` (sequence), `capture` \u2014 a `measure`, `verdict` or `expected_set` \u2014 `verdict` (gate), `mark` (media) | page: the run IS the record | none |\n| `live_board` | is everything OK, right now | `lifecycle` (state), `identity` | `verdict` (exception), `when` (since), `measure` (level), `category` (where) | drawer | none |\n| `group_register` | what does each group come to, and what is behind it | `subject` \u2014 a `category`, `party` or `when` | `amount`, `measure`, `identity` (member) | page: a row is an aggregate, and the door is the SET behind it | none |\n| `media_set` | scan a body of pictures by where they belong | `mark` (picture), `identity` | `category` or `party` (group), `when`, `verdict` (current against superseded) | drawer | none |\n| `day_sheet` | what happened on each day | `when` (the day) | `lifecycle` (state), `measure` (level), `amount`, `category` (note) | page: a day composes several child logs | none |\n| `resource_schedule` | what is on each resource, in what order, under what ceiling | `lane` \u2014 a `party` or a `parent` \u2014 `identity`, `when` (the start) | `measure` (duration), and `load` and `bulk`, each a `measure` read against a ceiling of the LANE\'s \u2014 a vehicle fills by weight and by room and stops at whichever runs out first; `lifecycle` (stage) | drawer, over the lanes | none |\n| `worksheet` | priced lines the reader edits, totalling to one figure | `identity` | `category` (group), `measure` (quantity), and `cost` and `sell`, each an `amount` or a `measure` | drawer, per line | none |\n\n**A record is one of five KINDS, and the shape plus the roles decide which.**\nEvery one of them is ONE READING COLUMN, and the ORDER of that column is the\nwhole of what the kind means.\n\n| Kind | The column, top to bottom |\n|---|---|\n| WORK RECORD \u2014 a `lifecycle_desk` over rows belonging to nothing | the one act that moves it \xB7 what it IS \xB7 the papers it owes \xB7 the rows it is made of \xB7 the book of what it came to \xB7 its own words |\n| LINE \u2014 the same shape over rows carrying `parent` | its ladder \xB7 the arithmetic behind its amount \xB7 the rows and papers under it \xB7 its particulars, last (the key it is filed by is the line under its title) |\n| PROFILE \u2014 a `party_register` | its history, OPEN, grouped by year \xB7 the rest of its registers \xB7 its own words \xB7 its facts (the ways to reach it are under its name, its settlement is the band) |\n| CATALOGUE ITEM \u2014 an `offering_register` | its own words (the picture leads the header at media scale, the price is read against its reference in the band) \xB7 what uses it \xB7 its facts |\n| EVIDENCE \u2014 a `transaction_ledger` | the PROOF \xB7 what the paper is, compactly \xB7 the rest \xB7 the links to the record it settles and the party it was with |\n\nNothing in the file states the kind: a clause that could say it could say the\nwrong one, and `parent` already says whether a row stands alone. `record`\noverrides the DOOR where the shape\'s own answer is not the one wanted \u2014 and its\nthird value, `"expand"`, is not a door at all: the row REVEALS what it holds in\nplace, where there is nothing behind it worth navigating to. A row read that way\nreads as a LINE whatever the shape would have opened: its ladder, the arithmetic\nbehind its amount, then its particulars, because there is no header above it to\nhave stated the name first. It is REFUSED for two reasons, and they are not the\nsame refusal. On a shape whose record is a page by nature \u2014 a `guided_run`, a\n`group_register`, a `day_sheet`, an `obligation_desk` \u2014 because each of those\nstates the opposite where its door is declared: what its row leads to is read\nwhole, not as four more columns than the register had room for. And on a shape\nthat draws its rows with a device of its OWN \u2014 an `entry_matrix`, a `media_set` \u2014\nbecause a cell of a grid and a tile on a wall have no band under them for the row\nto reveal into. For the same reason a revealed register is drawn as a TABLE: a\n`presentation.layout` of anything else is refused, and the reader is not offered\nthe arrangement either, since it would take away the only door the register has.\n\n**`scope` \u2014 the one subject every read of the app narrows to.** Stated on the\nAPP rather than on its screen, because it is not a filter: a record opened under\nit stays under it, the pick survives closing the app, and every app declaring the\nsame `entity` shares one pick per viewer \u2014 which is the whole value, and what\nstops a construction workspace asking which project twelve times. `entity` is the\nmodel\'s entity whose one row the app is read inside, and `param` is what the\napp\'s reads take that row by.\n\n```jsonc\n{ "alias": "site_work", "name": "Site work",\n  "scope": { "entity": "project", "param": "project_id" },\n  "screen": { \u2026 } }\n```\n\nThe register\'s own entity has to REACH it \u2014 its own rows, or rows that name one\nthrough a link \u2014 or the switcher is a control that changes nothing. Until a\nsubject is picked the app reads NOTHING and says which one it is waiting for: an\nunscoped read over a scoped app is every row in the workspace drawn as one\nproject\'s work, which looks correct.\n\n**ONE RECORD SURFACE PER ENTITY, AND ITS KIND IS THE ENTITY\'S.** An app is one\nregister, so the record its rows open is the register\'s own and the kind comes\nfrom that register\'s shape. Another app over the same entity opens the same kind\nof record: a payment read from a cash book and one read from a trend are both\nmovements, and both read proof first. A shape with no kind of its own (a trend, a\nmonitored set, a `custom` screen) says only where the record opens.\n\n**Two things a register states about a row beyond which field fills which slot.**\nA `measure` is read AGAINST its limit (`against`/`alert`) where the shape\'s slot\ntakes one \u2014 `level`, on a lifecycle desk and a monitored set, and every slot of a\n`custom` screen, which composes the frame\'s own column; `worth`, `availability`\nand a trend\'s headline are plain figures, and a limit there would read as a meter\nin the record over a number the row printed bare. And the name carries a\nSUPPORTING LINE where the entity states a key to file the row under: the `parent`\nit belongs to, its `reference`, an `autonumber`, a text formula \u2014 in that order,\nfirst hit wins, never a field a person types prose into. A LINE\'s record heads\nwith that same key, so the register and the door it opens name one row one way.\n\n**The act that opens a row belongs to a register that LISTS the entity\'s rows**\n\u2014 a desk, a register, a ledger, a monitored set, or a `custom` screen. A shape\nwhose rows are not records has neither that act nor the door a counted line\nelsewhere leads to: an obligation desk\'s rows are deadlines and a trend\'s are\nperiods, so a create pressed there would open a row the screen cannot show. An\nentity whose only app is one of those has no create at all \u2014 give it an app whose\nregister its rows are read in.\n\n**An `obligation_desk`\'s rows are not its entity\'s rows.** The shape fans the\nentity\'s `obligation` fields out \u2014 one row per thing still owed, which is one\nwhose date is SET and whose `satisfied_by` is empty \u2014 so a l\xF4 with four cut-offs\nis four rows, and the three it has met are not there at all. The row\'s name is\nthe obligation\'s, its supporting line the record\'s `identity`, and the door is\nthat record. A `when` bound to `runway` is what the countdown\'s ring is measured\nfrom. Over an entity declaring no `obligation` the shape is refused: there is\nnothing to count down to.\n\n**What a register carries beyond its columns.** Six clauses, each emitted as\nthe prop the kit draws it with; every one is optional and a screen that states\nnone gets a register of columns and nothing else.\n\n- **`period`** \u2014 a field on the entity whose value is a DATE. The toolbar gains a\n  date-range control (this month to start), and the rows it keeps are what the\n  register AND every figure below are computed over, so a band can never be over a\n  different window than the rows under it. Any such field, not only the `when`\n  role, and however the date got there: one table is read two ways (a cost ledger\n  by the day a line arose, the cash book over the same table by the day it\n  settled), a role is one field\'s, and the day money MOVED is often a formula over\n  the two columns that could hold it \u2014 which then declares `output_type: "date"`.\n  A `trend_deep_dive` brings its own period and takes none here; a `live_board`\n  is PERIODLESS and takes none either, for the opposite reason \u2014 it answers what\n  is true NOW, and a date range over it draws what was true in the window in the\n  live state\'s own colours.\n- **`filters`** \u2014 the chips beside the search. A single-`select` field\'s alias\n  offers that field\'s own live options; it is the lens a register is read through\n  over and above the one band its strip gives, so the strip\'s own field is\n  refused here (one dimension, one control) and so is a multi-select (a row would\n  answer the chip several ways at once). The rows the register and every figure\n  below are computed over are what the chips AND the period kept.\n  A DERIVED LENS is the other form \u2014 `{"label": \u2026, "predicates": [{"label": \u2026,\n  "tone": \u2026, "where": \u2026}]}` \u2014 where the sets a reader narrows by are ones the\n  MODEL names and no column holds: rate validity, plan urgency, free-time\n  overrun. Each `where` is an `and` group of plain conditions over the entity\'s\n  own fields, each `field_key` a field alias, and it is read off the row, so the\n  operators are the comparisons a value answers \u2014 `number` and `text` equality,\n  `number` ordering, `boolean` equality, `select` `has_any_of`/`has_none_of`, and\n  `is_empty`/`is_not_empty` on any of them. Nothing DATED: a relative point needs\n  a clock, and a screen states one date control (`period`), so a second beside it\n  would be two windows with nothing saying which a figure was computed over \u2014 a\n  date question is asked as a column the model derives and read here as a number\n  or a yes/no. `tone` is the option palette\'s, because the chip draws these\n  exactly as it draws a select\'s options.\n- **`summary`** \u2014 what the rows in view come to. `above` is a band OVER the\n  register: `"counts"` for how many rows are in view and, for the FIRST\n  `measure` the model gives a limit, how many are past it (accented only when\n  one is) \u2014 one such set, because a band naming three is the dashboard a\n  register is not; a list of number-field aliases for what they add up to, and a\n  `percentage` named there is refused, since a share summed over the rows in\n  view is a figure of no kind (draw it as a column, whose own total reads the\n  mean). A figure written `{"field": \u2026, "at": "end"}` is a STOCK instead: the\n  reading standing at the END of the window rather than the sum of the readings\n  in it, which is the only way opening + in \u2212 out = closing reconciles \u2014 a month\n  of daily closing stocks added together is thirty warehouses. The band labels it\n  as the snapshot it is, and it is refused on a screen that states no `period`,\n  since there is then no window for it to stand at the end of.\n  `ageing` stands in that same\n  band: an `amount` split by how many days past its `due` date each row is,\n  drawn as a `Breakdown` of the edges in `buckets` (30, 60 and 90 days unless the\n  model states its own, ascending). The ladder is the kit\'s \u2014 its boundary, its\n  words and its ramp \u2014 and it opens with what is NOT YET DUE, because a bar of\n  overdue bands alone is full at every input: a book with one late invoice and a\n  book that has gone entirely bad would paint the same solid width. Against the\n  current money the bar\'s own shape is the reading. A row whose date is empty is\n  in no band. `totals` is what the whole\n  view adds up, and it is drawn in that SAME band above the rows: a register\n  states one aggregate, over the rows the reader can see, in one place, and a\n  closing line under them is a second place to look and a second question about\n  which rows it covers. A closing line belongs to the one device that IS a\n  statement \u2014 a record\'s `Ledger`, whose balance is what it is read for, labelled\n  by its amount\'s own word. Where a shape has no band above (a trend, whose own\n  band is the chart) the figure stands under the register instead. A\n  `transaction_ledger` sums its amount column itself and takes `above` alone. An\n  `obligation_desk`\'s rows are DEADLINES and not records, so its band states\n  `"counts"` \u2014 how many are open \u2014 and a figure list or an `ageing` over it is\n  refused: a l\xF4 with three cut-offs is three rows, and its freight added over\n  them is three times the freight.\n- **`facts`** \u2014 how the RECORD\'s facts are banded. `groups` is a list of\n  `{caption, fields}`: what a set of facts has in common is a sentence about the\n  business and nothing derives it, so a plan that states one gets exactly those\n  bands, in its own order, captioned. Everything it leaves unnamed reads in the\n  derived order below it. A field the header, the band, the ladder, a required\n  set, the files or a register below already draws is refused: it is not a fact,\n  so a band naming it would either state it twice or draw nothing. Naming any\n  band IS the answer to which facts fold \u2014 see the TIERS below.\n- **`presentation`** \u2014 how the screen and the record it opens are DRAWN, where\n  what the rows are is not the answer wanted. `lead` is what each row leads\n  with: `"mark"` the subject\'s own mark, always spent because a party\'s initials\n  stand in for a picture nobody uploaded; `"picture"` the photograph, spent only\n  on the rows that carry one and, on the record, at media scale above the name;\n  `"figure"` the amount, with no gutter at all; `"none"` neither. `density` is\n  how many lines a row\'s subject may take \u2014 `"roomy"` two, `"dense"` one.\n  Both default, and the DEFAULT is what the rows are: a party register leads\n  with the mark, an offering register with the picture, a ledger with its\n  figure, and a desk \u2014 rows that are work still to do, scanned \u2014 stands its rows\n  one line each while a record\'s own rows are read roomy. So state it only to\n  differ, and a plan that states nothing still gets screens that vary. A lead\n  the rows cannot carry is refused: a mark where no field is drawn as one, a\n  figure where no column is the amount, and the other subject\'s mark (which of\n  the two a row wears is the shape\'s, so the register and the record it opens\n  cannot call one row two kinds of thing).\n  `layout` is how the rows are ARRANGED \u2014 `"table"`, `"list"`, `"cards"`,\n  `"gallery"`, `"board"`, `"calendar"`, `"timeline"`, `"gantt"` \u2014 and it is\n  AFFORDED by what the rows carry, not by the shape: every register affords a\n  table and a list, a `mark` affords the two picture-led grids, a `lifecycle`\n  affords a board, a `when` affords a calendar and a timeline, and a `when`\n  beside a `measure` affords a gantt, because a bar with no length is a calendar\n  drawn sideways. A layout the bound roles do not afford is refused, naming the\n  ones they do.\n- **`acts`** \u2014 where this screen hands work on: `row` is the \u22EF menu on every row,\n  `record` is the \u22EF on the RECORD\'s own page header \u2014 the same reach as a row\'s,\n  standing where the work is open instead of while a list is scanned, and refused\n  on a record that opens as a drawer, which has no header of its own and whose\n  row already carries the register\'s menu \u2014 and `selection` is the bar over the\n  TICKED rows. `export` is the third reach \u2014\n  the WHOLE VIEW, saved in one press: `true` writes the rows as the register drew\n  them, in the columns it drew, as an `.xlsx`, and\n  `{"template": "\u2026"}` says the layout is the trade\'s and makes the paper with a\n  workflow like any other. It is never a list of columns: which columns the\n  export carries is what the screen already draws, and a second statement of it\n  disagrees the moment a slot moves \u2014 the generator reads them off the drawn\n  slots and writes them into the app, so the sheet\'s headings are the labels the\n  register drew them under.\n  `import` is the reach OPPOSITE it \u2014 a file turned into rows:\n  `{"kind": "import", "label": \u2026, "entity": \u2026, "key": \u2026, "columns": [...]}`. The\n  file is mapped column by column, each row is validated, what would change is\n  previewed, and the commit UPSERTS by `key` \u2014 which is why a sheet sent twice\n  moves no counts. That key is one of the entity\'s own `natural_key` fields\n  (\xA7 Write rules), and an entity declaring none is refused: without a key the\n  second run is a second set of the same rows. `entity` is the register\'s own \u2014\n  an app is one register, and rows filed into another entity are a count nobody\n  on this screen can check. `columns` is what the sheet may fill, in that order;\n  absent, it is every column a person states IN WORDS. A computed one is refused\n  because the workspace writes it, and a link, a member or a files column is\n  refused because a cell of a sheet is words and those hold a row of another\n  table or bytes \u2014 a file reaches another table through the party pattern (a\n  `natural_key` on the target, named rather than picked), which is a create\'s.\n  The generator writes the whole verb, as it does for a paper: an\n  `import_<entity>` workflow that finds the row by `key` and then changes it or\n  opens it, answering which of the two, and the staged run over it \u2014 drop, map,\n  the per-row verdict, the commit. A line whose cell the column cannot hold is\n  refused with the reason and the rest of the sheet still lands.\n  Both spreadsheet reaches are read and written IN THE BROWSER, so the generated\n  `src/main.tsx` imports `@lotics/app-runtime/sheets` wherever the plan states\n  one of them and not otherwise; an app that has neither carries no spreadsheet\n  engine at all. An act names ONE of two things, never both:\n  - **`template`** \u2014 an `html` template this model declares (\xA7 Templates). The\n    paper is filled from ONE row in `row`, and from the whole ticked set in\n    `selection`. The generator writes the whole verb \u2014 a `generate_<template>`\n    workflow that reads the row and hands the file back, and a menu item that\n    opens it \u2014 so there is nothing left to bind. An `email` template is sent\n    rather than opened and is refused here; a file-backed template (`excel`,\n    `word`, `pdf-form`) is bytes a model has none of, so those stay the author\'s\n    own `lotics app workflow set`. Two screens over DIFFERENT entities cannot\n    name one template: one paper is filled from one kind of row.\n  - **`{"kind": "agent", \u2026}`** \u2014 a run over ONE row. `agent` is an alias the APP\n    declares (`package.json#lotics.agents`), because an agent is prose and tools\n    rather than anything a workspace model can state \u2014 `lotics app check` refuses\n    one nothing declares, exactly as it refuses a workflow nothing bound. `fills`\n    is the fields the run may write: pressed, the reader watches the run, reviews\n    what it proposes field by field against what the row holds now, and applies\n    the ones they kept as ONE write through the record\'s own update. A run can\n    reach nothing outside `fills`, a computed column there is refused (the\n    workspace writes those), and a screen stating `writes: false` refuses an\n    agent act outright. It belongs in `row`; the selection bar makes ONE paper\n    from many rows, and a run per ticked row is the row\'s own act many times.\n\n  **`"place": "cta"` draws an act ON the row** instead of in its \u22EF \u2014 the one verb\n  a reader presses without opening a menu first. At most one per screen and every\n  other act stays in the menu, because the trailing gutter is paid for by every\n  row: a second is refused with *one verb on the row, the rest in its menu*. The\n  ticked set has no row of its own, so `cta` is refused there.\n\n  Every other verb \u2014 record an interaction, close a request, push a voucher \u2014 is\n  a workflow the author writes and binds with `lotics app workflow set`; a plan\n  that could name one would scaffold a button wired to a body nobody had written.\n\n  A `selection` act is a `template` and nothing else: an act over many rows makes\n  ONE paper from them. The generator turns the register\'s checkbox gutter\n  on, emits a `generate_<template>` workflow taking the ticked ids, and the body\n  reads each row and passes them as `rows` \u2014 which is what the template iterates\n  (`{{#each rows}}`). One template is one paper AND one reach: naming the same\n  one from a row\'s \u22EF and from the bar is refused, because those are two bodies.\n  A shape whose rows are DERIVED rather than records \u2014 an `obligation_desk` \u2014\n  has no set to tick and refuses the clause. The paper is handed BACK, never\n  filed: a ticked set can hold rows of three different parents, so there is no\n  record on which "this document belongs here" is true.\n\n**`section_acts` puts a verb WHERE ITS EFFECT LANDS.** "Chase the paperwork"\nbelongs on the papers, not in the register\'s \u22EF two surfaces away. It is keyed by\nthe alias each section is DERIVED from \u2014 a field\'s (its progress, its prose, its\nrequired set, its charge, one of its files) or a CHILD ENTITY\'s (its register,\nits desk, its run, its thread) \u2014 because the sections come off the roles and the\nkey the app addresses one by does not exist until it is built. An alias naming no\nsection is refused, listing the ones that do; the facts band is what every other\nsection left over, so nothing addresses it. Each act is a `template` or an\n`agent`, exactly as a row\'s is, and `place: "cta"` is refused \u2014 a section is a\nband with a heading and has no row to draw a verb on. `scaffold check` prints\nwhich section each alias landed on, which is the half an author cannot see in\ntheir own file.\n\n`scaffold check` prints every clause a screen states, on its own line under the\nslots, spelling the screen\'s `writes` clause `operable` \u2014 the app manifest\'s\n`lotics.writes` keeps that word, and the two are different facts: `app create`\nSEEDS the manifest from the fields the screens\' own editors write, and from then\non the app owns the declaration `lotics app check` holds its bodies to.\n\nEach shape is a `@lotics/ui` component of the same name (`LifecycleDesk`,\n`PartyRegister`, \u2026) whose props are these slots, so once the tables exist\n`lotics app create <name> --from <this file>#<app alias>` scaffolds the app with\none screen per entry, each slot reading the field the plan bound.\n\n`"shape": "custom"` is the screen no registry row covers: it declares its own\n`roles` (slot name \u2192 role), and it is emitted on `ShapeFrame` \u2014 the one anatomy\nthe six shapes above are each a configuration of \u2014 so its strip, search,\nordinal, fit budget, empty and waiting states and record door are the same ones\nthey have. It opens the record its `record` says, drawer or page, like any other.\nA bound `lifecycle` slot IS its strip, the stages in the field\'s order as on a\ndesk, so such a screen names no `tabs`; a `tabs` select is the flat strip a\nscreen with no lifecycle gets.\n\n**An app IS its `app.json`.** `create --from` writes the bound plan \u2014 every\nscreen with its shape and slots, the record each row opens with its sections in\nthe archetype\'s order, the create panels, the acts \u2014 as one JSON document, plus\na five-line `src/main.tsx` that mounts `@lotics/app-runtime` over it and one\n`src/workflows/<alias>.ts` per write. There is no screen source: the runtime\ndraws the spec, so a kit correction reaches every app with its next install.\nWhere the plan has no word for what a screen or a section IS \u2014 or for what a\npaper act should ASK before it is made \u2014 the spec names one of the app\'s own\ncomponents and `src/components/index.ts` registers it, the one file under `src/`\na regeneration never rewrites. `lotics app eject <screen|<section key>|<act\nlabel>>` writes each of those, starting from what the runtime already drew.\n\n**How a spec reads a row.** Each query projects its columns under the alias the\nworkspace mints from the field\'s LABEL \u2014 never the alias this file keys it\nunder, which is the model\'s own namespace and which the workspace never saw. So\na field this file calls `partner` and labels `\u0110\u1ED1i t\xE1c` is referenced as\n`doi_tac` throughout the spec. Every id in it is live: the `tbl_` a screen is\nover, the `fld_` of each column, and the `opt_` of every option a role names.\n\n**Every query is described, in the model\'s own language.** The line an agent\nchooses between aliases by is written from this file\'s nouns \u2014 the entity\'s\nlabel, the screen\'s, the link\'s \u2014 and the sentence around them is the language\nthe file is mostly written in, decided the same way a generated write\'s refusals\nare. Hand-editing one is erased by the next regeneration; `lotics app check`\nrefuses an alias that carries none.\n\nA screen is that list and the RECORD it opens, and the record comes off the same\nroles \u2014 nothing to declare for it. It opens with a **header**: the entity\'s\n`identity` as the record\'s name \u2014 whether or not the list has a column for it, so\na ledger\'s and a trend\'s records are named too \u2014 the `when` this screen reads\nunder it, and ONE headline\nfigure (the `amount` the screen reads, else its `measure`). BOTH DOORS state the\nname: which door a screen uses is a layout answer, and what the record is ABOUT\nis not.\n\n**A JOB\'S HEADER ALSO STATES WHO IT IS FOR.** Where the record is the work itself\n\u2014 a desk\'s rows that belong to nothing, opened on a page \u2014 its `party` is a link\nunder the name, beside the ways to reach the subject, and it is then not a fact\nas well: a page headed by a code alone said nothing about whose work it is, and\nthe one thing a reader arriving from the desk already knows the row by sat in the\ngrid below as a row among forty. A record opening in a DRAWER has no row of links\nto hang it on, so its party stays a fact; so does a LINE\'s, whose register files\nit under the thing it belongs to and whose party is that parent\'s, restated per\nrow.\n\n**A record whose figures are a SENTENCE states them under the header, in a\nband**, and the header then states neither of them: a job reads what it comes to,\nhow far through it is (the `measure` against its limit), what is left of it (a\nformula that is exactly `{amount} - {measure}`) and how long there is (an\n`obligation`, else its `when`, counted down); a party reads its settlement, the\n`amount` and `measure` roles it carries in the order the model declares them; a\ncatalogue item reads its `amount` against the reference that amount names. Two\nfigures are the floor and four the ceiling \u2014 under two, the header keeps its one.\nA band is a PAGE\'s strip, so a screen whose `record` is a drawer keeps every\nfigure where a drawer reads them. Each figure is drawn exactly once: the limit a\nmeter states is not a fact beside it, and the day a countdown counts to is not\nthe provenance line above it. The `lifecycle` is not badged there, because the progress section is the\nrung it stands on. Then its sections, in the order its KIND reads them: the\n**facts** (every field neither the header, the band nor another section owns, the\nrow\'s own `parent` among them \u2014 led by the ones THIS screen\'s slots bound, then\nthe key it is filed under, then the order the model declares them in),\nthe record\'s own **body** (every `text` field the entity formats as `markdown` \u2014\nprose read at the width of the work, never wrapped to a label in a column\nbeside it), the **charge** (where the `amount` is a formula over exactly one\nquantity and one money field, the line states `quantity \xD7 unit price = amount`\nand neither figure is typed twice \u2014 the section is headed by the amount\'s own\nlabel and the closing row says what the figure IS, so the word is said once),\nthe **progress** (the `lifecycle`\'s stages, and the ONE act that moves the record\non \u2014 every other move, outcomes included, is an item in the menu beside it), a\n**required set** (a multi-select `expected_set`, or a child entity whose rows\ncarry one entry of it each \u2014 that child\'s `files` field is what a paper attaches\nto), the record\'s **own rows** (any other child, its role-bound fields as\ncolumns), and its **files** (every `files` field, the `mark` first \u2014 a section of\nthe column like any other, straight after the facts it is the evidence for,\nexcept on an EVIDENCE record, which OPENS on the paper it exists for; the\nheading carries the Add verb, and stands it down while the pile is empty, where\nthe drop well is already the door; and a `verdict` whose FORMULA reads one of\nthose files fields is the pile\'s OWN state rather than a fact row \u2014 the file it\nis short, drawn as a ghost, and the mark the rail sends a reader to). A child is\nan entity that LINKS here, ONE SECTION PER LINK: the rows it owns (`parent`), the\nrows that name it (`party` \u2014 so a party\'s record is its history), and the rows\nreaching it through a link carrying neither role, headed by that link\'s own\nlabel. A child hanging off two records therefore declares one `parent` and\nleaves the second relationship a plain link, which still gets its section.\n\n**THE ROWS A RECORD OWNS ARE ADDED AND OPENED FROM THEIR SECTION.** A `parent`\nsection\'s heading carries the Add for its rows, handing the record as the\nparent \u2014 filled, never asked. Every row opens its own record \u2014 a line of a book,\na paper on a desk, a stop on a timeline alike: where this app already routes a\npage for those rows (the register\'s own, under one of them) it is navigated to;\notherwise it is a DRAWER mounted on the record it belongs to, stepped \u25C0 \u25B6 over\nthe section\'s rows as they are drawn, with the row\'s framed editors, its ladder\nand its files, saving through `update_<child>` \u2014 the one editor those rows have,\nwhich any control the section draws over a row writes through too. Never the\n`parent` link itself: it is the key the row is FILED under, stated by the record\nthe drawer was opened from, so it is neither a fact of the drawer nor an input\nof that editor. ONE LEVEL, and only from a PAGE: a child\'s own children draw as\nthe kit\'s panel of the row, with no drawer and no Add, and a register whose own\nrecord is a DRAWER is the same for the children it owns \u2014 a drawer mounts no\ndrawer. **A ROW IS ADDED WHERE IT CAN BE OPENED AGAIN**, so those sections lose\ntheir Add with their drawer; a row of the register\'s OWN kind keeps it, because\nthe register\'s list opens it. A correspondence\'s entries are the one owned row\nthat opens nothing anywhere: the composer under them is the section\'s Add\nwhatever door the record has, and the answer mark is one field of the reply\'s\nown editor. The rows a `party`\'s record lists, and those reaching a record\nthrough a roleless link, are read only \u2014 a history, never a place to open or\nadd.\n\n**TWO CHILDREN ARE READ AS A RUN RATHER THAN AS A REGISTER**, and the model says\nwhich by the roles it declares on them. A child carrying an `obligation` whose\n`satisfied_by` is a DATE is a **timeline**: its rows are the ordered stops, each\nstating the day it was promised for and the day it happened, with the delta named\nwhere the rung was late \u2014 drawn as a register those are two date columns and the\nreader subtracts them by eye, which is exactly what "three days late at\ndischarge" costs to learn. An obligation closed by a FILE says nothing about\nwhen, so those rows stay the register they were. A child carrying a `markdown`\ntext field beside a `party` and a `when` is a **thread**: the entry is the body,\nthe author and the day lead it, and a `verdict` on the child is the yes/no one\nreply is marked the ANSWER with \u2014 a register of messages is a table whose one\nuseful column is the one it cannot draw. A SECOND `party` on those rows is who\nthe entry was left WITH, and the latest one names the ball in court: while\nnothing answers, the record says whose move it is and counts its own deadline\n(an `obligation`, else its `when`) against them. Both are read only under the\nrecord that OWNS the messages \u2014 under the party who wrote them the same rows are\nthat party\'s history, several questions at once, and the last of them says\nnothing about any. That record also REPLIES: the section\'s Add is a composer \u2014\nthe message is all a reply asks \u2014 and the answer mark is one field of the\nreply\'s own editor.\n\n**NOTHING SITS BESIDE THE RECORD.** A page is ONE reading column \u2014 its fields,\nits files, the rows it owns, its notes, all sections of it in the archetype\'s\norder \u2014 over a reserved left gutter holding a floating NAVIGATION RAIL: the way\nback, then one line per section with that section\'s category mark, and nothing\nelse. No files, no counts, no group headings. Too narrow to seat the rail, it is\none pinned bar of the same list across the top. A section HEADING never wears\nthe mark; the rail\'s line for it does.\n\n**A RELATION THE RECORD NEVER ACTS ON CLOSES THE COLUMN.** Every register that\nmerely NAMES the record is one counted line of a single last section: its label,\nhow many rows name this record (a COUNT, never a page of rows measured), and a\npress that opens the register owning them narrowed to this record. An entity\nthis app lists nowhere is a count with no door, and where every count is zero\nthe section is not drawn at all. The one exception is a PROFILE, whose history\nIS its body and stands open in the column.\n\n**Rows the record owns whose `amount` is `signed_by` a direction are a\nBOOK**, drawn as a statement \u2014 each line dated and signed, the balance under\nthem where there is more than one line to add up, labelled by the amount\'s own\nword \u2014 where the same rows on the party they\nwere transacted with stay that party\'s history, which is scanned for the line\nshort of its paperwork rather than struck to a balance. **Rows that carry a\n`when` read as RUNS**: a party\'s history under the year \u2014 and only where the rows\nin hand span more than one, since a subhead over every line of a book names the\nyear and separates nothing \u2014 and a job\'s own rows under the day they fall on,\nwhich, where those rows also carry a `lifecycle`, is an ITINERARY rather than a\ngrouped table: the day heads the run, each row is one line (its `slot`, its name,\nits party, its stage, its `category` and `reference`, its amount), the figures end\non one edge and the run closes with their sum \u2014 unless the record\'s own BAND is a\nsum rollup over exactly these rows, which states it once already. A `category`\npaints the node the run is read down, in the option\'s own colour; a `reference`\ncloses the line with the code somebody quotes on the phone. Both are PROJECTED for\nthe run whether or not the register\'s column budget would have drawn them.\n**EACH DAY\'S HEAD CARRIES THE SECTION\'S OWN ADD** as well, handing the panel that\nday, so a line made from Tuesday opens with Tuesday answered; the heading keeps\nthe verb too, for the first line and for a day nothing is planned on yet. **THE\nKEY LEAVES THE COLUMNS where the head states the whole of it** \u2014 a day head does,\na year head states four digits of the date and the day is what the column is\nstill there to carry.\n**A run is READ FROM THE END THE READER WANTS**: a job\'s own rows and an itinerary\nascending, a book and a history descending.\n\n**A DESK OVER AN ENTITY THAT CARRIES A `slot` IS ITSELF A DAY\'S RUN.** Its own\nregister is drawn under one subhead per day, sorted by that day and then by the\npart of it, and the date column goes \u2014 the subhead states it once for the whole\nrun, and a column repeating it down every line is the same value twice. Without\nit an itinerary was one flat list in whatever order the rows arrived.\nA document desk keeps its head either way \u2014 the entries it owes are its\ncontent, filed or not. The name and whatever figure is left to it are the header\'s\nalone \u2014 it states them in full, so a fact for either would be the same sentence\ntwice.\n\n**A FACT IS PRIMARY OR IT IS PROVENANCE.** An `autonumber`, a date the platform\nstamps (`derive_from`) and a date a formula works out that no role names are what\nthe SYSTEM wrote; they fold, with every optional field this record does not\nstate, behind the grid\'s ONE link. Everything a person types or picks is primary\nand is shown, empty or not, because absence is work somebody owes. **A screen\nthat named `facts.groups` has already said which:** a field in a group is\nprimary, and one in none folds \u2014 grouping says what the reader decides with, and\nby saying so says the rest are not. A `tier` on a `facts` entry exists only for\nthe case that derivation gets provably wrong.\n\n**A `contact` field whose kind the\nmodel decides** \u2014 an email, a number, a place, a `link`-formatted text, or a\nMESSAGING APP its label names (WhatsApp, Zalo, Telegram, Viber, WeChat, Line,\nMessenger) \u2014 leaves the facts too, for the row of links under the name on a\nrecord that opens as a page; one whose kind nothing decides stays a labelled\nfact, because a scheme nobody stated is a link that opens nothing. A handle is\ndrawn under its app\'s name \u2014 the app is what identifies the person there, and a\nbare number beside an envelope says the wrong thing \u2014 and it dials only where its\nvalue IS a number.\n`check` prints the record under each screen\'s slots:\n\n```\n  Orders \u2014 lifecycle desk over Orders (12 rows) \xB7 page \xB7 tabs: Stage (New \u2192 Quoted \u2192 Confirmed \u2192 Shipped \u2192 Done)\n    stage Stage \xB7 identity Order no. \xB7 mark Photo \xB7 party Customer \xB7 amount Total \xB7 level (none) \xB7 when Due\n    record: header (Order no. \xB7 Customer) \xB7 band (Total \xB7 Shipped against Lines \xB7 Due counting down) \xB7 progress: Stage (5 stages) \xB7 facts (Ship to \xB7 \u2026 2 filed) \xB7 files: Photos \xB7 documents: Papers (Kind: 4 required) \xB7 itinerary: Order lines by Ship by at Window, kind Handling, ref Waybill (Product \xB7 Quantity \xB7 Line total) \xB7 related: Visits (count via Order)\n```\n\nThe ORDER of that line is the record\'s own, top to bottom, and it is the KIND\'s,\nand every entry of it is a section of the one column. `related:` is the counted\nline that closes it \u2014 a register the record never acts on, named and counted \u2014\nand `\u2026 N filed` is how many facts fold behind the grid\'s one link.\nA child register whose `amount` is `signed_by` a direction is a BOOK of movements\n\u2014 what the record came to rather than what it is made of \u2014 so it closes the\ncolumn rather than standing among the rows the job is made of.\n\n**A section over a child is named by the CHILD\'s own label**, because the reader\nalready knows which record they are on: "\u0110\u01A1n h\xE0ng", not "\u0110\u01A1n h\xE0ng \u2014 Kh\xE1ch h\xE0ng".\nWhere two links from one entity reach this record, that label names two sections\nand each takes its own link\'s label as a qualifier \u2014 `H\u1ED3 s\u01A1 (\u0110\u01A1n h\xE0ng)` and\n`H\u1ED3 s\u01A1 (\u0110\u01A1n g\u1ED1c)`.\n\nIn that line `documents:` is a `RecordExpectedSet`, and `lines:` a `RecordChildren` over the rows\nthis record owns \u2014 `history:` where they name it as their `party` instead; a required set\nwhose entries are a CHILD entity carrying files takes `kind="files"`, and the entity\'s own\nmulti-select takes `kind="items"`, since nothing attaches to an option.\n\n**A section that knows its size says so.** Where a `measure` on the record is a\n`count` rollup over the very link a rows section hangs on, the limit it is read\n`against` is how many rows that section is OWED: the printout adds `\u2014 expects\n<limit>` and the screen draws that many ghost rows until the first one lands,\ninstead of "nothing here" two bands under a count saying three are outstanding.\n\nA figure printed as `Total (USD)` is MONEY in the currency named \u2014 a `formula`\nstates it in `formula.currency`, and a `rollup` or a `lookup` inherits it from the\nfield it reads, so read those brackets: a rate that should be in dollars and is\nprinted bare will be drawn in the workspace\'s own money. Where the entity carries\na `currency` role, the ROW\'s code outranks the field\'s on every line that states\none, and a line stating none falls back to the field\'s.\n\n**A record surface can be OPERATED, and that is the default.** Every screen with\na record gets a workflow that writes its editable facts \u2014 every field a person\nstates \u2014 so the record\'s values are edited in place and its stage is advanced\nfrom the progress section. `"writes": false` makes one screen a reader: use it\nfor a screen over rows another desk owns, never as the default. A desk nobody\ncan act on is a viewer of state somebody must go and set somewhere else.\n\n**Which facts those are is the FIELD\'s answer.** Text, number, date, yes/no and\nselect are typed or picked. A `"cardinality": "one"` link is RE-POINTED, through\na picker over the target entity named by its `display_field_aliases` \u2014 else the\ntarget\'s `identity` \u2014 narrowed by what the reader types and carrying that\nentity\'s own `read_scope`, so a link the plan gives neither column is read\ninstead of offering an empty list. A files field is ATTACHED TO and DETACHED\nFROM, as the delta rather than the pile, so two readers filing at once each keep\ntheir file. A many-link, an `autonumber` and every computed field are read: the\nfirst is a list a fact cannot state, and the rest are the platform\'s to write.\n\n**A one-link is that fact WHATEVER its sync.** `sync_both_ways` is one relation\nwith a field on each side, and the sides are not the same surface: the record\nthat names ONE row states it as a fact, and the MANY side is the register on the\nother entity\'s record. Declaring both directions does not give this record a\nregister of the single row its own fact already names.\n\n**The write is the record SURFACE\'s.** Its inputs are the fields that surface\noffers to save \u2014 the facts with an editor, the lifecycle its ladder advances, and\na files section over exactly one stated field \u2014 never every field a person could\nin principle type. What the header states, a limit a meter folds in, a required\nset with a section of its own and the pile a page\'s mark draws are read there, so\nno input is declared for them. A second screen over the same entity draws no\nsurface of its own and adds nothing.\n\nWhere two operable screens of one plan reach the same entity, `scaffold check`\nnames them and the apps they belong to: two desks writing one record is a\ndecision, and the split is stated on the FIELD in each app\'s\n`package.json#lotics.writes` rather than left to whoever edits second.\n\nThat workflow lands in the app as source, like every other: its body in\n`src/workflows/update_<entity>.ts` and its declaration in\n`package.json#lotics.workflows`. The two together are the binding \u2014 `lotics app\ndeploy` pushes whatever differs from what it last saw live \u2014 so the write is\nversion-controlled and travels with the app rather than being bound by hand\nafterwards.\n\nA `custom` screen declares its slots under `roles` (slot \u2192 role) and they bind\nthe same way:\n\n```jsonc\n{ "alias": "readings", "label": "Readings", "shape": "custom", "entity": "reading",\n  "roles": { "subject": "identity", "reading": "measure" } }\n```\n\n## Applying packages\n\n`apply` copies published packages into the workspace AFTER the model\'s own\ntables exist \u2014 apps over the tables you just described, and any tables of their\nown they still need. Ordered, and run by `lotics setup` and `lotics scaffold\napply` alike.\n\n```jsonc\n"apply": [\n  {\n    "package": "apg_k3nf82ldpq",\n    "bind": {                              // optional \u2014 which of YOUR tables each entity is\n      "company": { "label": "Customers", "fields": { "name": "Company name" } }\n    },\n    "no_sample_data": true                 // optional\n  }\n]\n```\n\n`bind` is keyed by the package\'s entity alias and holds the LABELS this\nworkspace uses: scaffold adopts by label, so binding points the package at the\ntables the model created instead of a second set beside them. Only naming\nmoves \u2014 a bound field must be the TYPE the package declares, or the copy is\nrefused. `lotics library list` is the shelf, and `lotics library show <apg_id>`\nlists the aliases to bind.\n\nEntries run in the order they are written, because a later one may bind onto a\ntable an earlier one created. **A refused entry stops the run and the entries\nbefore it stay** \u2014 they are separate copies, committed as they land, so the\nrefusal names them rather than leaving a caller to re-run the file and copy them\ntwice.\n\n## Presets\n\nA preset is a trade\'s model, published to be READ. An assistant reads it, asks\nat most two questions, picks a variant and writes a `model.json` from it \u2014\nnothing is copied, and a preset is a file rather than anything a workspace\ninstalls.\n\n```jsonc\n"preset": {\n  "name": "Field service",\n  "description": "Jobs, the crew that runs them, and what each one billed.",\n  "questions": ["Do you dispatch crews, or one person per job?"],  // at most 2\n  "variants": {\n    "crews": {\n      "when": "work is dispatched to crews rather than to one person",\n      "entities": [ /* tables this branch ADDS */ ],\n      "fields": { "job": [ /* fields this branch ADDS to `job` */ ] }\n    }\n  }\n}\n```\n\nVariants are **additive only**: a branch adds entities and fields and never\nremoves them, so the base is a model in its own right rather than a draft.\n`lotics scaffold check` proves the base AND every variant merged onto it, so a\npreset ships with every branch already proven \u2014 the branch nobody took is the\none that fails in the workspace of whoever takes it.\n\n`preset` is not scaffolded. `lotics setup` and `lotics scaffold apply` ignore\nit and create the base model\'s tables.\n\n`lotics scaffold export` prints a workspace that already works as one of these\nfiles \u2014 the starting point for a preset or for another business\'s model, never a\nsource of truth: it carries one business\'s words and stops describing that\nworkspace the moment either changes.\n\n## Starting from a preset\n\n`lotics library list` is the shelf of them and `lotics library show <slug>`\nprints one whole: its questions, every table as `alias \xB7 label` with each field\nas `alias:type`, and each variant as `slug \xB7 when` followed by the tables and\nfields that branch adds. When one of them is the trade in front of you, do not\ntranscribe it \u2014 name it:\n\n```jsonc\n{\n  "from": "field_service",\n  "variants": ["crews"],\n  "rename": { "job": { "label": "\u0110\u01A1n h\xE0ng", "fields": { "code": "M\xE3 \u0111\u01A1n" } } },\n  "entities": [ /* a table this business has that the preset does not */ ],\n  "rows": { "job": [ { "ref": "j1", "fields": { "code": "J-1" } } ] },\n  "field_roles": { "job": { "code": "identity" } },\n  "write_rules": { "customer": { "natural_key": ["email"] } },\n  "apps": [ /* the screens this business\'s apps will have */ ]\n}\n```\n\n- **`from`** is the preset\'s SLUG \u2014 its own file name, a lowercase slug. Naming\n  it is what makes `entities` optional; every other rule on this page is\n  unchanged, because the file is resolved into the full form and then checked and\n  applied exactly as one. A slug nothing serves is refused with the ones there\n  are, never resolved against something else.\n- **`variants`** names the branches to merge onto the base, in order. Pick the\n  one whose `when` describes what the person said; a slug the preset does not\n  declare is refused rather than ignored.\n- **`rename`** is keyed by the preset\'s entity alias and holds the labels this\n  business uses \u2014 the same shape `apply[].bind` takes, and the same rule: only\n  naming moves. An alias the preset does not declare, and a label that is\n  already another table\'s, are both refused.\n- **`entities`** are added after the rename, already in this business\'s own\n  words.\n- **`rows`**, **`field_roles`**, **`write_rules`**, **`apps`** and **`apply`**\n  mean exactly what they mean in the full form \u2014 `"rows"` are this business\'s\n  real first records,\n  `"field_roles"` may name the preset\'s fields as well as its own (a role the\n  preset declares itself is kept unless this file names the same field, or\n  clears it with `null`), `"write_rules"` the create-time clauses on either\n  (an entity this file names replaces the preset\'s whole entry for it),\n  `"apps"` the screens it will have (a preset carries none), `"apply"` the\n  packages copied in once its tables exist.\n\nThis is the ONE thing on this page that needs the network: `check` reads the\npreset it names, once. Everything after that read is the same offline check.\n\nWrite the full form when no preset is the trade.\n\n## A complete model\n\n```json\n{\n  "entities": [\n    {\n      "alias": "customer",\n      "label": "Customers",\n      "singular": "Customer",\n      "fields": [\n        { "alias": "name", "label": "Name", "type": "text", "required": true },\n        {\n          "alias": "tier",\n          "label": "Tier",\n          "type": "select",\n          "options": [\n            { "alias": "standard", "label": "Standard", "color": "slate" },\n            { "alias": "gold", "label": "Gold", "color": "amber" }\n          ],\n          "default": ["standard"]\n        },\n        {\n          "alias": "orders",\n          "label": "Orders",\n          "type": "select_record_link",\n          "target_entity": "order",\n          "cardinality": "many",\n          "sync_both_ways": true,\n          "paired_field_alias": "customer",\n          "display_field_aliases": ["code"]\n        },\n        {\n          "alias": "total_ordered",\n          "label": "Total ordered",\n          "type": "rollup",\n          "source_field_alias": "orders",\n          "aggregate_option": { "operation": "sum", "field_key": "amount" }\n        }\n      ],\n      "views": [\n        {\n          "alias": "gold",\n          "label": "Gold customers",\n          "filters": {\n            "node_type": "condition",\n            "type": "select",\n            "field_key": "tier",\n            "operator": "has_any_of",\n            "value": ["gold"]\n          },\n          "sort": [{ "field_key": "name", "order": "asc" }]\n        }\n      ]\n    },\n    {\n      "alias": "order",\n      "label": "Orders",\n      "singular": "Order",\n      "fields": [\n        { "alias": "code", "label": "Order no.", "type": "text", "unique": true },\n        { "alias": "placed_on", "label": "Placed on", "type": "date", "format": "date" },\n        {\n          "alias": "amount",\n          "label": "Amount",\n          "type": "number",\n          "format": "currency",\n          "currency": "VND"\n        },\n        {\n          "alias": "total",\n          "label": "Total with VAT",\n          "type": "formula",\n          "formula": { "expression": "{amount} * 1.1", "format": "currency", "currency": "VND" }\n        },\n        {\n          "alias": "customer",\n          "label": "Customer",\n          "type": "select_record_link",\n          "target_entity": "customer",\n          "cardinality": "one",\n          "sync_both_ways": true,\n          "paired_field_alias": "orders",\n          "display_field_aliases": ["name"]\n        }\n      ]\n    }\n  ],\n  "roles": [{ "alias": "sales", "label": "Sales" }],\n  "field_roles": {\n    "customer": { "name": "identity" },\n    "order": { "code": "identity", "placed_on": "when", "amount": "amount", "customer": "party" }\n  },\n  "apps": [\n    {\n      "alias": "customers",\n      "name": "Customers",\n      "screen": { "alias": "customers", "label": "Customers", "shape": "party_register", "entity": "customer" }\n    },\n    {\n      "alias": "orders",\n      "name": "Orders",\n      "screen": { "alias": "orders", "label": "Orders", "shape": "transaction_ledger", "entity": "order" }\n    }\n  ],\n  "rows": {\n    "customer": [\n      { "ref": "acme", "fields": { "name": "Acme Trading", "tier": "gold" } },\n      { "ref": "bluebird", "fields": { "name": "Bluebird Foods", "tier": "standard" } }\n    ],\n    "order": [\n      {\n        "ref": "so_1001",\n        "fields": {\n          "code": "SO-1001",\n          "placed_on": "@month-start+2",\n          "amount": 4200000,\n          "customer": "customer:acme"\n        }\n      },\n      {\n        "ref": "so_1002",\n        "fields": {\n          "code": "SO-1002",\n          "placed_on": "@today-3",\n          "amount": 1150000,\n          "customer": "customer:bluebird"\n        }\n      }\n    ]\n  }\n}\n```\n\n`lotics scaffold check` on this file reports\n`2 tables, 9 fields, 2 links, 1 view, 1 role, 4 rows, 2 apps`, then\nthe plan:\n\n```\nCustomers\n  Customers \u2014 party register over Customers (2 rows) \xB7 page \xB7 tabs: none\n    identity Name \xB7 mark (none) \xB7 contact (none) \xB7 worth (none) \xB7 risk (none)\n    above: rows\n    record: header (Name) \xB7 history: Orders (Order no. \xB7 Placed on \xB7 Amount (VND)) \xB7 facts (Tier \xB7 Total ordered (VND))\nOrders\n  Orders \u2014 transaction ledger over Orders (2 rows) \xB7 drawer \xB7 tabs: none\n    when Placed on \xB7 amount Amount (VND) \xB7 reference Order no. \xB7 party Customer \xB7 classification (none) \xB7 document (none)\n    above: Amount (VND)\n    record: header (Order no. \xB7 Placed on \xB7 Amount (VND)) \xB7 facts (Placed on \xB7 Total with VAT (VND) \xB7 Customer)\nWho writes what:\n  Customers (customer, one: Customer): Customers\n  Orders (order, one: Order): Orders\n```\n\nThe last block is the WRITERS matrix \u2014 one line per record surface the plan\nleaves operable, the word one of its rows is called, and the app whose register\nopens it. Part of the verdict rather than a diagnostic beside it: which desk\nchanges a table is answerable from the plan, and two apps on one line is the\nsplit to state in each of their `package.json#lotics.writes`.\n\nEvery `(none)` is a slot no field fills \u2014 the picture a register has none of,\nthe contact nobody declared. Read it as the screen a person will see. Neither\nentity carries a stage, a required set or files, so the rest is facts \u2014 except\nthe sections neither entity declares: the customer\'s `history:` is the orders\nthat name it as their party, and the order\'s `via Orders:` is the customers whose\n`Orders` link names it. **A link is a section, not a fact**, on the side it\npoints AT and on the side that holds it: `Customers.Orders` therefore leaves the\ncustomer\'s facts, because the section below already lists the same relation and\na link fact can only ever show the first of them. Both records state their name\nin the header and nowhere else \u2014 a ledger\'s columns are the date and the figure,\nso `Order no.` is on no column of that list and is still what the drawer behind\na line is called. `Total ordered (VND)` is the rollup inheriting the currency of\nthe column it sums: money is read off the model, never off the field\'s own line.\n';
+var model_reference_default = '# The Lotics workspace model (`model.json`)\n\nOne JSON file describing the tables, fields, options, views, roles and first rows\na workspace starts with. `lotics scaffold check model.json` proves it offline \u2014\nno account, no network. `lotics setup model.json --email you@company.com` creates\nthe account and applies it. `lotics scaffold apply model.json` applies it again,\ninto the workspace the credential names.\n\n**There are two forms of this file.** The full one, below, spells the model out.\nThe `from` one names a published preset and carries only what this business\ndiffers by \u2014 see \xA7 Starting from a preset, and prefer it whenever a preset fits\nthe trade.\n\nApps are PLANNED here and built afterwards: `apps` names each app\'s screens as a\nshape over an entity, checked against the roles `field_roles` gives its fields,\nso the plan is refused before anyone builds a screen (\xA7 Apps and screens). The\nbuilt app lives in the workspace; publishing that workspace as a package is how\nit ships.\n\n## The rules\n\n- **At least one entity, at most 50.** More tables than that is a data model\n  being designed, not scaffolded \u2014 scaffold the rest in a second call.\n- **Adoption is explicit.** `lotics setup` REFUSES an entity whose `label`\n  already names a table in the workspace, naming every colliding label at once.\n  `lotics scaffold apply` adopts those tables and adds the fields, options and\n  views they are missing. Nothing is ever modified or deleted, so applying the\n  same model twice creates nothing the second time.\n- **Adoption is by LABEL, not alias.** Change an entity\'s `label` and the next\n  run asks for a NEW table beside the old one. Renaming a FIELD is\n  `lotics field rename <table> <field> "<new label>" --model <this file>`, which\n  moves the platform, this file and every app bound to it together; deleting is\n  `lotics run delete_table`. Neither goes through the file.\n- **The file\'s own majority is the language.** A model names no locale \u2014 which\n  language it is in is what it mostly says, and `scaffold check` notes the label\n  written the other way. The generated screens read the kit\'s pack, and a\n  generated WRITE cannot: its refusals run on the server, so they are worded in\n  that same majority. Mix the two and the workspace answers in two languages.\n- **`lotics scaffold diff model.json` says where the file and the workspace have\n  come apart**, joined on label, entity then field \u2014 the join adoption itself\n  makes. It exits 1 on any difference, so a model that is about to be published\n  as a preset carries the labels in use rather than the ones it was written with.\n- **Rows land only where every bound table is empty.** One table already holding\n  records and no rows are written anywhere, and the result says\n  `rows_skipped: true`: sample rows landing among a customer\'s real ones cannot\n  be told apart from them.\n- **After the first run the WORKSPACE is the source of truth.** The file is an\n  authoring input, not a mirror \u2014 scaffold never deletes what the file stopped\n  naming.\n- **`lotics scaffold check` decides all of it offline**, and reports every\n  problem in one run rather than the first: an alias that resolves to nothing, a\n  link whose pair is not symmetric, and the rows themselves \u2014 a field the entity\n  does not declare, an option alias the field does not declare, a link naming no\n  row in the file, a `ref` used twice, a date that is not one, a value on a\n  platform-computed field, and a files cell that is neither a relative path\n  beside this file nor a `fil_` id.\n\n## Top level\n\n```jsonc\n{\n  "entities": [ /* the tables */ ],\n  "roles":    [ /* workspace groups to create */ ],    // optional\n  "templates":[ /* inline html / email templates */ ], // optional\n  "rows":     { /* first records, keyed by entity alias */ },  // optional\n  "field_roles": { /* the reporting role each field plays, keyed by entity then field */ }, // optional\n  "write_rules": { /* what a CREATE finds, defaults and refuses, keyed by entity */ }, // optional\n  "apps":     [ /* the screens each app will have, as shapes over entities */ ], // optional\n  "apply":    [ /* published packages to copy in afterwards */ ], // optional\n  "preset":   { /* a trade\'s branches, for a PUBLISHED model */ } // optional\n}\n```\n\nThe other form names a preset instead of restating one:\n\n```jsonc\n{\n  "from":     "field_service",             // the preset this model starts from, by slug\n  "variants": ["crews"],                   // optional \u2014 its branches to merge in, in order\n  "rename":   {                            // optional \u2014 what THIS business calls each table\n    "job": { "label": "\u0110\u01A1n h\xE0ng", "fields": { "code": "M\xE3 \u0111\u01A1n" } }\n  },\n  "entities": [ /* tables the preset does not declare */ ],    // optional\n  "rows":     { /* first records, keyed by entity alias */ },  // optional\n  "field_roles": { /* roles on the preset\'s fields and this business\'s own */ }, // optional\n  "write_rules": { /* create-time clauses on the preset\'s entities and its own */ }, // optional\n  "apps":     [ /* the screens each app will have */ ],        // optional\n  "apply":    [ /* published packages to copy in afterwards */ ] // optional\n}\n```\n\n**A model may not carry** `fixtures`, `knowledge` or `knowledge_expects`, and no\n`excel` / `word` / `pdf-form` template: each of those is content that lives in a\npublished bundle, which a model has none of. `apps` here is a plan of screens,\nnever built code. An unknown top-level key is an error, never ignored.\n\n### Aliases\n\nEvery `alias` is a lowercase slug \u2014 a letter, then letters, digits and\nunderscores (`unit_price`, `so_1001`). Aliases are how the file cross-references\nitself; they are never shown to anyone. `label` is what a person sees.\n\nLabels must be unique within their namespace \u2014 two entities, two fields on one\nentity, two options on one field, two views on one entity, two roles or two\ntemplates cannot share a label, because scaffold matches by label.\n\n## Entity\n\n```jsonc\n{\n  "alias": "order",\n  "label": "Orders",            // the table\'s name, which names the SET it holds\n  "singular": "Order",          // optional \u2014 ONE of them, for the act that opens one\n  "description": "\u2026",           // optional\n  "fields": [ /* at least one */ ],\n  "views":  [ /* optional; an entity with none still gets the default grid */ ],\n  "read_scope": { /* optional; absent, everyone with access to the table reads every row */\n    "any": [\n      { "member_of": "sales" },                       // a role alias this model declares\n      { "field": "scope", "is": ["shared"] }          // a single select on this entity, by option alias\n    ]\n  }\n}\n```\n\n**`singular` is what a create says.** A register\'s own act and the panel it\nopens name the row being made \u2014 `New Order`, `H\u1ED3 s\u01A1 m\u1EDBi` \u2014 while `label` names\nthe table, so without it the button reads `New Orders`. Nothing derives it\n(English plurals are irregular), and most models need none: a Vietnamese noun is\nthe same word either way. `scaffold check` prints it beside the table under *Who\nwrites what* and NOTES a table that will name the set. An act on a child section\nkeeps the label: it adds a line to the register under the record the reader is\nalready standing in.\n\n**`read_scope` is a ROW rule, enforced by the platform.** A row is readable when\nANY clause holds: the reader is in that role\'s group, or the named select carries\none of those options. It is resolved at scaffold into the table\'s own row\nfilters, so an app, a workflow reading for a viewer, and the API all answer the\nsame rows \u2014 a per-record visibility field the app merely honours is a convention,\nnot a gate. `any` may not be empty (a rule nobody satisfies hides the table), and\nevery role alias and option alias in it must be one this model declares.\n\n## Field\n\nEvery field carries `alias`, `label`, an optional `description`, and an optional\n`required` \u2014 advisory only, read by app forms and workflows; the table itself has\nno required constraint. `label` may not contain `{` or `}` (formulas reference\nfields by label at the platform level).\n\n`default` is the value pre-filled into a NEW record. It applies on create only;\nexisting records are never backfilled. Only the types listed below accept one.\n\n### `text`\n\n```jsonc\n{ "alias": "name", "label": "Name", "type": "text",\n  "unique": false,              // optional \u2014 require distinct values\n  "format": "text",             // optional \u2014 "text" | "link" | "markdown"\n  "default": "" }               // optional\n```\n\n### `number`\n\n```jsonc\n{ "alias": "amount", "label": "Amount", "type": "number",\n  "format": "currency",         // optional \u2014 "number" | "currency" | "percentage"\n  "currency": "VND",            // optional \u2014 ISO 4217\n  "default": 0 }                // optional\n```\n\n`format` is what the number IS, and every surface reads it: `currency` prints as\nmoney in the code the row or the field states, `percentage` as a whole percent\nwith its sign. An ABSENT number is drawn absent \u2014 the one exception is a\n`sum` or count rollup the plan reads as a **`measure`**: that is the thing\naccumulated toward a bound, so nothing accumulated yet is zero and the meter\ndraws it. The same rollup read as an `amount` keeps its blank, and so does every\nother role: nothing added to what a row is WORTH means unpriced, not free. A\n`min`, an `avg`, a percentage of nothing and every FORMULA stay blank in any\nrole, because none of them has an answer to give. This is why the pair on one\nscreen reads two ways \u2014 what has come in against what is owed \u2014 and why a\nmeasure\'s own LIMIT, an amount, leaves an unquoted row out of the count rather\nthan reporting it as nothing collected. **AND WHERE THAT LIMIT IS ABSENT THERE IS\nNO LEVEL AT ALL**: a level is a reading AGAINST a bound, so a row that states no\nbound draws nothing \u2014 cell, fact and all \u2014 rather than a numerator whose whole\nmeaning was the comparison. "Collected 0" beside a blank total reads as money\nagainst a job worth nothing. A measure the model gives no limit is a plain figure\nand is unaffected. A share is stored in percent units \u2014 68.1 is 68.1 % \u2014 and the\ncolumn, the fact behind it, the meter it is judged by and the figure over the\nregister all say so.\n\n### `date`\n\n```jsonc\n{ "alias": "placed_on", "label": "Placed on", "type": "date",\n  "format": "date",             // optional \u2014 "date" | "datetime" | "date_range" | "datetime_range"\n  "timezone": "Asia/Ho_Chi_Minh",  // optional \u2014 IANA name\n  "derive_from": "created_at",  // optional \u2014 "created_at" | "updated_at"; makes the field read-only\n  "default": "2026-01-01" }     // optional; refused together with derive_from\n```\n\n### `boolean`\n\n```jsonc\n{ "alias": "paid", "label": "Paid", "type": "boolean", "default": false }\n```\n\n### `select`\n\n```jsonc\n{ "alias": "tier", "label": "Tier", "type": "select",\n  "options": [                                     // at least one\n    { "alias": "standard", "label": "Standard", "color": "slate" },\n    { "alias": "gold",     "label": "Gold",     "color": "amber" }\n  ],\n  "multi": false,               // optional\n  "default": ["standard"] }     // optional \u2014 option ALIASES; one unless multi\n```\n\n`color` is one of: `red`, `orange`, `amber`, `yellow`, `lime`, `green`,\n`emerald`, `teal`, `cyan`, `sky`, `blue`, `indigo`, `violet`, `purple`,\n`fuchsia`, `pink`, `rose`, `slate`, `gray`, `zinc`, `neutral`, `stone`.\n\n### `select_member`\n\nA person picker over the workspace\'s members. No default: a model cannot name\nmembers of a workspace that does not exist yet.\n\n```jsonc\n{ "alias": "owner", "label": "Owner", "type": "select_member", "multi": false }\n```\n\n### `select_record_link`\n\n```jsonc\n{ "alias": "customer", "label": "Customer", "type": "select_record_link",\n  "target_entity": "customer",        // an entity alias this model declares\n  "cardinality": "one",               // optional \u2014 "one" | "many" (default "many")\n  "sync_both_ways": true,             // optional \u2014 keep a paired field on the target\n  "paired_field_alias": "orders",     // the partner field ON THE TARGET entity\n  "display_field_aliases": ["name"] } // optional \u2014 what the link shows / the picker\'s columns\n```\n\nA two-way link is declared on BOTH sides, each naming the other as its\n`paired_field_alias`; the pair must be symmetric or the model is refused.\n\n**A single-valued link needs no partner.** `"cardinality": "one"` on its own is a\nlink that holds one row \u2014 one customer on an invoice, one project on a device \u2014\nand nothing is created on the target. The mirror invariant belongs to a PAIRED\nlink: pair a link when the target\'s own record should list what points at it, and\nleave it unpaired when it should not. Either way the record plan draws the\nrelation as a section on the side it points at, so an unpaired link costs the\ntarget nothing.\n\n### `files`\n\n```jsonc\n{ "alias": "attachments", "label": "Attachments", "type": "files" }\n```\n\n### `formula`\n\n```jsonc\n{ "alias": "total", "label": "Total", "type": "formula",\n  "formula": {\n    "expression": "{amount} * 1.1",  // fields on THIS entity, by alias, in braces\n    "output_type": "number",         // optional \u2014 what it YIELDS: "number" | "text" | "date" | "datetime" | "boolean"\n    "format": "currency",            // optional \u2014 how that result is DRAWN: "number" | "currency" | "percentage" | "link"\n    "currency": "VND"                // optional\n  } }\n```\n\n`output_type` is what the expression answers WITH; `format` is how it is printed.\nThe platform infers the result at write time and ignores what you declare, so\nthis is a statement the offline checks read \u2014 which is what lets a role or a\nscreen clause accept a computed value: a caption over a derived name\n(`output_type: "text"`), a period over a settled date (`"date"`). A formula\ndeclaring neither says nothing about its result, and every rule that needs one\nrefuses it by name. `lotics scaffold export` writes the result a live workspace\ncomputed, so exporting a workspace fills these in.\n\n### `rollup`\n\nAggregates the records reached through a link on this entity.\n\n```jsonc\n{ "alias": "total_ordered", "label": "Total ordered", "type": "rollup",\n  "source_field_alias": "orders",    // a select_record_link field on THIS entity\n  "aggregate_option": {\n    "operation": "sum",              // count | sum | avg | median | min | max | range |\n                                     // empty | filled | percent_empty | percent_filled |\n                                     // unique | percent_unique |\n                                     // earliest | latest | date_range |\n                                     // checked | unchecked | percent_checked |\n                                     // percent_unchecked\n    "field_key": "amount"            // a field ALIAS on the linked entity ("count" may omit it)\n  },\n  "filter": { /* optional \u2014 see Views; every field_key is an alias on the LINKED entity */ } }\n```\n\nThe operation must be one the aggregated field\'s type allows \u2014 `sum` over a\nnumber, `earliest` over a date, `filled` over anything.\n\n### `lookup`\n\nDisplays a field from the linked records.\n\n```jsonc\n{ "alias": "customer_tier", "label": "Customer tier", "type": "lookup",\n  "source_field_alias": "customer",  // a select_record_link field on THIS entity\n  "lookup_field_alias": "tier",      // a field alias on the linked entity\n  "order_by": { "field_key": "placed_on", "direction": "desc" } }  // optional \u2014 pick the single extreme row\n```\n\n### `autonumber`\n\n```jsonc\n{ "alias": "seq", "label": "No.", "type": "autonumber",\n  "prefix": "SO-",     // optional \u2014 ignored when template is set\n  "padding": 4,        // optional \u2014 1..20, zero-pads the integer\n  "template": "SO-{YEAR}-{N:4}" }  // optional \u2014 {N}, {N:W}, {YEAR}, {YEAR:2}, {MONTH}, {DAY}\n```\n\n## Views\n\nSaved views live under the entity they belong to. Every field reference is a\nfield ALIAS on that entity.\n\n```jsonc\n{\n  "alias": "gold",\n  "label": "Gold customers",\n  "description": "\u2026",                       // optional\n  "columns": [                              // optional \u2014 omit to show every field\n    { "field_alias": "name", "visibility": "visible", "width": 240 },\n    { "field_alias": "tier", "visibility": "hidden" }\n  ],\n  "filters": {                              // optional\n    "node_type": "group",\n    "logic": "and",                         // "and" | "or"\n    "children": [\n      { "node_type": "condition", "type": "select", "field_key": "tier",\n        "operator": "has_any_of", "value": ["gold"] }\n    ]\n  },\n  "sort": [ { "field_key": "name", "order": "asc" } ],  // optional; order is "asc" | "desc" | null\n  "summary": { "amount": "sum" },           // optional \u2014 field alias \u2192 footer operation\n  "frozen_columns": 1                       // optional\n}\n```\n\nA condition\'s `type` is the field\'s type and its `operator` is one that type\nadmits \u2014 `has_any_of` / `has_none_of` / `has_all_of` / `is_empty` /\n`is_not_empty` for a select, `equals` / `greater_than` / `less_than` for a\nnumber, `on` / `before` / `after` / `between` for a date, `contains` /\n`is_any_of` for text. A select condition\'s `value` names option ALIASES.\n\n`columns`, when present, is exhaustive and must not be empty: a view renders\nexactly the entries it holds. Omit the key to show every field.\n\n## Roles\n\nA role becomes a workspace group. Members are added afterwards, in the app.\n\n```jsonc\n{ "alias": "sales", "label": "Sales" }\n```\n\n## Templates\n\nOnly inline `html` and `email` templates \u2014 the rest are file-backed and a model\nhas no bytes. An `html` template renders to a PDF when a workflow generates\nfrom it; `{{name}}` is filled from the workflow\'s data.\n\n```jsonc\n{ "alias": "order_ack", "label": "Order acknowledgement", "type": "email",\n  "content": "<p>Hello {{customer}}\u2026</p>" }\n```\n\nA paper that has to look like a counterparty produced it \u2014 an official letter,\nan acceptance minute, a supplier\'s bill \u2014 is the same `html` template with a\nshell around the body: a letterhead, a reference line, a seal and a signature\nblock, and paper grain over everything. One shell, many bodies; the data is the\nonly thing that changes, so a workflow can re-issue it over any record.\n\n```jsonc\n{ "alias": "cong_van", "label": "C\xF4ng v\u0103n", "type": "html",\n  "content": "\u2026the page below, as one JSON string\u2026" }\n```\n\n```html\n<style>\n    .sheet{position:relative;width:718px;padding:44px 58px 30px;background:#fbfaf6;color:#111;font:14.2px/1.5 \'Liberation Serif\',serif}\n    .grain{position:absolute;inset:0;opacity:.34;mix-blend-mode:multiply;background:url("data:image/svg+xml;utf8,<svg xmlns=\'http://www.w3.org/2000/svg\' width=\'140\' height=\'140\'><filter id=\'f\'><feTurbulence baseFrequency=\'.9\' numOctaves=\'2\'/><feColorMatrix values=\'0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .35 0\'/></filter><rect width=\'140\' height=\'140\' filter=\'url(%23f)\'/></svg>")}\n    .top{display:flex;text-align:center;font-size:13.4px} .top>div{flex:1} .u{display:inline-block;border-bottom:1px solid #111;font-weight:700}\n    .ref{display:flex;text-align:center;font-size:13.4px;margin-top:6px} .ref>div{flex:1} .ref .r{font-style:italic}\n    h1{text-align:center;font-size:15.6px;margin:26px 0 18px} p{text-align:justify;text-indent:26px;margin:0 0 9px}\n    .sig{display:flex;margin-top:20px} .sig .l{flex:1} .sig .r{width:290px;text-align:center;position:relative}\n    .sig .nm{font-weight:700;margin-top:96px} .seal{position:absolute;left:4px;top:8px;width:166px;height:166px;opacity:.66;mix-blend-mode:multiply;transform:rotate(-17deg)}\n  </style>\n  <div class=\'sheet\'><div class=\'grain\'></div>\n    <div class=\'top\'><div><b>{{issuer_parent}}</b><br><span class=\'u\'>{{issuer}}</span></div>\n      <div><b>C\u1ED8NG H\xD2A X\xC3 H\u1ED8I CH\u1EE6 NGH\u0128A VI\u1EC6T NAM</b><br><span class=\'u\'>\u0110\u1ED9c l\u1EADp - T\u1EF1 do - H\u1EA1nh ph\xFAc</span></div></div>\n    <div class=\'ref\'><div>S\u1ED1: {{number}}</div><div class=\'r\'>{{place}}, ng\xE0y {{day}} th\xE1ng {{month}} n\u0103m {{year}}</div></div>\n    <h1>{{title}}</h1>\n    <p>K\xEDnh g\u1EEDi: {{recipient}}.</p>\n    {{{body}}}\n    <div class=\'sig\'><div class=\'l\'><b>N\u01A1i nh\u1EADn:</b><br>- Nh\u01B0 tr\xEAn;<br>- L\u01B0u VT.</div>\n      <div class=\'r\'><img class=\'seal\' src=\'{{seal_url}}\'><b>{{signer_title}}</b><div class=\'nm\'>{{signer}}</div></div></div>\n  </div>\n```\n\n`lotics preview <file.html>` renders any such page to a PNG the way a demo\'s\nprops are made, sized to its content, so a paper can be looked at before it is\nput in a template.\n\n## Rows\n\nFirst records, keyed by entity alias. Up to 200 rows per entity and 2000 across\nthe model, attaching at most 2000 documents between them \u2014 a real data set\nbelongs in an import, not a model.\n\n```jsonc\n"rows": {\n  "customer": [\n    { "ref": "acme", "fields": { "name": "Acme Trading", "tier": "gold" } }\n  ]\n}\n```\n\n`ref` is a local handle (lowercase letters, digits, underscores) that other rows\'\nlink fields address. It is never persisted.\n\nA `files` cell attaches documents: paths relative to this file (no `..`, never\nabsolute), which `check` proves exist and `apply` uploads into the workspace\nbefore any row is written \u2014 a paperwork business seeds its papers with its\nrows. The server accepts only `fil_` ids of files this workspace owns, which is\nwhat the upload leaves behind. After a run that wrote rows, `apply` writes the\nrecord ids beside the file (`<model>.last_run.json`): `delete_records` over\nthem is how a seeded set is reset, and applying again re-dates it.\n\n`fields` is keyed by field alias, and every value is read against the field\'s\nDECLARED type:\n\n| Field type | Value |\n|---|---|\n| `text` / `number` / `boolean` | the value itself |\n| `date` | `"2026-03-14"`, or a relative expression (below) |\n| `select` | the option ALIAS \u2014 `"gold"`, or `["gold","vip"]` for a multi-select |\n| `select_record_link` | `"<entity-alias>:<ref>"` naming another row in this file \u2014 `"customer:acme"`, or an array for several |\n| `select_member` | `"self"` only \u2014 the person applying the model |\n| `files` | paths beside this file \u2014 `["scans/pccc_letter.png"]` \u2014 uploaded by `apply`/`setup` before the rows are posted; or `fil_` ids of files already in this workspace |\n| `formula`, `rollup`, `lookup`, `autonumber` | not allowed \u2014 the platform writes these |\n\n**Documents can be attached on their own, afterwards.** Rows land only into empty\ntables, so a model whose binaries were added after the first apply has no second\napply to carry them: `lotics scaffold apply model.json --documents` writes ONLY\nthe `files` cells, onto the records the first run created, joined through the\n`<model>.last_run.json` beside the file. Running it twice attaches nothing the\nsecond time \u2014 the same path keeps the same file, and a cell is a set.\n\n### Relative dates\n\nA date cell holds a literal `YYYY-MM-DD`, or an expression relative to the day\nthe model is applied, so a screen that opens on "this month" is not empty a month\nlater:\n\n- `@today` \u2014 the day of the run, in the workspace\'s timezone\n- `@month-start` \u2014 the 1st of that month\n- either with a whole-day offset: `@today-14`, `@month-start+9`\n\n`@month-start` exists because `@today-N` cannot promise a month: applied on the\n2nd, `@today-3` lands in the previous one.\n\n## Field roles\n\n`field_roles` names the reporting role a field plays on its entity \u2014 keyed by\nentity alias, then field alias \u2014 so every screen over the entity agrees on\nwhich column names the row and which select is the stage. A shape\'s slot binds\nto it (\xA7 Apps and screens). Like `rows` and `apps`, it is this file\'s: `check`\nproves it and the workspace never sees it. Each role sits on the types that can\nanswer it:\n\n| Role | On | Meaning |\n|---|---|---|\n| `identity` | `text`, `autonumber`, `select_record_link`, `formula` | names the row \u2014 the register\'s first column; a link where the row is "the product, at this branch"; a formula where the name is computed, and then it may not be `format`ted as a figure. One per entity |\n| `reference` | `text`, `autonumber`, `formula` | the key the SYSTEM files the row under \u2014 a booking number, a container code \u2014 drawn as the supporting line under the name rather than as a column of its own. One per entity |\n| `mark` | `files`, or a `lookup`/`rollup` that resolves to one | the row\'s picture \u2014 its own, or the linked record\'s. One per entity |\n| `lifecycle` | single `select` | the ordered stages a row walks; option order is the order. Which of them END the flow is `outcomes`. One per entity |\n| `category` | single `select` | what the row IS \u2014 a kind, a service, a book. One badge in the field\'s own colour, with no ladder behind it and no flow to advance. Repeats: a row can be of two kinds of thing |\n| `measure` | `number`, `formula`, `rollup` | a level read against a limit \u2014 see `against` and `alert`. Money where the model says so, and then it prints as money |\n| `expected_set` | `select` | its OPTIONS are the required set (documents, checks, services); an option no row has is a gap to show, not nothing. A multi-select draws as a ring and a fraction wherever it is drawn \u2014 absence is the information, and a list of what IS there says nothing about what is missing |\n| `amount` | `number`, `formula`, `rollup` | THE money of a ledger row; `signed_by` says which way it moved, `against` names the reference it is quoted off. One per entity |\n| `when` | `date`, or a `formula`/`rollup`/`lookup` that yields one | the ledger or timeline date \u2014 stated, or derived: the day money MOVED is a formula over the two columns that could hold it. `due` makes it a DEADLINE; without it the date is the plain day it is. `until` names the stage of this entity\'s own `lifecycle` at which the countdown is spent, and says `due` by saying so. One per entity |\n| `slot` | single `select`, or a `datetime` `date` | where in the DAY a row sits \u2014 the run it is read in under its day\'s heading on an itinerary. A select\'s option order IS the run\'s order; a time is ordered by the clock. A plain `date` is refused: that is the day itself. One per entity |\n| `party` | `select_record_link` | the counterparty. One per entity |\n| `parent` | `select_record_link` | the record this row belongs to \u2014 a line\'s order, a paper\'s case. The parent\'s record shows these rows; the row shows the parent as a fact. One per entity, and it links to an entity this model declares |\n| `contact` | `text` | a way to reach a party \u2014 an address, a number, the town it is in. The record draws them as ONE row of links under the name, so the role sits on every field that is one of them. Repeats |\n| `currency` | single `select` whose option LABELS are ISO 4217 codes | the money THIS ROW\'s figures are in. Every amount and every money measure on the entity is then printed per row rather than in one code for the whole column, and the select is not drawn as a fact of its own. One per entity |\n| `verdict` | `boolean`, `formula` | a settled pass/fail \u2014 ticked, or computed. TRUE is the PASSING side wherever it is drawn, a register\'s risk flag included, so a field whose true means trouble is the same fact asked the other way round. One per entity |\n| `obligation` | `date` | a day something is OWED by \u2014 a cut-off, a permit expiry, a payment due. It counts down by definition. `satisfied_by` names what CLOSES it (or `until`, the stage the record stops owing it at), `label` what is owed. Repeats: a row owes several things, and a shape that fans them draws one row each |\n\n**`due` is what makes a `when` a deadline.** A date a row is merely filed by \u2014 the\nday a lead arrived, the day a movement happened \u2014 is neither early nor late,\nhowever long ago it was. Without the clause every desk drew every `when` as a\ncountdown and a two-month-old lead read "40 days overdue" on a record nobody was\nlate on. So a bare `when` is a plain date, and `{ "role": "when", "due": true }`\nis the one that counts down. An `obligation` needs no clause: a day something is\nowed by is a deadline already.\n\n**`until` stops a countdown where the work is DONE.** A deadline counts down so\nsomebody acts on it, and a row that has arrived needs nothing: without the clause\na delivered order is tinted for a date it met, and every settled row past its day\njoins the urgent ones in the reader\'s glance. It names one option of the entity\'s\n`lifecycle`; at that stage, at every stage past it and at every `outcome`, the\ndate is drawn as the plain day it is. On a `when` it also says the date is `due`.\n\n"One per entity" is one COLUMN, never one value on screen. A second counterparty\nor a second parent stays a ROLELESS `select_record_link`: which field fills a\nslot is the screen\'s answer (\xA7 Apps and screens), and the extra link is a fact on\nthe row with its own section on the record, headed by that link\'s own label. A\nrole naming two fields would move the ambiguity into every shape that reads it.\n\nA COMPUTED field is admitted where its RESULT is what the role needs, and\nrefused where it is not: `identity` and `reference` need `text`, `when` a `date`,\n`mark` `files`. A formula\'s result is its `output_type`; a rollup\'s and a\nlookup\'s is read through the walk. So a formula yielding a number is refused in a\nname\'s place, a lookup landing on anything but `files` is refused as a `mark`, and\na formula declaring NO result is refused by all four \u2014 naming `output_type` as\nthe remedy, because a value drawn as a type nobody stated is the wrong cell with\nnothing saying so. The result also decides the DEVICE every screen draws the value\nwith: a rollup taking the `latest` of a set of dates is drawn as a date, a lookup\nof a select as the words it holds.\n\nA bare role name is the common form. A role that is read against a SECOND field\ntakes the object form:\n\n- **`measure`** names its limit: `against` \u2014 a constant, or a field on the same\n  entity the row states as a number (a `number`, or a formula or rollup whose\n  result is one) \u2014 and `alert`, which side of it needs attention, `over` a\n  capacity or `under` a minimum. The two come together.\n- **`measure`** names what its number COUNTS, where the unit changes how the row\n  is DRAWN rather than how the figure reads: `counts: "days"` spans a stop across\n  that many days of a run, so a three-night stay fills three of its days instead\n  of only the one it starts on. Stated, never inferred \u2014 nothing about a `3` says\n  whether it is nights, pallets or hours, and a quantity drawn across a week is a\n  run nobody can read.\n- **`lifecycle`** names the stages that END the flow: `outcomes`, option aliases\n  of that select. A row in one has ARRIVED \u2014 delivered, cancelled, written off \u2014\n  so a desk draws them apart from the ladder instead of chaining them after each\n  other. Not every option may be an outcome, and terminal-ness belongs here, never\n  written into a stage\'s label.\n- **`amount`** names the REFERENCE it is read against: `against`, a field on the\n  same entity the row states as a number. A price against the list it is quoted\n  off, a rate against the going one \u2014 and the catalogue item\'s record draws the\n  pair on one axis with the gap said in words. Never a constant (a price typed\n  into the model ages with nothing to update it) and never an `alert`: a limit is\n  a ceiling a row can pass, and beating a reference is the point.\n- **`amount`** names the select that SIGNS it: `signed_by`, a select on the same\n  entity, and `outflow`, the options of that select under which the amount is\n  money going out. Without it every shape over the ledger adds both directions\n  together: a month whose net was small reads as the total of everything that\n  moved, and the trend plots one rising line. The two come together, and\n  `outflow` is some of that select\'s options, never all.\n- **`expected_set`** names what CONDITIONS the set: `required_by`, a field on the\n  same entity, and `options`, which of that field\'s values require which entries.\n  A row whose value is not named requires nothing. Without it the denominator is\n  every option, so a set whose entries are mutually exclusive by kind reads\n  `1 of 4` on every complete row \u2014 a denominator no row can reach is worse than\n  no role. The field is a single `select`, keyed by its option aliases \u2014 or a\n  YES/NO the row answers itself (a `boolean`, or a formula resolving to one),\n  keyed by `"true"` and `"false"`: a check that FAILED owes its consequence \u2014 the\n  photograph, the owner, the day it is due \u2014 and there is no select of the record\n  that says so. `from: "parent"` reads that field off the record these rows hang\n  under instead, through this entity\'s own `parent` link: which documents an order\n  owes is the ORDER\'s type, and the papers carry no column that says it. Which of\n  the two a set takes is the set\'s own shape and not a choice \u2014 a multi-select\n  holds the whole set on one row and is narrowed by that row (`from` omitted), a\n  single select is one entry per row and takes `from: "parent"` \u2014 and the other\n  way round is refused rather than left conditioning nothing.\n- **`obligation`** names what ENDS it: `satisfied_by`, a `date` or a `files` field\n  on the same entity \u2014 the day it was done, or the paper that proves it \u2014 or,\n  where the business stamps nothing, `until`, the stage of this entity\'s\n  `lifecycle` at which the record stops owing it: a deposit is owed until the\n  order is paid, and nobody records the act of paying twice. One or the other,\n  never neither \u2014 without one every obligation the business ever met stays on the\n  desk. Optionally `label`, what is OWED as the reader says it ("G\u1EEDi SI"), which\n  is not what the column holding the date is called ("SI cut-off").\n\n```jsonc\n"field_roles": {\n  "product": { "name": "identity", "photo": "mark" },\n  "stock":   { "on_hand": { "role": "measure", "against": "minimum", "alert": "under" },\n               "uptime":  { "role": "measure", "against": 80, "alert": "under" } },\n  "order":   { "stage": { "role": "lifecycle", "outcomes": ["delivered", "cancelled"] },\n               // A DEADLINE COUNTS DOWN \u2014 `payment.paid_on` below is a plain day.\n               "ship_by": { "role": "when", "due": true },\n               // The day the papers are owed by, and the day they went.\n               "papers_due": { "role": "obligation", "label": "File the papers", "satisfied_by": "papers_sent" },\n               // Nothing stamps a deposit paid \u2014 the order\'s own stage ends it.\n               "deposit_due": { "role": "obligation", "label": "Take the deposit", "until": "delivered" } },\n  // WHICH PAPERS THIS ONE OWES IS THE ORDER\'S OWN TYPE, and no document says it.\n  "document": { "order": "parent",\n                "kind": { "role": "expected_set",\n                          "required_by": { "from": "parent", "field": "kind",\n                                           "options": { "export": ["invoice", "customs"] } } } },\n  // `kind` is the direction select \u2014 options `received` and `paid_out`, no role of its own.\n  // Every figure on a quotation is in the currency that row names.\n  "quote":   { "unit": "currency", "total": "amount" },\n  // What the price is quoted off, so the item\'s page reads one against the other.\n  "service": { "price": { "role": "amount", "against": "list_price" } },\n  // The day the money moved is neither early nor late, so it stays a bare `when`.\n  "payment": { "paid_on": "when",\n               "value": { "role": "amount", "signed_by": "kind", "outflow": ["paid_out"] },\n               // A receipt owes a receipt voucher; a payment owes an invoice and a payment voucher.\n               "papers": { "role": "expected_set",\n                           "required_by": { "field": "kind",\n                                            "options": { "received": ["receipt_voucher"],\n                                                         "paid_out": ["invoice", "payment_voucher"] } } } },\n  // A CHECK THAT FAILED OWES ITS CONSEQUENCE \u2014 keyed by the row\'s own answer,\n  // and the answer that owes nothing is omitted rather than named with an empty list.\n  "check":   { "passed": "verdict",\n               "evidence": { "role": "expected_set",\n                             "required_by": { "field": "passed",\n                                              "options": { "false": ["photo", "owner", "due"] } } } }\n}\n```\n\nIn a file that starts from a preset (\xA7 Starting from a preset), `field_roles`\nmay name the preset\'s fields as well as this business\'s own; a role the preset\ndeclares itself is kept unless this file names the same field, and `null`\nclears it.\n\n## Write rules\n\n`write_rules` is what only a CREATE meets \u2014 keyed by entity alias, like\n`field_roles`, and this file\'s in the same way: `check` proves it and the\nworkspace never sees it. An update names one field that moved; a create takes a\ndraft whole, so it has to know which row a name already belongs to, where a\nvalue comes from when nobody types it, and what a figure or a picker may hold.\nThe generator writes one `create_<entity>` workflow and one `New<Entity>Dialog`\nper entity an app can operate, from these clauses and the fields\' own\n`required`.\n\n```jsonc\n"write_rules": {\n  // A customer is RECOGNISED by their address. Where an entity names a customer\n  // as its `party`, the create takes the email instead of a picker, reuses the\n  // row it matches and mints one only where nothing does \u2014 so the book never\n  // grows a second Acme because somebody typed the name differently.\n  "customer": { "natural_key": ["email"] },\n  "order_line": {\n    "fields": {\n      // A line of nothing is not a line. Refused on create and on update, at\n      // the control the figure was typed into.\n      "quantity": { "min": 1, "max": 9999 },\n      // The price is fixed at the moment of ordering \u2014 COPIED off the product,\n      // not looked up for ever after, so the price list moving next week does\n      // not silently reprice an order already placed.\n      "unit_price": { "default_from": "product.price" },\n      // And nothing is sold off an empty shelf. The picker reads only the rows\n      // that answer this, and the write refuses the same rows again \u2014 a caller\n      // who never opened the picker is bound by it too.\n      "product": {\n        "options_where": {\n          "node_type": "group", "logic": "and",\n          "children": [{ "node_type": "condition", "type": "number",\n                         "field_key": "in_stock", "operator": "greater_than", "value": 0 }]\n        }\n      }\n    }\n  }\n}\n```\n\n| Clause | On | Meaning |\n|---|---|---|\n| `natural_key` | the entity | the field aliases a row is recognised by. A `text` key declares `unique: true` on the field itself \u2014 two rows sharing it would make find-or-create pick whichever the read answered first \u2014 and a key is `text` or `number`, because a person types it back |\n| `default_from` | a field | `"<link alias>.<field alias>"` \u2014 the value is copied from the linked row when the row is created, never asked. The link is a one-row link on this entity and `required`, because there has to be a row to read, and the two field types must match |\n| `min` / `max` | a `number` | the figure is refused outside them, on create and on update |\n| `options_where` | a `select_record_link` | an `and` group of plain conditions over the TARGET\'s own fields, each `field_key` a field alias. It narrows the picker\'s read and is refused again where the write lands, so the link is `required` |\n\nA field\'s own `required` is not here: the contract carries it, every write path\nrefuses the row by field name from it, and the generated panel stands its commit\ndown until the same set is filled. `unique` is the text field\'s own clause\n(\xA7 `text`) \u2014 the create says so at the control before the column does.\n\nWhat a create asks is what a person STATES. A `default_from` field is not drawn,\na `lifecycle` opens at its first rung, the stamp an obligation\'s `satisfied_by`\nnames is not asked (the row is only now taking that on), and files are attached\nto the row afterwards \u2014 one fact, one place. `scaffold check` prints every clause\nunder its entity in **Who writes what**.\n\n**The `parent` is prefilled only in the door that mounts the act.** A row opened\nfrom the record it hangs under takes that record from the door it was pressed\nin, so the link is neither asked for nor drawn. The same entity\'s act on its own\nregister has no such row, so there the parent is an ordinary picker the draft\ncannot be committed without \u2014 a payment opened from a money app belongs to a\ncase either way.\n\n## Apps and screens\n\n`apps` is the plan: each app the reader will build, as ONE REGISTER \u2014 a SHAPE\nover an ENTITY \u2014 under `screen`. Nothing here is built by the scaffold: the plan\nis what `lotics scaffold check` prints back, register by register with the field\nin every slot, so it is read and corrected before a screen exists.\n\n**THREE THINGS DECIDE EVERY SCREEN AND EVERY RECORD**: the SHAPE, whose slots are\nthe table below; the ROLES the entities declare (\xA7 Field roles), which fill those\nslots and decide what each child\'s rows become; and the CLAUSES, which are where\nthe plan overrides what the two would answer. This index says which is which, so\na clause is reached for only where the first two have no answer.\n\n**What a child\'s rows become.** One section per LINK into the record, and what\nthe CHILD declares decides its kind \u2014 the first line it answers wins.\n\n| Printed as | The child declares | The reader gets |\n|---|---|---|\n| `documents:` | an `expected_set` select, one entry per row | the desk of what is owed, each row\'s files attached to it |\n| `timeline:` | an `obligation` closed by a DATE | the ordered stops, the promised day against the day it happened |\n| `thread:` | a `markdown` body, a `party` and a `when` | the correspondence, its answer, and whose move it is |\n| `itinerary:` | a `when` and a `lifecycle`, on rows a JOB\'s record OWNS | the day heads the run, one line per stop, the sum under it |\n| `lines:` | anything else the record owns (`parent`) | the register of the rows it is made of |\n| `history:` | anything else naming it as their `party` | the same rows read as that party\'s own history |\n| `via <link>:` | a link carrying neither role | the register, headed by that link\'s own label |\n| `related:` | rows of an entity this app lists NOWHERE | one counted line, and a press that opens their register |\n\nA child carrying the BODY and one of the other two is a plain register, and\n`scaffold check` names the declaration it is one short of rather than letting it\nfall through silently. A `party` beside a `when` and no body is not a near miss \u2014\nthat is every ledger line there is.\n\n**The clauses, by name.** On the APP: `scope`. On the `screen`: `record`, `tabs`,\n`slots` (`roles` on a `custom` one), `columns`, `writes`, `period`, `filters`,\n`summary` (`above`, `totals`, `ageing`, `trend`), `facts`, `presentation`\n(`lead`, `density`, `layout`, `until`), `acts` (`row`, `record`, `selection`,\n`export`, `import`), `section_acts`, `sections`. Every one is optional, every one\nis printed back by `scaffold check`, and a screen that states none gets what its\nshape and its roles answer by themselves.\n\n**ONE APP IS ONE REGISTER AND THE RECORDS IT OPENS.** A second register beside\nit is a second job on one page: the reader arrives on whichever the nav listed\nfirst and decides, every time, which of the two they came for. So an app has one\ndestination and everything else about a row is DISCLOSED by opening it \u2014 the\nfacts by tier, the children as lists, the related as counts, one primary act, and\na filter or a group where a strip of destinations would have been. What used to\nbe a second screen is a section of the record, or another app; a model still\nsaying `screens` is refused by name.\n\n**The unit of an app is a JOB, not a person and not a table.** A job has its\nown outcome (something exists or is settled when it is done), its own subject\n(the record it advances), and an end that does not wait on the rest of the\nwork. Two tasks are ONE job when neither finishes without the other and both\nadvance the same record. One app per job, and that is what makes an app a\nwrite-ownership boundary: what the job settles is its app\'s alone to write,\nplus everything it must read to settle it well. A person holding several jobs\nopens several apps \u2014 one app for everything one person does is the dump. A step\nof the job is a section of the record, never a register beside it; a reference\nthe job needs at hand is read inside the record it is about.\n\n**Two people signing is two jobs**, because the outcome belongs to the signer:\nthe desk that prepares against the gate that releases. So is a different\ncadence \u2014 reference data edited monthly and read by the public site, beside a\ndaily desk \u2014 and a different reader, the owner\'s read-only questions. Device,\nplace and step never split a job. A super app holds more than one job; an\nover-split holds less than one, a job cut by device, place or step. The count\nper workspace falls out of the jobs, typically two to six, and is never the\ninput: review the plan app by app, naming who holds it, the job in one\nsentence, what it writes and what it reads.\n\n*A two-van appliance repair shop.* The technician\'s job is the call-out: the\noutcome is a visit done, the subject is the call-out record, and quoting it and\nscheduling it are one job, because neither finishes without the other and both\nadvance that record. The owner holds two of his own \u2014 billing the month\n(outcome invoiced, subject the invoice, settled against visits already closed)\nand the price list the booking page quotes from, edited monthly. Three jobs,\nthree apps, and the owner opens two of them.\n\n**Inside a job the caps hold**: six flow stages on a desk, seven facts before a\nrecord\'s fold. Past them, look for the second job hiding inside. And a job\'s app\nis DENSE: every create the job needs lives in it, so its user never leaves it to\ncorrect a figure the screen in front of them is stating \u2014 three workflows is a\nscreen, not a desk.\n\n**A handoff is a stage change.** Where one job ends the record moves stage and\nthe next job\'s desk opens on it; a field two jobs must both write is declared\nshared at the split, naming the stage each may write it in.\n\n**Name an app for the JOB, in the trade\'s own words, never for who it is for.**\nA title on the door says nothing about what the person who opened it came to\ndo, and it is wrong the day the org chart moves.\n\n```jsonc\n"apps": [\n  {\n    "alias": "sales", "name": "Sales",\n    "description": "\u2026", "icon": "briefcase", "theme": { "color": "blue" }, // optional\n    "screen":\n      { "alias": "orders",    "label": "Orders",    "shape": "lifecycle_desk", "entity": "order",\n        "record": "drawer",                  // optional \u2014 "drawer" | "page"; absent, the shape decides\n        "tabs": "stage",                     // optional \u2014 a select on the entity, or null; absent, the shape decides\n        "writes": false,                     // optional \u2014 default TRUE; false makes this screen a reader\n        "period": "due_date",                // optional \u2014 any field whose value is a date, derived ones included\n        "filters": ["kind",                  // optional \u2014 a single-select, or a lens the model states itself\n                    { "label": "Qu\xE1 h\u1EA1n l\u01B0u", "predicates": [\n                      { "label": "\u0110\xE3 qu\xE1", "tone": "red",\n                        "where": { "node_type": "group", "logic": "and", "children": [\n                          { "node_type": "condition", "field_key": "owed", "operator": "greater_than", "value": 0 }] } }] }],\n        "summary": { "totals": ["total"], "above": ["total", { "field": "owed", "at": "end" }],\n                     "ageing": { "amount": "owed", "due": "due_date", "buckets": [30, 60, 90] },\n                     "trend": { "field": "total", "direction": "up" } },  // optional \u2014 see below\n        "facts": { "groups": [{ "caption": "Pricing", "fields": ["rate", "surcharge"] }] },  // optional \u2014 the record\'s named bands\n        "presentation": { "lead": "none", "density": "dense" },  // optional \u2014 how it is DRAWN; absent, what the rows are decides\n        "acts": { "row": [{ "label": "Issue the note", "template": "debit_note", "place": "cta" },\n                          { "kind": "agent", "label": "Read the papers", "agent": "reader", "fills": ["ref", "due_date"] },\n                          { "kind": "workflow", "label": "Hand it to dispatch", "workflow": "hand_to_dispatch",\n                            "inputs": { "order_id": "record", "owed_by": "due_date" } }],\n                  "record": [{ "label": "Print the file", "template": "dossier" }],  // optional \u2014 the record\'s own header menu\n                  "selection": [{ "label": "Statement", "template": "statement" }],  // optional \u2014 the work it hands on\n                  "export": true,                                                    // optional \u2014 the rows in view, saved\n                  "import": { "kind": "import", "label": "Upload the sheet",         // optional \u2014 a file turned into rows\n                              "entity": "order", "key": "code", "columns": ["rate"] } },\n        "section_acts": { "line": [{ "label": "Chase the lines", "template": "chaser" }] },  // optional \u2014 a verb on one section\n        "sections": { "line": { "draw": "worksheet", "cost": "buy_rate", "sell": "rate" } },  // optional \u2014 priced lines, worked down in place\n        "slots": { "identity": "code",       // optional \u2014 slot \u2192 field, where the roles cannot decide alone\n                   "subject": ["customer", "project"],              // \u2026or the TIERS a fold walks down, outermost first\n                   "stage": { "field": "state", "quick": true } },  // \u2026or the field AND the reader\'s own control for it\n        "columns": ["source", "owner"] }     // optional \u2014 extra facts after the slots, shed first at narrow width\n  }\n]\n```\n\nA shape is a proven screen with named SLOTS, each filled by a field carrying a\nrole (\xA7 Field roles). A slot with exactly one candidate on the entity binds by itself;\ntwo candidates need naming in `slots`; a field fills one slot; a required slot\nwith none is refused \u2014 a lifecycle desk over an entity with no `lifecycle`\nselect cannot be built.\n\n**A LIST IS A HIERARCHY, not a set of columns.** A group register\'s `subject`\ntakes one \u2014 `"subject": ["customer", "project", "order"]`, outermost first \u2014 and\nthe register becomes one the reader walks DOWN: it folds by the first tier, a\nnode narrows to the tier inside it, the last tier opens the set behind the\nfigure, and a trail says where they are. Every tier is a field of this entity\ncarrying a role that slot accepts, and none of them fills a second slot. It is\nthe slot\'s own answer that decides: a list on any other is refused, because two\ncolumns in one cell is not a fold. Without it the same business needs a register\nper depth, and the same money is folded twice with nothing saying it is the same\nmoney.\n\n**A QUICK SLOT IS FOR A DECISION THE READER MAKES FROM THE ROW ALONE.** A slot\'s\nvalue in `slots` is normally the field\'s alias; `{"field": \u2026, "quick": true}`\nsays the column is not a reading of that value but the CONTROL for it \u2014 pressed,\nit writes that one field as a diff through the record\'s own update, so the\nregister and the page behind it land the same write. THREE roles are such a\ndecision, and `quick` on any other is refused: a `lifecycle`, which rests as the\nstage chip and opens the field\'s own stages with the ones that END the flow last;\na `verdict`, which is the switch; and a `measure`, which is the figure typed in\nits own cell \u2014 a reading taken per row IS the row, which is what a timesheet\'s\nhours and a count sheet\'s tally are. Everything else is decided against what the\nrecord holds, and the record has to be open. All three carry the record\'s own\nblockers \u2014 a move the ladder holds is a move the cell holds, and it names the\nentries the row still owes \u2014 and an outcome asks before it commits. Add `"order": "sequence"`\nwhere the stages are a WALK rather than a set of destinations: the cell is then\nthe next step alone, the same advance `RecordProgress` draws under the run, and\nthe doors out of the flow stay on the record. A screen stating `writes: false`\nrefuses `quick`: a reader who may operate nothing has no decision to take.\n\n**THE SLOTS ARE THE ROW\'S ANSWER; `columns` IS ITS CONTEXT.** `"columns":\n["nguon", "phu_trach", "nhu_cau"]` names extra fields of the entity, drawn AFTER\nevery slot and in this order, each by what its column IS \u2014 a chip for a select,\nthe person\'s name for a member, the day for a date, the figure for a number, a\ntick for a boolean, the words for everything else. They are ranked BENEATH every\nslot, so a phone sheds all of them before it sheds any of the shape\'s own\ncolumns. At most four, and refused where one would say what a slot already says,\nover a files field (files are read, so they are a section of the record), over a\ncell holding several (a column of comma lists compares nothing), on a shape whose\nrows are not the entity\'s records in a table, and beside a `presentation.layout`\nthat draws the rows with a device of its own. A fifth fact worth the width is a\nslot the shape is missing \u2014 say so rather than widening this clause.\n\n| Shape | Answers | Required | Also fills | Record | Tabs |\n|---|---|---|---|---|---|\n| `lifecycle_desk` | what is stuck, what do I move next | `lifecycle`, `identity` | `mark`, `party`, `amount`, `measure` (level), `when` | page, or drawer where the entity carries `parent` | the lifecycle\'s stages |\n| `party_register` | who is this, our history, is there a risk | `identity` | `mark`, `contact`, `measure` (worth), `verdict` (risk) | page | none |\n| `offering_register` | what do we offer, at what price, can I sell it | `identity` | `mark`, `amount` (price), `measure` (availability) | page | none |\n| `transaction_ledger` | does this period reconcile, what is unexplained | `when`, `amount` | `identity` (reference \u2014 the line\'s own number), `party`, `lifecycle` (classification), `expected_set` (document) | drawer | none |\n| `monitored_asset_set` | what needs attention, is that number normal | `identity`, `measure` (level) | `mark`, `lifecycle` | drawer | none |\n| `obligation_desk` | what is due next, and has it been done | `identity`, and at least one `obligation` on the entity | `when` (runway) | page | none |\n| `trend_deep_dive` | how did the period go, and why | `when` | `measure`, `amount` | drawer | none |\n| `reconciliation_desk` | what does not match, and by how much | `identity` (reference), and two figures \u2014 `ours` and `theirs`, each an `amount` or a `measure` | `category` (reason), `verdict`, `when` | drawer, on the PAIR | the dated runs, where the model names a select |\n| `entry_matrix` | one value per subject per period | `identity` (subject), `across` \u2014 a `when`, or a `category` for a fixed column set | `measure` (value), `lifecycle` (state), `category` (note) | drawer, on the cell\'s row | none |\n| `guided_run` | complete an ordered sequence, a step at a time | `identity` (step) | `slot` (sequence), `capture` \u2014 a `measure`, `verdict` or `expected_set` \u2014 `verdict` (gate), `mark` (media) | page: the run IS the record | none |\n| `live_board` | is everything OK, right now | `lifecycle` (state), `identity` | `verdict` (exception), `when` (since), `measure` (level), `category` (where) | drawer | none |\n| `group_register` | what does each group come to, and what is behind it | `subject` \u2014 a `category`, `party` or `when` | `amount`, `measure`, `identity` (member) | page: a row is an aggregate, and the door is the SET behind it | none |\n| `media_set` | scan a body of pictures by where they belong | `mark` (picture), `identity` | `category` or `party` (group), `when`, `verdict` (current against superseded) | drawer | none |\n| `day_sheet` | what happened on each day | `when` (the day) | `lifecycle` (state), `measure` (level), `amount`, `category` (note) | page: a day composes several child logs | none |\n| `resource_schedule` | what is on each resource, in what order, under what ceiling | `lane` \u2014 a `party` or a `parent` \u2014 `identity`, `when` (the start) | `measure` (duration), and `load` and `bulk`, each a `measure` read against a ceiling of the LANE\'s \u2014 a vehicle fills by weight and by room and stops at whichever runs out first; `lifecycle` (stage) | drawer, over the lanes | none |\n| `worksheet` | priced lines the reader edits, totalling to one figure | `identity` | `category` (group), `measure` (quantity), and `cost` and `sell`, each an `amount` or a `measure` | drawer, per line | none |\n\n**A record is one of five KINDS, and the shape plus the roles decide which.**\nEvery one of them is ONE READING COLUMN, and the ORDER of that column is the\nwhole of what the kind means.\n\n| Kind | The column, top to bottom |\n|---|---|\n| WORK RECORD \u2014 a `lifecycle_desk` over rows belonging to nothing | the one act that moves it \xB7 what it IS \xB7 the papers it owes \xB7 the rows it is made of \xB7 the book of what it came to \xB7 its own words |\n| LINE \u2014 the same shape over rows carrying `parent` | its ladder \xB7 the arithmetic behind its amount \xB7 the rows and papers under it \xB7 its particulars, last (the key it is filed by is the line under its title) |\n| PROFILE \u2014 a `party_register` | its history, OPEN, grouped by year \xB7 the rest of its registers \xB7 its own words \xB7 its facts (the ways to reach it are under its name, its settlement is the band) |\n| CATALOGUE ITEM \u2014 an `offering_register` | its own words (the picture leads the header at media scale, the price is read against its reference in the band) \xB7 what uses it \xB7 its facts |\n| EVIDENCE \u2014 a `transaction_ledger` | the PROOF \xB7 what the paper is, compactly \xB7 the rest \xB7 the links to the record it settles and the party it was with |\n\nNothing in the file states the kind: a clause that could say it could say the\nwrong one, and `parent` already says whether a row stands alone. `record`\noverrides the DOOR where the shape\'s own answer is not the one wanted \u2014 and its\nthird value, `"expand"`, is not a door at all: the row REVEALS what it holds in\nplace, where there is nothing behind it worth navigating to. A row read that way\nreads as a LINE whatever the shape would have opened: its ladder, the arithmetic\nbehind its amount, then its particulars, because there is no header above it to\nhave stated the name first. It is REFUSED for two reasons, and they are not the\nsame refusal. On a shape whose record is a page by nature \u2014 a `guided_run`, a\n`group_register`, a `day_sheet`, an `obligation_desk` \u2014 because each of those\nstates the opposite where its door is declared: what its row leads to is read\nwhole, not as four more columns than the register had room for. And on a shape\nthat draws its rows with a device of its OWN \u2014 an `entry_matrix`, a `media_set` \u2014\nbecause a cell of a grid and a tile on a wall have no band under them for the row\nto reveal into. For the same reason a revealed register is drawn as a TABLE: a\n`presentation.layout` of anything else is refused, and the reader is not offered\nthe arrangement either, since it would take away the only door the register has.\n\n**`scope` \u2014 the one subject every read of the app narrows to.** Stated on the\nAPP rather than on its screen, because it is not a filter: a record opened under\nit stays under it, the pick survives closing the app, and every app declaring the\nsame `entity` shares one pick per viewer \u2014 which is the whole value, and what\nstops a construction workspace asking which project twelve times. `entity` is the\nmodel\'s entity whose one row the app is read inside, and `param` is what the\napp\'s reads take that row by.\n\n```jsonc\n{ "alias": "site_work", "name": "Site work",\n  "scope": { "entity": "project", "param": "project_id" },\n  "screen": { \u2026 } }\n```\n\nThe register\'s own entity has to REACH it \u2014 its own rows, or rows that name one\nthrough a link \u2014 or the switcher is a control that changes nothing. Until a\nsubject is picked the app reads NOTHING and says which one it is waiting for: an\nunscoped read over a scoped app is every row in the workspace drawn as one\nproject\'s work, which looks correct.\n\n**ONE RECORD SURFACE PER ENTITY, AND ITS KIND IS THE ENTITY\'S.** An app is one\nregister, so the record its rows open is the register\'s own and the kind comes\nfrom that register\'s shape. Another app over the same entity opens the same kind\nof record: a payment read from a cash book and one read from a trend are both\nmovements, and both read proof first. A shape with no kind of its own (a trend, a\nmonitored set, a `custom` screen) says only where the record opens.\n\n**Two things a register states about a row beyond which field fills which slot.**\nA `measure` is read AGAINST its limit (`against`/`alert`) where the shape\'s slot\ntakes one \u2014 `level`, on a lifecycle desk and a monitored set, and every slot of a\n`custom` screen, which composes the frame\'s own column; `worth`, `availability`\nand a trend\'s headline are plain figures, and a limit there would read as a meter\nin the record over a number the row printed bare. And the name carries a\nSUPPORTING LINE where the entity states a key to file the row under: the `parent`\nit belongs to, its `reference`, an `autonumber`, a text formula \u2014 in that order,\nfirst hit wins, never a field a person types prose into. A LINE\'s record heads\nwith that same key, so the register and the door it opens name one row one way.\n\n**The act that opens a row belongs to a register that LISTS the entity\'s rows**\n\u2014 a desk, a register, a ledger, a monitored set, or a `custom` screen. A shape\nwhose rows are not records has neither that act nor the door a counted line\nelsewhere leads to: an obligation desk\'s rows are deadlines and a trend\'s are\nperiods, so a create pressed there would open a row the screen cannot show. An\nentity whose only app is one of those has no create at all \u2014 give it an app whose\nregister its rows are read in.\n\n**An `obligation_desk`\'s rows are not its entity\'s rows.** The shape fans the\nentity\'s `obligation` fields out \u2014 one row per thing still owed, which is one\nwhose date is SET and whose `satisfied_by` is empty \u2014 so a l\xF4 with four cut-offs\nis four rows, and the three it has met are not there at all. The row\'s name is\nthe obligation\'s, its supporting line the record\'s `identity`, and the door is\nthat record. A `when` bound to `runway` is what the countdown\'s ring is measured\nfrom. Over an entity declaring no `obligation` the shape is refused: there is\nnothing to count down to.\n\n**What a register carries beyond its columns.** Six clauses, each emitted as\nthe prop the kit draws it with; every one is optional and a screen that states\nnone gets a register of columns and nothing else.\n\n- **`period`** \u2014 a field on the entity whose value is a DATE. The toolbar gains a\n  date-range control (this month to start), and the rows it keeps are what the\n  register AND every figure below are computed over, so a band can never be over a\n  different window than the rows under it. Any such field, not only the `when`\n  role, and however the date got there: one table is read two ways (a cost ledger\n  by the day a line arose, the cash book over the same table by the day it\n  settled), a role is one field\'s, and the day money MOVED is often a formula over\n  the two columns that could hold it \u2014 which then declares `output_type: "date"`.\n  A `trend_deep_dive` brings its own period and takes none here; a `live_board`\n  is PERIODLESS and takes none either, for the opposite reason \u2014 it answers what\n  is true NOW, and a date range over it draws what was true in the window in the\n  live state\'s own colours.\n- **`filters`** \u2014 the chips beside the search. A single-`select` field\'s alias\n  offers that field\'s own live options; it is the lens a register is read through\n  over and above the one band its strip gives, so the strip\'s own field is\n  refused here (one dimension, one control) and so is a multi-select (a row would\n  answer the chip several ways at once). The rows the register and every figure\n  below are computed over are what the chips AND the period kept.\n  A DERIVED LENS is the other form \u2014 `{"label": \u2026, "predicates": [{"label": \u2026,\n  "tone": \u2026, "where": \u2026}]}` \u2014 where the sets a reader narrows by are ones the\n  MODEL names and no column holds: rate validity, plan urgency, free-time\n  overrun. Each `where` is an `and` group of plain conditions over the entity\'s\n  own fields, each `field_key` a field alias, and it is read off the row, so the\n  operators are the comparisons a value answers \u2014 `number` and `text` equality,\n  `number` ordering, `boolean` equality, `select` `has_any_of`/`has_none_of`, and\n  `is_empty`/`is_not_empty` on any of them. Nothing DATED: a relative point needs\n  a clock, and a screen states one date control (`period`), so a second beside it\n  would be two windows with nothing saying which a figure was computed over \u2014 a\n  date question is asked as a column the model derives and read here as a number\n  or a yes/no. `tone` is the option palette\'s, because the chip draws these\n  exactly as it draws a select\'s options.\n- **`summary`** \u2014 what the rows in view come to. `above` is a band OVER the\n  register: `"counts"` for how many rows are in view and, for the FIRST\n  `measure` the model gives a limit, how many are past it (accented only when\n  one is) \u2014 one such set, because a band naming three is the dashboard a\n  register is not; a list of number-field aliases for what they add up to, and a\n  `percentage` named there is refused, since a share summed over the rows in\n  view is a figure of no kind (draw it as a column, whose own total reads the\n  mean). A figure written `{"field": \u2026, "at": "end"}` is a STOCK instead: the\n  reading standing at the END of the window rather than the sum of the readings\n  in it, which is the only way opening + in \u2212 out = closing reconciles \u2014 a month\n  of daily closing stocks added together is thirty warehouses. The band labels it\n  as the snapshot it is, and it is refused on a screen that states no `period`,\n  since there is then no window for it to stand at the end of.\n  `ageing` stands in that same\n  band: an `amount` split by how many days past its `due` date each row is,\n  drawn as a `Breakdown` of the edges in `buckets` (30, 60 and 90 days unless the\n  model states its own, ascending). The ladder is the kit\'s \u2014 its boundary, its\n  words and its ramp \u2014 and it opens with what is NOT YET DUE, because a bar of\n  overdue bands alone is full at every input: a book with one late invoice and a\n  book that has gone entirely bad would paint the same solid width. Against the\n  current money the bar\'s own shape is the reading. A row whose date is empty is\n  in no band. `totals` is what the whole\n  view adds up, and it is drawn in that SAME band above the rows: a register\n  states one aggregate, over the rows the reader can see, in one place, and a\n  closing line under them is a second place to look and a second question about\n  which rows it covers. A closing line belongs to the one device that IS a\n  statement \u2014 a record\'s `Ledger`, whose balance is what it is read for, labelled\n  by its amount\'s own word. Where a shape has no band above (a trend, whose own\n  band is the chart) the figure stands under the register instead. A\n  `transaction_ledger` sums its amount column itself and takes `above` alone. An\n  `obligation_desk`\'s rows are DEADLINES and not records, so its band states\n  `"counts"` \u2014 how many are open \u2014 and a figure list, an `ageing` or a `trend`\n  over it is\n  refused: a l\xF4 with three cut-offs is three rows, and its freight added over\n  them is three times the freight.\n  `trend` is `{"field": \u2026, "direction": "up"|"down"}` and states WHICH WAY that\n  figure moved across the window: the rows in view are cut into the window\'s own\n  buckets \u2014 days over a month, weeks over half a year, months beyond \u2014 and the\n  later half of the CLOSED ones is read against the earlier half, drawn beside\n  the figures as one line, so a window the reader is still inside states the\n  movement of the days that have run rather than a fall into the ones that have\n  not. `direction` is which way is GOOD, which nothing about the number\n  says: a book wants its takings rising and a backlog wants its days falling, and\n  the same arrow is a win on one and an alarm on the other. It needs a `period`\n  to be a window of, and it is refused on a shape that draws its own (a\n  `trend_deep_dive` already draws the series) or that reads none at all (a\n  `live_board` answers what is true now). A window whose earlier half took\n  nothing draws no line: there is no base for a percentage, and 0 % would claim a\n  steadiness nobody measured.\n- **`facts`** \u2014 how the RECORD\'s facts are banded. `groups` is a list of\n  `{caption, fields}`: what a set of facts has in common is a sentence about the\n  business and nothing derives it, so a plan that states one gets exactly those\n  bands, in its own order, captioned. Everything it leaves unnamed reads in the\n  derived order below it. A field the header, the band, the ladder, a required\n  set, the files or a register below already draws is refused: it is not a fact,\n  so a band naming it would either state it twice or draw nothing. Naming any\n  band IS the answer to which facts fold \u2014 see the TIERS below.\n- **`presentation`** \u2014 how the screen and the record it opens are DRAWN, where\n  what the rows are is not the answer wanted. `lead` is what each row leads\n  with: `"mark"` the subject\'s own mark, always spent because a party\'s initials\n  stand in for a picture nobody uploaded; `"picture"` the photograph, spent only\n  on the rows that carry one and, on the record, at media scale above the name;\n  `"paper"` the row\'s own files, drawn as the cards a pile of documents is read\n  as; `"figure"` the amount, with no gutter at all; `"none"` neither. `density` is\n  how many lines a row\'s subject may take \u2014 `"roomy"` two, `"dense"` one.\n  Both default, and the DEFAULT is what the rows are: a party register leads\n  with the mark, an offering register with the picture, a ledger with its\n  figure, and a desk \u2014 rows that are work still to do, scanned \u2014 stands its rows\n  one line each while a record\'s own rows are read roomy. So state it only to\n  differ, and a plan that states nothing still gets screens that vary. A lead\n  the rows cannot carry is refused: a mark, a picture or a paper where no column\n  is drawn as the rows\' mark, a\n  figure where no column is the amount, and the other subject\'s mark (which of\n  the two a row wears is the shape\'s, so the register and the record it opens\n  cannot call one row two kinds of thing).\n  `layout` is how the rows are ARRANGED \u2014 `"table"`, `"list"`, `"cards"`,\n  `"gallery"`, `"board"`, `"calendar"`, `"timeline"`, `"gantt"` \u2014 and it is\n  AFFORDED by what the rows carry, not by the shape: every register affords a\n  table and a list, a `mark` affords the two picture-led grids, a `lifecycle`\n  affords a board, a `when` affords a calendar and a timeline, and a `when`\n  beside a `measure` that `counts` DAYS affords a gantt, because a bar with no\n  length is a calendar drawn sideways and a bar measured in money or litres is a\n  length of another kind. `until` names the date field a bar ENDS on, where the\n  rows state one, and the days measure is what the bar runs for without it. A\n  layout the bound roles do not afford is refused, naming the ones they do.\n- **`acts`** \u2014 where this screen hands work on: `row` is the \u22EF menu on every row,\n  `record` is the \u22EF on the RECORD\'s own page header \u2014 the same reach as a row\'s,\n  standing where the work is open instead of while a list is scanned, and refused\n  on a record that opens as a drawer, which has no header of its own and whose\n  row already carries the register\'s menu \u2014 and `selection` is the bar over the\n  TICKED rows. `export` is the third reach \u2014\n  the WHOLE VIEW, saved in one press: `true` writes the rows as the register drew\n  them, in the columns it drew, as an `.xlsx`, and\n  `{"template": "\u2026"}` says the layout is the trade\'s and makes the paper with a\n  workflow like any other. It is never a list of columns: which columns the\n  export carries is what the screen already draws, and a second statement of it\n  disagrees the moment a slot moves \u2014 the generator reads them off the drawn\n  slots and writes them into the app, so the sheet\'s headings are the labels the\n  register drew them under.\n  `import` is the reach OPPOSITE it \u2014 a file turned into rows:\n  `{"kind": "import", "label": \u2026, "entity": \u2026, "key": \u2026, "columns": [...]}`. The\n  file is mapped column by column, each row is validated, what would change is\n  previewed, and the commit UPSERTS by `key` \u2014 which is why a sheet sent twice\n  moves no counts. That key is one of the entity\'s own `natural_key` fields\n  (\xA7 Write rules), and an entity declaring none is refused: without a key the\n  second run is a second set of the same rows. `entity` is the register\'s own \u2014\n  an app is one register, and rows filed into another entity are a count nobody\n  on this screen can check. `columns` is what the sheet may fill, in that order;\n  absent, it is every column a person states IN WORDS. A computed one is refused\n  because the workspace writes it, and a link, a member or a files column is\n  refused because a cell of a sheet is words and those hold a row of another\n  table or bytes \u2014 a file reaches another table through the party pattern (a\n  `natural_key` on the target, named rather than picked), which is a create\'s.\n  The generator writes the whole verb, as it does for a paper: an\n  `import_<entity>` workflow that finds the row by `key` and then changes it or\n  opens it, answering which of the two, and the staged run over it \u2014 drop, map,\n  the per-row verdict, the commit. A line whose cell the column cannot hold is\n  refused with the reason and the rest of the sheet still lands.\n  Both spreadsheet reaches are read and written IN THE BROWSER, so the generated\n  `src/main.tsx` imports `@lotics/app-runtime/sheets` wherever the plan states\n  one of them and not otherwise; an app that has neither carries no spreadsheet\n  engine at all. An act names ONE of three things, never two:\n  - **`template`** \u2014 an `html` template this model declares (\xA7 Templates). The\n    paper is filled from ONE row in `row`, and from the whole ticked set in\n    `selection`. The generator writes the whole verb \u2014 a `generate_<template>`\n    workflow that reads the row and hands the file back, and a menu item that\n    opens it \u2014 so there is nothing left to bind. An `email` template is sent\n    rather than opened and is refused here; a file-backed template (`excel`,\n    `word`, `pdf-form`) is bytes a model has none of, so those stay the author\'s\n    own `lotics app workflow set`. Two screens over DIFFERENT entities cannot\n    name one template: one paper is filled from one kind of row.\n  - **`{"kind": "agent", \u2026}`** \u2014 a run over ONE row. `agent` is an alias the APP\n    declares (`package.json#lotics.agents`), because an agent is prose and tools\n    rather than anything a workspace model can state \u2014 `lotics app check` refuses\n    one nothing declares, exactly as it refuses a workflow nothing bound. `fills`\n    is the fields the run may write: pressed, the reader watches the run, reviews\n    what it proposes field by field against what the row holds now, and applies\n    the ones they kept as ONE write through the record\'s own update. A run can\n    reach nothing outside `fills`, a computed column there is refused (the\n    workspace writes those), and a screen stating `writes: false` refuses an\n    agent act outright. It belongs in `row`; the selection bar makes ONE paper\n    from many rows, and a run per ticked row is the row\'s own act many times.\n  - **`{"kind": "workflow", "workflow": "\u2026", "inputs": {\u2026}}`** \u2014 the work HANDED\n    ON: a lead becomes an opportunity, an order is split into the orders placed\n    on its suppliers, a request is closed. `workflow` is an alias the APP binds\n    (`package.json#lotics.workflows`), because the rule behind it is the\n    business\'s and no model states one \u2014 so the generator writes NO body and\n    `lotics app check` refuses an alias nothing bound, exactly as it refuses an\n    agent nothing declares. `inputs` is what the press hands that body: the\n    workflow\'s own input name \u2192 `"record"` for the row it was pressed on, or a\n    field of this entity for a value off that row. The value is what the\n    workspace HOLDS \u2014 an option\'s key, a linked row\'s id, the figure \u2014 never the\n    rendering. A files column is refused (the body reads the row\'s files off the\n    row it is handed), a column that is not a field of the entity is refused by\n    name, and one input short of the declaration is refused at the press, so the\n    whole act is dropped rather than shipped half-bound. It runs ON the press:\n    there is nothing to review first, which is the agent arm\'s law, and the\n    body\'s own sentence is what the reader is told either way. It stands in\n    `row`, in `record` and on a `section_acts` band \u2014 each reaches ONE row \u2014 and\n    is refused over the ticked set, where one act makes one paper from many.\n\n  **`"place": "cta"` draws an act ON the row** instead of in its \u22EF \u2014 the one verb\n  a reader presses without opening a menu first. At most one per screen and every\n  other act stays in the menu, because the trailing gutter is paid for by every\n  row: a second is refused with *one verb on the row, the rest in its menu*. The\n  ticked set has no row of its own, so `cta` is refused there.\n\n  A hand-off\'s BODY is still the author\'s: `lotics app workflow set <alias>`\n  binds it, and `scaffold check` prints the act as `"<label>" \u2192 <alias>(\u2026) [you\n  write the body]` so it is read as work owed rather than as a verb already\n  wired.\n\n  A `selection` act is a `template` and nothing else: an act over many rows makes\n  ONE paper from them. The generator turns the register\'s checkbox gutter\n  on, emits a `generate_<template>` workflow taking the ticked ids, and the body\n  reads each row and passes them as `rows` \u2014 which is what the template iterates\n  (`{{#each rows}}`). One template is one paper AND one reach: naming the same\n  one from a row\'s \u22EF and from the bar is refused, because those are two bodies.\n  A shape whose rows are DERIVED rather than records \u2014 an `obligation_desk` \u2014\n  has no set to tick and refuses the clause. The paper is handed BACK, never\n  filed: a ticked set can hold rows of three different parents, so there is no\n  record on which "this document belongs here" is true.\n\n**`section_acts` puts a verb WHERE ITS EFFECT LANDS.** "Chase the paperwork"\nbelongs on the papers, not in the register\'s \u22EF two surfaces away. It is keyed by\nthe alias each section is DERIVED from \u2014 a field\'s (its progress, its prose, its\nrequired set, its charge, one of its files) or a CHILD ENTITY\'s (its register,\nits desk, its run, its thread) \u2014 because the sections come off the roles and the\nkey the app addresses one by does not exist until it is built. An alias naming no\nsection is refused, listing the ones that do; the facts band is what every other\nsection left over, so nothing addresses it. Each act is a `template`, an `agent`\nor a `workflow`, exactly as a row\'s is \u2014 the reach is the same one row \u2014 and\n`place: "cta"` is refused: a section is a band with a heading and has no row to\ndraw a verb on. `scaffold check` prints\nwhich section each alias landed on, which is the half an author cannot see in\ntheir own file.\n\n**`sections` says HOW one of those sections is DRAWN**, keyed by the same\naliases. The one reading it carries is `"draw": "worksheet"`: the child\'s rows\nare PRICED LINES the reader works down in place, each part of the job footed and\nthe sheet closing under them. `cost` and `sell` name the child\'s two figures,\nwhich is the one thing the roles cannot decide \u2014 an entity carries one `amount`,\nand a line that is costed and sold carries two. Everything else is read off the\nchild\'s own roles: what a line is FOR is its `identity`, how many it is for is\nthe `measure` the pair left, and the part it falls under is its `category`. The\nMARGIN is on none of them, because it is arithmetic over the pair.\n\nA sheet is the WRITE side of a price, so it is the one child section whose cells\nare editors: a figure typed into a cell is written as a diff through the child\'s\nown update, which is the same editor the line\'s own drawer saves through. Every\nother child section is read where it is drawn and edited in the row\'s drawer. A\nline is ADDED from the section\'s heading as every child\'s row is, with the record\nit hangs under as the act\'s own context.\n\nRefused: an alias naming no register of this record, rows the record is merely\nthe `party` or `link` of (a line added to a history belongs to the job it is\nabout, not to what is reading it), a figure that is not a field of the child or\nwhose role is neither `amount` nor `measure`, a sheet naming neither figure, and\none figure priced as both.\n\n**A CHILD NOBODY REGISTERS IS A NOTE, not a refusal.** Where a record lists a\nchild entity no app is a register of, `scaffold check` says `"<entity>" has no\nregister \u2014 its rows are read here and created nowhere` and the plan printout\nmarks that entity `(no app)`. Rows can arrive from an import or a workflow, so\nit is a reading rather than a rule; what it catches is the register somebody\nmeant to plan and did not. A thread is exempt \u2014 a reply is written where it is\nread \u2014 and so is a sheet, which opens its own lines.\n\n`scaffold check` prints every clause a screen states, on its own line under the\nslots, spelling the screen\'s `writes` clause `operable` \u2014 the app manifest\'s\n`lotics.writes` keeps that word, and the two are different facts: `app create`\nSEEDS the manifest from the fields the screens\' own editors write, and from then\non the app owns the declaration `lotics app check` holds its bodies to.\n\nEach shape is a `@lotics/ui` component of the same name (`LifecycleDesk`,\n`PartyRegister`, \u2026) whose props are these slots, so once the tables exist\n`lotics app create <name> --from <this file>#<app alias>` scaffolds the app with\none screen per entry, each slot reading the field the plan bound.\n\n`"shape": "custom"` is the screen no registry row covers: it declares its own\n`roles` (slot name \u2192 role), and it is emitted on `ShapeFrame` \u2014 the one anatomy\nthe six shapes above are each a configuration of \u2014 so its strip, search,\nordinal, fit budget, empty and waiting states and record door are the same ones\nthey have. It opens the record its `record` says, drawer or page, like any other.\nA bound `lifecycle` slot IS its strip, the stages in the field\'s order as on a\ndesk, so such a screen names no `tabs`; a `tabs` select is the flat strip a\nscreen with no lifecycle gets.\n\n**An app IS its `app.json`.** `create --from` writes the bound plan \u2014 every\nscreen with its shape and slots, the record each row opens with its sections in\nthe archetype\'s order, the create panels, the acts \u2014 as one JSON document, plus\na five-line `src/main.tsx` that mounts `@lotics/app-runtime` over it and one\n`src/workflows/<alias>.ts` per write. There is no screen source: the runtime\ndraws the spec, so a kit correction reaches every app with its next install.\nWhere the plan has no word for what a screen or a section IS \u2014 or for what a\npaper act should ASK before it is made \u2014 the spec names one of the app\'s own\ncomponents and `src/components/index.ts` registers it, the one file under `src/`\na regeneration never rewrites. `lotics app eject <screen|<section key>|<act\nlabel>>` writes each of those, starting from what the runtime already drew.\n\n**How a spec reads a row.** Each query projects its columns under the alias the\nworkspace mints from the field\'s LABEL \u2014 never the alias this file keys it\nunder, which is the model\'s own namespace and which the workspace never saw. So\na field this file calls `partner` and labels `\u0110\u1ED1i t\xE1c` is referenced as\n`doi_tac` throughout the spec. Every id in it is live: the `tbl_` a screen is\nover, the `fld_` of each column, and the `opt_` of every option a role names.\n\n**Every query is described, in the model\'s own language.** The line an agent\nchooses between aliases by is written from this file\'s nouns \u2014 the entity\'s\nlabel, the screen\'s, the link\'s \u2014 and the sentence around them is the language\nthe file is mostly written in, decided the same way a generated write\'s refusals\nare. Hand-editing one is erased by the next regeneration; `lotics app check`\nrefuses an alias that carries none.\n\nA screen is that list and the RECORD it opens, and the record comes off the same\nroles \u2014 nothing to declare for it. It opens with a **header**: the entity\'s\n`identity` as the record\'s name \u2014 whether or not the list has a column for it, so\na ledger\'s and a trend\'s records are named too \u2014 the `when` this screen reads\nunder it, and ONE headline\nfigure (the `amount` the screen reads, else its `measure`). BOTH DOORS state the\nname: which door a screen uses is a layout answer, and what the record is ABOUT\nis not.\n\n**A JOB\'S HEADER ALSO STATES WHO IT IS FOR.** Where the record is the work itself\n\u2014 a desk\'s rows that belong to nothing, opened on a page \u2014 its `party` is a link\nunder the name, beside the ways to reach the subject, and it is then not a fact\nas well: a page headed by a code alone said nothing about whose work it is, and\nthe one thing a reader arriving from the desk already knows the row by sat in the\ngrid below as a row among forty. A record opening in a DRAWER has no row of links\nto hang it on, so its party stays a fact; so does a LINE\'s, whose register files\nit under the thing it belongs to and whose party is that parent\'s, restated per\nrow.\n\n**A record whose figures are a SENTENCE states them under the header, in a\nband**, and the header then states neither of them: a job reads what it comes to,\nhow far through it is (the `measure` against its limit), what is left of it (a\nformula that is exactly `{amount} - {measure}`) and how long there is (an\n`obligation`, else its `when`, counted down); a party reads its settlement, the\n`amount` and `measure` roles it carries in the order the model declares them; a\ncatalogue item reads its `amount` against the reference that amount names. Two\nfigures are the floor and four the ceiling \u2014 under two, the header keeps its one.\nA band is a PAGE\'s strip, so a screen whose `record` is a drawer keeps every\nfigure where a drawer reads them. Each figure is drawn exactly once: the limit a\nmeter states is not a fact beside it, and the day a countdown counts to is not\nthe provenance line above it. The `lifecycle` is not badged there, because the progress section is the\nrung it stands on. Then its sections, in the order its KIND reads them: the\n**facts** (every field neither the header, the band nor another section owns, the\nrow\'s own `parent` among them \u2014 led by the ones THIS screen\'s slots bound, then\nthe key it is filed under, then the order the model declares them in),\nthe record\'s own **body** (every `text` field the entity formats as `markdown` \u2014\nprose read at the width of the work, never wrapped to a label in a column\nbeside it), the **charge** (where the `amount` is a formula over exactly one\nquantity and one money field, the line states `quantity \xD7 unit price = amount`\nand neither figure is typed twice \u2014 the section is headed by the amount\'s own\nlabel and the closing row says what the figure IS, so the word is said once),\nthe **progress** (the `lifecycle`\'s stages, and the ONE act that moves the record\non \u2014 every other move, outcomes included, is an item in the menu beside it), a\n**required set** (a multi-select `expected_set`, or a child entity whose rows\ncarry one entry of it each \u2014 that child\'s `files` field is what a paper attaches\nto), the record\'s **own rows** (any other child, its role-bound fields as\ncolumns), and its **files** (every `files` field, the `mark` first \u2014 a section of\nthe column like any other, straight after the facts it is the evidence for,\nexcept on an EVIDENCE record, which OPENS on the paper it exists for; the\nheading carries the Add verb, and stands it down while the pile is empty, where\nthe drop well is already the door; and a `verdict` whose FORMULA reads one of\nthose files fields is the pile\'s OWN state rather than a fact row \u2014 the file it\nis short, drawn as a ghost, and the mark the rail sends a reader to). A child is\nan entity that LINKS here, ONE SECTION PER LINK: the rows it owns (`parent`), the\nrows that name it (`party` \u2014 so a party\'s record is its history), and the rows\nreaching it through a link carrying neither role, headed by that link\'s own\nlabel. A child hanging off two records therefore declares one `parent` and\nleaves the second relationship a plain link, which still gets its section.\n\n**THE ROWS A RECORD OWNS ARE ADDED AND OPENED FROM THEIR SECTION.** A `parent`\nsection\'s heading carries the Add for its rows, handing the record as the\nparent \u2014 filled, never asked. Every row opens its own record \u2014 a line of a book,\na paper on a desk, a stop on a timeline alike: where this app already routes a\npage for those rows (the register\'s own, under one of them) it is navigated to;\notherwise it is a DRAWER mounted on the record it belongs to, stepped \u25C0 \u25B6 over\nthe section\'s rows as they are drawn, with the row\'s framed editors, its ladder\nand its files, saving through `update_<child>` \u2014 the one editor those rows have,\nwhich any control the section draws over a row writes through too. Never the\n`parent` link itself: it is the key the row is FILED under, stated by the record\nthe drawer was opened from, so it is neither a fact of the drawer nor an input\nof that editor. ONE LEVEL, and only from a PAGE: a child\'s own children draw as\nthe kit\'s panel of the row, with no drawer and no Add, and a register whose own\nrecord is a DRAWER is the same for the children it owns \u2014 a drawer mounts no\ndrawer. **A ROW IS ADDED WHERE IT CAN BE OPENED AGAIN**, so those sections lose\ntheir Add with their drawer; a row of the register\'s OWN kind keeps it, because\nthe register\'s list opens it. A correspondence\'s entries are the one owned row\nthat opens nothing anywhere: the composer under them is the section\'s Add\nwhatever door the record has, and the answer mark is one field of the reply\'s\nown editor. The rows a `party`\'s record lists, and those reaching a record\nthrough a roleless link, are read only \u2014 a history, never a place to open or\nadd.\n\n**TWO CHILDREN ARE READ AS A RUN RATHER THAN AS A REGISTER**, and the model says\nwhich by the roles it declares on them. A child carrying an `obligation` whose\n`satisfied_by` is a DATE is a **timeline**: its rows are the ordered stops, each\nstating the day it was promised for and the day it happened, with the delta named\nwhere the rung was late \u2014 drawn as a register those are two date columns and the\nreader subtracts them by eye, which is exactly what "three days late at\ndischarge" costs to learn. An obligation closed by a FILE says nothing about\nwhen, so those rows stay the register they were. A child carrying a `markdown`\ntext field beside a `party` and a `when` is a **thread**: the entry is the body,\nthe author and the day lead it, and a `verdict` on the child is the yes/no one\nreply is marked the ANSWER with \u2014 a register of messages is a table whose one\nuseful column is the one it cannot draw. A SECOND `party` on those rows is who\nthe entry was left WITH, and the latest one names the ball in court: while\nnothing answers, the record says whose move it is and counts its own deadline\n(an `obligation`, else its `when`) against them. Both are read only under the\nrecord that OWNS the messages \u2014 under the party who wrote them the same rows are\nthat party\'s history, several questions at once, and the last of them says\nnothing about any. That record also REPLIES: the section\'s Add is a composer \u2014\nthe message is all a reply asks \u2014 and the answer mark is one field of the\nreply\'s own editor.\n\n**NOTHING SITS BESIDE THE RECORD.** A page is ONE reading column \u2014 its fields,\nits files, the rows it owns, its notes, all sections of it in the archetype\'s\norder \u2014 over a reserved left gutter holding a floating NAVIGATION RAIL: the way\nback, then one line per section with that section\'s category mark, and nothing\nelse. No files, no counts, no group headings. Too narrow to seat the rail, it is\none pinned bar of the same list across the top. A section HEADING never wears\nthe mark; the rail\'s line for it does.\n\n**A RELATION THE RECORD NEVER ACTS ON CLOSES THE COLUMN.** Every register that\nmerely NAMES the record is one counted line of a single last section: its label,\nhow many rows name this record (a COUNT, never a page of rows measured), and a\npress that opens the register owning them narrowed to this record. An entity\nthis app lists nowhere is a count with no door, and where every count is zero\nthe section is not drawn at all. The one exception is a PROFILE, whose history\nIS its body and stands open in the column.\n\n**Rows the record owns whose `amount` is `signed_by` a direction are a\nBOOK**, drawn as a statement \u2014 each line dated and signed, the balance under\nthem where there is more than one line to add up, labelled by the amount\'s own\nword \u2014 where the same rows on the party they\nwere transacted with stay that party\'s history, which is scanned for the line\nshort of its paperwork rather than struck to a balance. **Rows that carry a\n`when` read as RUNS**: a party\'s history under the year \u2014 and only where the rows\nin hand span more than one, since a subhead over every line of a book names the\nyear and separates nothing \u2014 and a job\'s own rows under the day they fall on,\nwhich, where those rows also carry a `lifecycle`, is an ITINERARY rather than a\ngrouped table: the day heads the run, each row is one line (its `slot`, its name,\nits party, its stage, its `category` and `reference`, its amount), the figures end\non one edge and the run closes with their sum \u2014 unless the record\'s own BAND is a\nsum rollup over exactly these rows, which states it once already. A `category`\npaints the node the run is read down, in the option\'s own colour; a `reference`\ncloses the line with the code somebody quotes on the phone. Both are PROJECTED for\nthe run whether or not the register\'s column budget would have drawn them.\n**EACH DAY\'S HEAD CARRIES THE SECTION\'S OWN ADD** as well, handing the panel that\nday, so a line made from Tuesday opens with Tuesday answered; the heading keeps\nthe verb too, for the first line and for a day nothing is planned on yet. **THE\nKEY LEAVES THE COLUMNS where the head states the whole of it** \u2014 a day head does,\na year head states four digits of the date and the day is what the column is\nstill there to carry.\n**A run is READ FROM THE END THE READER WANTS**: a job\'s own rows and an itinerary\nascending, a book and a history descending.\n\n**A DESK OVER AN ENTITY THAT CARRIES A `slot` IS ITSELF A DAY\'S RUN.** Its own\nregister is drawn under one subhead per day, sorted by that day and then by the\npart of it, and the date column goes \u2014 the subhead states it once for the whole\nrun, and a column repeating it down every line is the same value twice. Without\nit an itinerary was one flat list in whatever order the rows arrived.\nA document desk keeps its head either way \u2014 the entries it owes are its\ncontent, filed or not. The name and whatever figure is left to it are the header\'s\nalone \u2014 it states them in full, so a fact for either would be the same sentence\ntwice.\n\n**A FACT IS PRIMARY OR IT IS PROVENANCE.** An `autonumber`, a date the platform\nstamps (`derive_from`) and a date a formula works out that no role names are what\nthe SYSTEM wrote; they fold, with every optional field this record does not\nstate, behind the grid\'s ONE link. Everything a person types or picks is primary\nand is shown, empty or not, because absence is work somebody owes. **A screen\nthat named `facts.groups` has already said which:** a field in a group is\nprimary, and one in none folds \u2014 grouping says what the reader decides with, and\nby saying so says the rest are not. A `tier` on a `facts` entry exists only for\nthe case that derivation gets provably wrong.\n\n**A `contact` field whose kind the\nmodel decides** \u2014 an email, a number, a place, a `link`-formatted text, or a\nMESSAGING APP its label names (WhatsApp, Zalo, Telegram, Viber, WeChat, Line,\nMessenger) \u2014 leaves the facts too, for the row of links under the name on a\nrecord that opens as a page; one whose kind nothing decides stays a labelled\nfact, because a scheme nobody stated is a link that opens nothing. A handle is\ndrawn under its app\'s name \u2014 the app is what identifies the person there, and a\nbare number beside an envelope says the wrong thing \u2014 and it dials only where its\nvalue IS a number.\n`check` prints the record under each screen\'s slots:\n\n```\n  Orders \u2014 lifecycle desk over Orders (12 rows) \xB7 page \xB7 tabs: Stage (New \u2192 Quoted \u2192 Confirmed \u2192 Shipped \u2192 Done)\n    stage Stage \xB7 identity Order no. \xB7 mark Photo \xB7 party Customer \xB7 amount Total \xB7 level (none \u2014 no field declares "measure") \xB7 when Due\n    record: header (Order no. \xB7 Customer) \xB7 band (Total \xB7 Shipped against Lines \xB7 Due counting down) \xB7 progress: Stage (5 stages) \xB7 facts (Ship to \xB7 \u2026 2 filed) \xB7 files: Photos \xB7 documents: Papers (Kind: 4 required) \xB7 itinerary: Order lines by Ship by at Window, kind Handling, ref Waybill (Product \xB7 Quantity \xB7 Line total) \xB7 related: Visits (count via Order)\n```\n\nThe ORDER of that line is the record\'s own, top to bottom, and it is the KIND\'s,\nand every entry of it is a section of the one column. `related:` is the counted\nline that closes it \u2014 a register the record never acts on, named and counted \u2014\nand `\u2026 N filed` is how many facts fold behind the grid\'s one link.\nA child register whose `amount` is `signed_by` a direction is a BOOK of movements\n\u2014 what the record came to rather than what it is made of \u2014 so it closes the\ncolumn rather than standing among the rows the job is made of.\n\n**A section over a child is named by the CHILD\'s own label**, because the reader\nalready knows which record they are on: "\u0110\u01A1n h\xE0ng", not "\u0110\u01A1n h\xE0ng \u2014 Kh\xE1ch h\xE0ng".\nWhere two links from one entity reach this record, that label names two sections\nand each takes its own link\'s label as a qualifier \u2014 `H\u1ED3 s\u01A1 (\u0110\u01A1n h\xE0ng)` and\n`H\u1ED3 s\u01A1 (\u0110\u01A1n g\u1ED1c)`.\n\nIn that line `documents:` is a `RecordExpectedSet`, and `lines:` a `RecordChildren` over the rows\nthis record owns \u2014 `history:` where they name it as their `party` instead; a required set\nwhose entries are a CHILD entity carrying files takes `kind="files"`, and the entity\'s own\nmulti-select takes `kind="items"`, since nothing attaches to an option.\n\n**A section that knows its size says so.** Where a `measure` on the record is a\n`count` rollup over the very link a rows section hangs on, the limit it is read\n`against` is how many rows that section is OWED: the printout adds `\u2014 expects\n<limit>` and the screen draws that many ghost rows until the first one lands,\ninstead of "nothing here" two bands under a count saying three are outstanding.\n\nA figure printed as `Total (USD)` is MONEY in the currency named \u2014 a `formula`\nstates it in `formula.currency`, and a `rollup` or a `lookup` inherits it from the\nfield it reads, so read those brackets: a rate that should be in dollars and is\nprinted bare will be drawn in the workspace\'s own money. Where the entity carries\na `currency` role, the ROW\'s code outranks the field\'s on every line that states\none, and a line stating none falls back to the field\'s.\n\n**A record surface can be OPERATED, and that is the default.** Every screen with\na record gets a workflow that writes its editable facts \u2014 every field a person\nstates \u2014 so the record\'s values are edited in place and its stage is advanced\nfrom the progress section. `"writes": false` makes one screen a reader: use it\nfor a screen over rows another desk owns, never as the default. A desk nobody\ncan act on is a viewer of state somebody must go and set somewhere else.\n\n**Which facts those are is the FIELD\'s answer.** Text, number, date, yes/no and\nselect are typed or picked. A `"cardinality": "one"` link is RE-POINTED, through\na picker over the target entity named by its `display_field_aliases` \u2014 else the\ntarget\'s `identity` \u2014 narrowed by what the reader types and carrying that\nentity\'s own `read_scope`, so a link the plan gives neither column is read\ninstead of offering an empty list. A files field is ATTACHED TO and DETACHED\nFROM, as the delta rather than the pile, so two readers filing at once each keep\ntheir file. A many-link, an `autonumber` and every computed field are read: the\nfirst is a list a fact cannot state, and the rest are the platform\'s to write.\n\n**A one-link is that fact WHATEVER its sync.** `sync_both_ways` is one relation\nwith a field on each side, and the sides are not the same surface: the record\nthat names ONE row states it as a fact, and the MANY side is the register on the\nother entity\'s record. Declaring both directions does not give this record a\nregister of the single row its own fact already names.\n\n**The write is the record SURFACE\'s.** Its inputs are the fields that surface\noffers to save \u2014 the facts with an editor, the lifecycle its ladder advances, and\na files section over exactly one stated field \u2014 never every field a person could\nin principle type. What the header states, a limit a meter folds in, a required\nset with a section of its own and the pile a page\'s mark draws are read there, so\nno input is declared for them. A second screen over the same entity draws no\nsurface of its own and adds nothing.\n\nWhere two operable screens of one plan reach the same entity, `scaffold check`\nnames them and the apps they belong to: two desks writing one record is a\ndecision, and the split is stated on the FIELD in each app\'s\n`package.json#lotics.writes` rather than left to whoever edits second.\n\nThat workflow lands in the app as source, like every other: its body in\n`src/workflows/update_<entity>.ts` and its declaration in\n`package.json#lotics.workflows`. The two together are the binding \u2014 `lotics app\ndeploy` pushes whatever differs from what it last saw live \u2014 so the write is\nversion-controlled and travels with the app rather than being bound by hand\nafterwards.\n\nA `custom` screen declares its slots under `roles` (slot \u2192 role) and they bind\nthe same way:\n\n```jsonc\n{ "alias": "readings", "label": "Readings", "shape": "custom", "entity": "reading",\n  "roles": { "subject": "identity", "reading": "measure" } }\n```\n\n## Applying packages\n\n`apply` copies published packages into the workspace AFTER the model\'s own\ntables exist \u2014 apps over the tables you just described, and any tables of their\nown they still need. Ordered, and run by `lotics setup` and `lotics scaffold\napply` alike.\n\n```jsonc\n"apply": [\n  {\n    "package": "apg_k3nf82ldpq",\n    "bind": {                              // optional \u2014 which of YOUR tables each entity is\n      "company": { "label": "Customers", "fields": { "name": "Company name" } }\n    },\n    "no_sample_data": true                 // optional\n  }\n]\n```\n\n`bind` is keyed by the package\'s entity alias and holds the LABELS this\nworkspace uses: scaffold adopts by label, so binding points the package at the\ntables the model created instead of a second set beside them. Only naming\nmoves \u2014 a bound field must be the TYPE the package declares, or the copy is\nrefused. `lotics library list` is the shelf, and `lotics library show <apg_id>`\nlists the aliases to bind.\n\nEntries run in the order they are written, because a later one may bind onto a\ntable an earlier one created. **A refused entry stops the run and the entries\nbefore it stay** \u2014 they are separate copies, committed as they land, so the\nrefusal names them rather than leaving a caller to re-run the file and copy them\ntwice.\n\n## Presets\n\nA preset is a trade\'s model, published to be READ. An assistant reads it, asks\nat most two questions, picks a variant and writes a `model.json` from it \u2014\nnothing is copied, and a preset is a file rather than anything a workspace\ninstalls.\n\n```jsonc\n"preset": {\n  "name": "Field service",\n  "description": "Jobs, the crew that runs them, and what each one billed.",\n  "questions": ["Do you dispatch crews, or one person per job?"],  // at most 2\n  "variants": {\n    "crews": {\n      "when": "work is dispatched to crews rather than to one person",\n      "entities": [ /* tables this branch ADDS */ ],\n      "fields": { "job": [ /* fields this branch ADDS to `job` */ ] }\n    }\n  }\n}\n```\n\nVariants are **additive only**: a branch adds entities and fields and never\nremoves them, so the base is a model in its own right rather than a draft.\n`lotics scaffold check` proves the base AND every variant merged onto it, so a\npreset ships with every branch already proven \u2014 the branch nobody took is the\none that fails in the workspace of whoever takes it.\n\n`preset` is not scaffolded. `lotics setup` and `lotics scaffold apply` ignore\nit and create the base model\'s tables.\n\n`lotics scaffold export` prints a workspace that already works as one of these\nfiles \u2014 the starting point for a preset or for another business\'s model, never a\nsource of truth: it carries one business\'s words and stops describing that\nworkspace the moment either changes.\n\n## Starting from a preset\n\n`lotics library list` is the shelf of them and `lotics library show <slug>`\nprints one whole: its questions, every table as `alias \xB7 label` with each field\nas `alias:type`, and each variant as `slug \xB7 when` followed by the tables and\nfields that branch adds. When one of them is the trade in front of you, do not\ntranscribe it \u2014 name it:\n\n```jsonc\n{\n  "from": "field_service",\n  "variants": ["crews"],\n  "rename": { "job": { "label": "\u0110\u01A1n h\xE0ng", "fields": { "code": "M\xE3 \u0111\u01A1n" } } },\n  "entities": [ /* a table this business has that the preset does not */ ],\n  "rows": { "job": [ { "ref": "j1", "fields": { "code": "J-1" } } ] },\n  "field_roles": { "job": { "code": "identity" } },\n  "write_rules": { "customer": { "natural_key": ["email"] } },\n  "apps": [ /* the screens this business\'s apps will have */ ]\n}\n```\n\n- **`from`** is the preset\'s SLUG \u2014 its own file name, a lowercase slug. Naming\n  it is what makes `entities` optional; every other rule on this page is\n  unchanged, because the file is resolved into the full form and then checked and\n  applied exactly as one. A slug nothing serves is refused with the ones there\n  are, never resolved against something else.\n- **`variants`** names the branches to merge onto the base, in order. Pick the\n  one whose `when` describes what the person said; a slug the preset does not\n  declare is refused rather than ignored.\n- **`rename`** is keyed by the preset\'s entity alias and holds the labels this\n  business uses \u2014 the same shape `apply[].bind` takes, and the same rule: only\n  naming moves. An alias the preset does not declare, and a label that is\n  already another table\'s, are both refused.\n- **`entities`** are added after the rename, already in this business\'s own\n  words.\n- **`rows`**, **`field_roles`**, **`write_rules`**, **`apps`** and **`apply`**\n  mean exactly what they mean in the full form \u2014 `"rows"` are this business\'s\n  real first records,\n  `"field_roles"` may name the preset\'s fields as well as its own (a role the\n  preset declares itself is kept unless this file names the same field, or\n  clears it with `null`), `"write_rules"` the create-time clauses on either\n  (an entity this file names replaces the preset\'s whole entry for it),\n  `"apps"` the screens it will have (a preset carries none), `"apply"` the\n  packages copied in once its tables exist.\n\nThis is the ONE thing on this page that needs the network: `check` reads the\npreset it names, once. Everything after that read is the same offline check.\n\nWrite the full form when no preset is the trade.\n\n## A complete model\n\n```json\n{\n  "entities": [\n    {\n      "alias": "customer",\n      "label": "Customers",\n      "singular": "Customer",\n      "fields": [\n        { "alias": "name", "label": "Name", "type": "text", "required": true },\n        {\n          "alias": "tier",\n          "label": "Tier",\n          "type": "select",\n          "options": [\n            { "alias": "standard", "label": "Standard", "color": "slate" },\n            { "alias": "gold", "label": "Gold", "color": "amber" }\n          ],\n          "default": ["standard"]\n        },\n        {\n          "alias": "orders",\n          "label": "Orders",\n          "type": "select_record_link",\n          "target_entity": "order",\n          "cardinality": "many",\n          "sync_both_ways": true,\n          "paired_field_alias": "customer",\n          "display_field_aliases": ["code"]\n        },\n        {\n          "alias": "total_ordered",\n          "label": "Total ordered",\n          "type": "rollup",\n          "source_field_alias": "orders",\n          "aggregate_option": { "operation": "sum", "field_key": "amount" }\n        }\n      ],\n      "views": [\n        {\n          "alias": "gold",\n          "label": "Gold customers",\n          "filters": {\n            "node_type": "condition",\n            "type": "select",\n            "field_key": "tier",\n            "operator": "has_any_of",\n            "value": ["gold"]\n          },\n          "sort": [{ "field_key": "name", "order": "asc" }]\n        }\n      ]\n    },\n    {\n      "alias": "order",\n      "label": "Orders",\n      "singular": "Order",\n      "fields": [\n        { "alias": "code", "label": "Order no.", "type": "text", "unique": true },\n        { "alias": "placed_on", "label": "Placed on", "type": "date", "format": "date" },\n        {\n          "alias": "amount",\n          "label": "Amount",\n          "type": "number",\n          "format": "currency",\n          "currency": "VND"\n        },\n        {\n          "alias": "total",\n          "label": "Total with VAT",\n          "type": "formula",\n          "formula": { "expression": "{amount} * 1.1", "format": "currency", "currency": "VND" }\n        },\n        {\n          "alias": "customer",\n          "label": "Customer",\n          "type": "select_record_link",\n          "target_entity": "customer",\n          "cardinality": "one",\n          "sync_both_ways": true,\n          "paired_field_alias": "orders",\n          "display_field_aliases": ["name"]\n        }\n      ]\n    }\n  ],\n  "roles": [{ "alias": "sales", "label": "Sales" }],\n  "field_roles": {\n    "customer": { "name": "identity" },\n    "order": { "code": "identity", "placed_on": "when", "amount": "amount", "customer": "party" }\n  },\n  "apps": [\n    {\n      "alias": "customers",\n      "name": "Customers",\n      "screen": { "alias": "customers", "label": "Customers", "shape": "party_register", "entity": "customer" }\n    },\n    {\n      "alias": "orders",\n      "name": "Orders",\n      "screen": { "alias": "orders", "label": "Orders", "shape": "transaction_ledger", "entity": "order" }\n    }\n  ],\n  "rows": {\n    "customer": [\n      { "ref": "acme", "fields": { "name": "Acme Trading", "tier": "gold" } },\n      { "ref": "bluebird", "fields": { "name": "Bluebird Foods", "tier": "standard" } }\n    ],\n    "order": [\n      {\n        "ref": "so_1001",\n        "fields": {\n          "code": "SO-1001",\n          "placed_on": "@month-start+2",\n          "amount": 4200000,\n          "customer": "customer:acme"\n        }\n      },\n      {\n        "ref": "so_1002",\n        "fields": {\n          "code": "SO-1002",\n          "placed_on": "@today-3",\n          "amount": 1150000,\n          "customer": "customer:bluebird"\n        }\n      }\n    ]\n  }\n}\n```\n\n`lotics scaffold check` on this file reports\n`2 tables, 9 fields, 2 links, 1 view, 1 role, 4 rows, 2 apps`, then\nthe plan:\n\n```\nCustomers\n  Customers \u2014 party register over Customers (2 rows) \xB7 page \xB7 tabs: none\n    identity Name \xB7 mark (none \u2014 no field declares "mark") \xB7 contact (none \u2014 no field declares "contact") \xB7 worth (none \u2014 no field declares "measure") \xB7 risk (none \u2014 no field declares "verdict")\n    above: rows (default)\n    record: header (Name) \xB7 history: Orders (Order no. \xB7 Placed on \xB7 Amount (VND)) \xB7 facts (Tier \xB7 Total ordered (VND))\nOrders\n  Orders \u2014 transaction ledger over Orders (2 rows) \xB7 drawer \xB7 tabs: none\n    when Placed on \xB7 amount Amount (VND) \xB7 reference Order no. \xB7 party Customer \xB7 classification (none \u2014 no field declares "lifecycle") \xB7 document (none \u2014 no field declares "expected_set" or "verdict")\n    above: Amount (VND) (default)\n    record: header (Order no. \xB7 Placed on \xB7 Amount (VND)) \xB7 facts (Placed on \xB7 Total with VAT (VND) \xB7 Customer)\nWho writes what:\n  Customers (customer, one: Customer): Customers\n  Orders (order, one: Order): Orders\n```\n\nThe last block is the WRITERS matrix \u2014 one line per record surface the plan\nleaves operable, the word one of its rows is called, and the app whose register\nopens it. Part of the verdict rather than a diagnostic beside it: which desk\nchanges a table is answerable from the plan, and two apps on one line is the\nsplit to state in each of their `package.json#lotics.writes`.\n\nEvery `(none)` is a slot no field fills, and it says WHY: no field declares the\nrole, or several could and the plan named none of them (`(none \u2014 a, b; name\none)`). Read it as the screen a person will see. `above: \u2026 (default)` is the band\nnobody stated \u2014 the shape sums the amount its slot draws, and a plan naming its\nown figures loses the word. Neither\nentity carries a stage, a required set or files, so the rest is facts \u2014 except\nthe sections neither entity declares: the customer\'s `history:` is the orders\nthat name it as their party, and the order\'s `via Orders:` is the customers whose\n`Orders` link names it. **A link is a section, not a fact**, on the side it\npoints AT and on the side that holds it: `Customers.Orders` therefore leaves the\ncustomer\'s facts, because the section below already lists the same relation and\na link fact can only ever show the first of them. Both records state their name\nin the header and nowhere else \u2014 a ledger\'s columns are the date and the figure,\nso `Order no.` is on no column of that list and is still what the drawer behind\na line is called. `Total ordered (VND)` is the rollup inheriting the currency of\nthe column it sums: money is read off the model, never off the field\'s own line.\n';
 
 // src/scaffold_commands.ts
 function printModelReference() {
@@ -54601,11 +55310,14 @@ function describeRecord(model, resolved) {
         const required2 = section.source === "own" ? section.field : section.setField;
         const name = section.source === "own" ? section.field.label : section.child.label;
         if (required2.type !== "select") return `documents: ${name}`;
-        const set2 = section.requiredBy === void 0 ? `${required2.options.length} required` : `${count(required2.options.length, "option")}, ${section.requiredBy.field.label} decides which`;
+        const set2 = section.requiredBy === void 0 ? `${required2.options.length} required` : `${count(required2.options.length, "option")}, ${section.requiredBy.field.label}${section.requiredBy.from === "parent" ? " on this record" : ""} decides which`;
         return section.source === "own" ? `documents: ${name} (${set2})` : `documents: ${name} (${required2.label}: ${set2})`;
       }
       case "children": {
         if (draw === "related") return `related: ${section.child.label} (count via ${section.link.label})`;
+        if (resolved.screen.sections?.[section.child.alias] !== void 0) {
+          return `sheet: ${section.child.label} (${labels(section.child, section.fields)})`;
+        }
         const run = recordItinerary(archetype, recipeSlot, section.child, model.field_roles);
         if (run !== void 0) {
           const at2 = run.slot === void 0 ? "" : ` at ${fieldName(model, section.child, run.slot)}`;
@@ -54667,9 +55379,13 @@ function describePlan(model) {
       `    ${resolved.slots.map((entry) => {
         if (entry.field !== null) {
           const operated = entry.quick !== true ? "" : entry.order === "sequence" ? " [quick, next step]" : " [quick]";
-          return `${entry.name} ${[entry.field, ...entry.also].map((field) => fieldName(model, resolved.entity, field)).join(", else ")}${operated}`;
+          const under = entry.tiers.length === 0 ? "" : `, then ${entry.tiers.map((field) => fieldName(model, resolved.entity, field)).join(", then ")}`;
+          return `${entry.name} ${[entry.field, ...entry.also].map((field) => fieldName(model, resolved.entity, field)).join(", else ")}${under}${operated}`;
         }
-        return entry.ambiguous.length === 0 ? `${entry.name} (none)` : `${entry.name} (none \u2014 ${entry.ambiguous.join(", ")}; name one)`;
+        if (entry.ambiguous.length > 0) return `${entry.name} (none \u2014 ${entry.ambiguous.join(", ")}; name one)`;
+        const takes = slotTakes(resolved.screen.shape, entry.name);
+        const roles = (takes.length === 0 ? [entry.role] : takes).map((role) => `"${role}"`);
+        return `${entry.name} (none \u2014 no field declares ${roles.join(" or ")})`;
       }).join(" \xB7 ")}`
     );
     const carried = describeCarried(model, resolved);
@@ -54683,11 +55399,20 @@ function describeCarried(model, resolved) {
   const name = (field) => fieldName(model, resolved.entity, field);
   const act = (entry) => {
     const where = entry.place === "cta" ? " [on the row]" : "";
-    return entry.kind === "agent" ? `"${entry.label}" \u2192 ${entry.agent} fills ${entry.fills.map(name).join(", ")}${where}` : `"${entry.label}" \u2192 ${entry.template.label} (${entry.template.type})${where}`;
+    if (entry.kind === "agent") return `"${entry.label}" \u2192 ${entry.agent} fills ${entry.fills.map(name).join(", ")}${where}`;
+    if (entry.kind === "workflow") {
+      const taken = entry.inputs.map((input) => `${input.name}: ${input.field === null ? "the record" : name(input.field)}`).join(", ");
+      return `"${entry.label}" \u2192 ${entry.workflow}(${taken}) [you write the body]${where}`;
+    }
+    return `"${entry.label}" \u2192 ${entry.template.label} (${entry.template.type})${where}`;
   };
   const runs = registerRuns(resolved, model.field_roles);
   const drawn = resolved.screen.presentation;
   const parts = [
+    // THE CONTEXT, AFTER THE ANSWER — printed beside the slot line rather than
+    // inside it, because the two are read differently: a slot is the shape's
+    // question and a column is the author's own addition to the row.
+    ...resolved.columns.length === 0 ? [] : [`columns: ${resolved.columns.map(name).join(" \xB7 ")} (after the slots)`],
     ...runs === void 0 ? [] : [`runs: by ${name(runs.when)} at ${name(runs.slot)}`],
     ...drawn === void 0 || Object.values(drawn).every((clause) => clause === void 0) ? [] : [
       `presentation: ${[
@@ -54697,13 +55422,19 @@ function describeCarried(model, resolved) {
         // decided against what the rows carry: an author reading back
         // "board" learns nothing about the three other arrangements the
         // same screen could have taken.
-        ...drawn.layout === void 0 ? [] : [`as a ${drawn.layout} (of ${layoutsFor(resolved.slots.flatMap((slot2) => slot2.field === null ? [] : [slot2.role])).join(", ")})`]
+        ...drawn.layout === void 0 ? [] : [`as a ${drawn.layout} (of ${layoutsFor(drawnColumns(resolved, model.field_roles)).join(", ")})`],
+        // WHERE THE BARS END, in the column's own words: an author who named
+        // a finish date reads back which date the chart is drawn to.
+        ...drawn.until === void 0 ? [] : [`ending at ${drawn.until}`]
       ].join(", ")}`
     ],
     ...period === null ? [] : [`period: ${name(period)}`],
     // WHAT THE ROWS ARE, where the shape fans them out of the record: one line
-    // per thing owed, and the stamp that takes it off the desk.
-    ...resolved.obligations.length === 0 ? [] : [`obligations: ${resolved.obligations.map((owed) => `${owed.label} (${owed.field.label} \u2192 ${owed.satisfiedBy.label})`).join(" \xB7 ")}`],
+    // per thing owed, and what takes it off the desk — the stamp, or the stage
+    // the record stops owing it at.
+    ...resolved.obligations.length === 0 ? [] : [
+      `obligations: ${resolved.obligations.map((owed) => `${owed.label} (${owed.field.label} \u2192 ${owed.satisfiedBy?.label ?? "settled"})`).join(" \xB7 ")}`
+    ],
     // A DERIVED LENS IS PRINTED BY ITS SETS, never by its label alone: what an
     // author has to check is that the predicates say what they meant, and the
     // chip's own name is the one thing they already wrote down.
@@ -54723,6 +55454,10 @@ function describeCarried(model, resolved) {
     // read as whatever the reader assumes, and the cuts are what a statement of
     // account is compared against.
     ...summary.ageing === null ? [] : [`ageing: ${name(summary.ageing.amount)} by ${name(summary.ageing.due)} (${summary.ageing.buckets.join(" \xB7 ")} days)`],
+    // WHICH WAY IS GOOD IS THE HALF NOBODY CAN READ OFF THE FIGURE. A book wants
+    // its takings rising and a desk wants its backlog falling, and the same
+    // arrow is a win on one and an alarm on the other.
+    ...summary.trend === null ? [] : [`trend: ${name(summary.trend.field)} across the period (${summary.trend.direction} is good)`],
     // WHERE the sum is drawn is the reading a person checks. A register states
     // ONE aggregate, over the rows the reader can see, in the band it already
     // reads the count in — except a SHARE, which does not add up: what a column
@@ -54744,6 +55479,11 @@ function describeCarried(model, resolved) {
     // A VERB ON A SECTION STANDS WHERE ITS EFFECT LANDS, and which SECTION each
     // alias resolved to is the half the author cannot see in their own file.
     ...sectionActLines(model, resolved, act),
+    // A SHEET IS THE ONE SECTION THAT WRITES, so the plan says which register it
+    // prices and which of the child's figures is the base and which the answer.
+    ...Object.entries(resolved.screen.sections ?? {}).map(
+      ([alias, drawn2]) => `sheet on ${alias}: ${drawn2.cost ?? "(no cost)"} \u2192 ${drawn2.sell ?? "(no sell)"}`
+    ),
     ...resolved.screen.writes === false ? ["operable: no"] : []
   ];
   return parts.join(" \xB7 ");
@@ -54780,42 +55520,52 @@ function foldsAbove(model, resolved, field) {
 function aboveLine(model, resolved, name) {
   const { above, columnTotals, bandTotals } = resolved.summary;
   const folded = [...columnTotals, ...bandTotals].filter((field) => foldsAbove(model, resolved, field)).map((field) => ({ field }));
-  const named = [...above === null || above === "counts" ? [] : above, ...folded];
-  const once = named.filter((figure, at2) => named.findIndex((other) => other.field.alias === figure.field.alias) === at2);
+  const named2 = [...above === null || above === "counts" ? [] : above, ...folded];
+  const once = named2.filter((figure, at2) => named2.findIndex((other) => other.field.alias === figure.field.alias) === at2);
   const figures = [
     ...above === "counts" ? ["counts"] : [],
     ...once.map((figure) => `${name(figure.field)}${figure.at === void 0 ? "" : " at the window's end"}`)
   ];
   if (above === null && figures.length === 0) return [];
-  return [`above: ${figures.length === 0 ? "rows" : figures.join(" \xB7 ")}`];
+  const stated2 = resolved.screen.summary?.above !== void 0 || folded.length > 0;
+  return [`above: ${figures.length === 0 ? "rows" : figures.join(" \xB7 ")}${stated2 ? "" : " (default)"}`];
 }
 function totalsUnder(model, resolved) {
-  const named = [...resolved.summary.columnTotals, ...resolved.summary.bandTotals].filter(
+  const named2 = [...resolved.summary.columnTotals, ...resolved.summary.bandTotals].filter(
     (field) => !foldsAbove(model, resolved, field)
   );
-  if (named.length === 0) return [];
-  return [`totals: ${named.map((field) => fieldName(model, resolved.entity, field)).join(" \xB7 ")} (under the register)`];
+  if (named2.length === 0) return [];
+  return [`totals: ${named2.map((field) => fieldName(model, resolved.entity, field)).join(" \xB7 ")} (under the register)`];
 }
 function describeCoverage(model) {
   return roleCoverage(model.contract, model.field_roles, model.rows).map((note2) => `  ${note2.path}: ${note2.message}`);
 }
 function describeWriters(model) {
   const appsByEntity = /* @__PURE__ */ new Map();
-  for (const resolved of resolvePlan(model)) {
-    if (resolved.screen.writes === false) continue;
-    const entry = appsByEntity.get(resolved.entity.alias) ?? {
-      label: resolved.entity.label,
-      ...resolved.entity.singular === void 0 ? {} : { singular: resolved.entity.singular },
-      apps: []
-    };
-    if (!entry.apps.includes(resolved.app.name)) entry.apps.push(resolved.app.name);
-    appsByEntity.set(resolved.entity.alias, entry);
+  const resolved = resolvePlan(model);
+  const named2 = (entity) => appsByEntity.get(entity.alias) ?? {
+    label: entity.label,
+    ...entity.singular === void 0 ? {} : { singular: entity.singular },
+    apps: []
+  };
+  for (const screen of resolved) {
+    if (screen.screen.writes === false) continue;
+    const entry = named2(screen.entity);
+    if (!entry.apps.includes(screen.app.name)) entry.apps.push(screen.app.name);
+    appsByEntity.set(screen.entity.alias, entry);
+  }
+  const registered = new Set(resolved.map((screen) => screen.entity.alias));
+  for (const screen of resolved) {
+    for (const alias of unregisteredChildren(screen, model.contract.entities, model.field_roles, registered)) {
+      const entity = model.contract.entities.find((one) => one.alias === alias);
+      if (entity !== void 0) appsByEntity.set(alias, named2(entity));
+    }
   }
   if (appsByEntity.size === 0) return [];
   const lines = [];
   for (const [alias, entry] of appsByEntity) {
     lines.push(
-      `  ${entry.label} (${alias}${entry.singular === void 0 ? "" : `, one: ${entry.singular}`}): ${entry.apps.join(", ")}` + (entry.apps.length > 1 ? ` \u2014 ${entry.apps.length} desks write this record; state the split in each app's package.json#lotics.writes` : "")
+      `  ${entry.label} (${alias}${entry.singular === void 0 ? "" : `, one: ${entry.singular}`}): ${entry.apps.length === 0 ? "(no app)" : entry.apps.join(", ")}` + (entry.apps.length > 1 ? ` \u2014 ${entry.apps.length} desks write this record; state the split in each app's package.json#lotics.writes` : "")
     );
     for (const clause of describeWriteRules(model, alias)) lines.push(`    ${clause}`);
   }
@@ -54845,9 +55595,9 @@ function writersJson(model) {
   const writers = {};
   for (const resolved of resolvePlan(model)) {
     if (resolved.screen.writes === false) continue;
-    const named = writers[resolved.entity.alias] ?? [];
-    if (!named.includes(resolved.app.alias)) writers[resolved.entity.alias] = [...named, resolved.app.alias];
-    else writers[resolved.entity.alias] = named;
+    const named2 = writers[resolved.entity.alias] ?? [];
+    if (!named2.includes(resolved.app.alias)) writers[resolved.entity.alias] = [...named2, resolved.app.alias];
+    else writers[resolved.entity.alias] = named2;
   }
   return writers;
 }
@@ -54878,7 +55628,7 @@ function planJson(model) {
         obligations: resolved.obligations.map((owed) => ({
           field: owed.field.alias,
           label: owed.label,
-          satisfied_by: owed.satisfiedBy.alias
+          ...owed.satisfiedBy === void 0 ? {} : { satisfied_by: owed.satisfiedBy.alias }
         }))
       },
       ...resolved.acts.row.length === 0 && resolved.acts.selection.length === 0 ? {} : {
@@ -54892,7 +55642,14 @@ function planJson(model) {
 }
 function actJson(act) {
   const place = act.place === void 0 ? {} : { place: act.place };
-  return act.kind === "agent" ? { label: act.label, agent: act.agent, fills: act.fills.map((field) => field.alias), ...place } : { label: act.label, template: act.template.alias, ...place };
+  if (act.kind === "agent") {
+    return { kind: act.kind, label: act.label, agent: act.agent, fills: act.fills.map((field) => field.alias), ...place };
+  }
+  if (act.kind === "workflow") {
+    const inputs = Object.fromEntries(act.inputs.map((input) => [input.name, input.field === null ? RECORD_INPUT : input.field.alias]));
+    return { kind: act.kind, label: act.label, workflow: act.workflow, inputs, ...place };
+  }
+  return { label: act.label, template: act.template.alias, ...place };
 }
 var presetSourceSchema = zod_default.object({
   entities: zod_default.array(contractEntitySchema),
@@ -54944,14 +55701,14 @@ async function resolveOverlay(file2, raw, overlay) {
   note(`${file2} starts from ${read2.name} (${overlay.from}).`);
   return { kind: "ok", model, notes };
 }
-async function knownSlugs(named) {
+async function knownSlugs(named2) {
   let slugs;
   try {
     slugs = (await fetchPresetIndex()).map((row) => row.slug);
   } catch {
     return "";
   }
-  return slugs.includes(named) ? "" : `
+  return slugs.includes(named2) ? "" : `
     The presets there are: ${slugs.join(", ")}.`;
 }
 async function checkModelFile(file2) {
@@ -56073,11 +56830,11 @@ function rpcFailureBody(err) {
   if (!(err instanceof LoticsRequestError)) return { message: message2 };
   const code = err.body.code;
   const raw = err.body.field_errors;
-  const named = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? Object.entries(raw).filter((e) => typeof e[1] === "string") : [];
+  const named2 = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? Object.entries(raw).filter((e) => typeof e[1] === "string") : [];
   return {
     message: message2,
     ...typeof code === "string" ? { code } : {},
-    ...named.length > 0 ? { field_errors: Object.fromEntries(named) } : {}
+    ...named2.length > 0 ? { field_errors: Object.fromEntries(named2) } : {}
   };
 }
 function servesWrapperPage(method, pathname) {
@@ -57870,15 +58627,15 @@ function warnLocalKit(projectDir) {
 function assertKitShippable(projectDir, options) {
   const entries2 = Object.entries(readLocalKit(projectDir));
   if (entries2.length === 0) return;
-  const named = entries2.map(([name, record2]) => describeRecord2(name, record2)).join(", ");
+  const named2 = entries2.map(([name, record2]) => describeRecord2(name, record2)).join(", ");
   if (options.allowLocalKit) {
     warn(
-      `\u26A0 Deploying against a local kit build (${named}) \u2014 the bundle carries it, but the source archive does not, so a clone of this app will not install.`
+      `\u26A0 Deploying against a local kit build (${named2}) \u2014 the bundle carries it, but the source archive does not, so a clone of this app will not install.`
     );
     return;
   }
   fail(
-    `This app is installed against a local kit build (${named}), and ${KIT_DIR}/ is not in the source a deploy uploads.
+    `This app is installed against a local kit build (${named2}), and ${KIT_DIR}/ is not in the source a deploy uploads.
   Publish the kit and run:  lotics app kit <path-to-package> --published
   Or ship it anyway:        lotics app deploy --allow-local-kit`
   );
@@ -59630,8 +60387,8 @@ Ready. Next steps:`);
     console.error(`  lotics app check           # every pre-flight a deploy runs`);
     console.error(`  lotics app deploy`);
   } else {
-    console.error(`  # edit src/screens/*.tsx \u2014 one per plan screen \u2014 then:`);
-    console.error(`  lotics app check --screens # every pre-flight a deploy runs, and the probes over each screen`);
+    console.error(`  # edit app.json \u2014 the screens, their records and their acts \u2014 then:`);
+    console.error(`  lotics app check           # every pre-flight a deploy runs, the spec read against the project`);
     console.error(`  lotics app deploy`);
   }
 }
@@ -60385,6 +61142,7 @@ async function appDeploy(client, args) {
       });
       note(`Deployed v${result.version_number} (${result.version_id})`);
       note(`Bundle size: ${(result.bundle_size_bytes / 1024).toFixed(1)} KB`);
+      if (result.origin !== void 0) note(`Address: ${result.origin}`);
       try {
         const drifted = staleWorkflowGlobals(projectDir, meta3.workflows ?? {});
         for (const { alias, declaration } of drifted) {
@@ -61327,11 +62085,11 @@ async function warnIfQueriesIgnoreRowRules(client, queries) {
   const lines = [];
   const unguarded = /* @__PURE__ */ new Set();
   for (const [alias, scans] of byQuery) {
-    const named = /* @__PURE__ */ new Set();
+    const named2 = /* @__PURE__ */ new Set();
     for (const scan of scans) {
       const name = scoped.get(scan.table_id);
-      if (scan.guarded || name === void 0 || named.has(name)) continue;
-      named.add(name);
+      if (scan.guarded || name === void 0 || named2.has(name)) continue;
+      named2.add(name);
       unguarded.add(alias);
       lines.push(
         `  \u2022 ${alias} over ${name} \u2014 ${name} declares a row rule; this query runs as the app's owner and returns every row. Add the viewer predicate the rule names.`
@@ -62397,7 +63155,16 @@ function candidates(spec) {
             kind: "refused",
             message: `"${act.label}" runs an agent, and the panel a run is reviewed in is the kit's \u2014 started once,
   reviewed before it is applied, cancelled by closing. Only a paper act opens a panel of the app's own.`
-          } : act.component !== void 0 ? already(`"${act.label}"`, act.component) : { kind: "target", target: { kind: "act", at: at2, act } }
+          } : (
+            // A HAND-OFF'S SURFACE IS THE BODY THE AUTHOR WROTE. What a panel
+            // would ask for is an input, and an input is the plan's own clause
+            // — so the answer to "ask first" is the workflow, not a component.
+            act.kind === "workflow" ? {
+              kind: "refused",
+              message: `"${act.label}" hands the row to the "${act.workflow}" workflow, whose body is already yours \u2014 what a
+  panel would ask for is an input, which the act's own \`inputs\` names. Only a paper act opens a panel.`
+            } : act.component !== void 0 ? already(`"${act.label}"`, act.component) : { kind: "target", target: { kind: "act", at: at2, act } }
+          )
         )
       };
     })
@@ -62760,13 +63527,13 @@ var countOf = (outcomes, kind) => outcomes.filter((outcome) => outcome.kind ===
 var list2 = (aliases) => aliases.length === 0 ? "\u2014" : aliases.join(", ");
 function renderSummary(summary, dryRun) {
   const { outcomes, deploy } = summary;
-  const named = (kind) => outcomes.filter((outcome) => outcome.kind === kind).map((outcome) => `    ${outcome.path}${outcome.kind === "kept" ? ` \u2014 ${outcome.why}` : ""}`);
+  const named2 = (kind) => outcomes.filter((outcome) => outcome.kind === kind).map((outcome) => `    ${outcome.path}${outcome.kind === "kept" ? ` \u2014 ${outcome.why}` : ""}`);
   const nothingToDeploy = deploy.added.length === 0 && deploy.changed.length === 0 && deploy.removed.length === 0;
   const lines = [
     dryRun ? "lotics app regenerate --dry-run \u2014 nothing was written." : "lotics app regenerate",
     `  Files: ${countOf(outcomes, "written")} written, ${countOf(outcomes, "kept")} kept, ${countOf(outcomes, "deleted")} deleted`,
     ...["kept", "deleted"].flatMap((kind) => {
-      const rows = named(kind);
+      const rows = named2(kind);
       return rows.length === 0 ? [] : [`  ${kind}:`, ...rows];
     }),
     // A declaration losing an entry is not something to do quietly, and the two
@@ -63167,38 +63934,38 @@ function renameInModel(raw, args) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function resolveTable(client, named) {
+async function resolveTable(client, named2) {
   const res = await client.execute("query_tables", {}, { format: "json" });
   if (res.error) throw new Error(`Could not list this workspace's tables: ${res.error}`);
   const rows = Array.isArray(res.result) ? res.result : [];
   const tables = rows.flatMap(
     (row) => typeof row.table_id === "string" && typeof row.table_name === "string" ? [{ id: row.table_id, name: row.table_name }] : []
   );
-  const byId2 = tables.find((table) => table.id === named);
+  const byId2 = tables.find((table) => table.id === named2);
   if (byId2 !== void 0) return byId2;
-  const byName = tables.filter((table) => table.name === named);
+  const byName = tables.filter((table) => table.name === named2);
   if (byName.length === 1) return byName[0];
   if (byName.length > 1) {
     throw new Error(
-      `"${named}" names ${byName.length} tables here. Name the one you mean by id: ${byName.map((t) => t.id).join(", ")}.`
+      `"${named2}" names ${byName.length} tables here. Name the one you mean by id: ${byName.map((t) => t.id).join(", ")}.`
     );
   }
   throw new Error(
-    `No table here is called "${named}". This workspace has: ${tables.map((t) => t.name).join(", ")}.`
+    `No table here is called "${named2}". This workspace has: ${tables.map((t) => t.name).join(", ")}.`
   );
 }
-function resolveField(table, named) {
-  const byId2 = table.fields.find((field) => field.id === named);
+function resolveField(table, named2) {
+  const byId2 = table.fields.find((field) => field.id === named2);
   if (byId2 !== void 0) return byId2;
-  const byName = table.fields.filter((field) => field.name === named);
+  const byName = table.fields.filter((field) => field.name === named2);
   if (byName.length === 1) return byName[0];
   if (byName.length > 1) {
     throw new Error(
-      `"${named}" names ${byName.length} fields on ${table.name}. Name the one you mean by key: ${byName.map((f) => f.id).join(", ")}.`
+      `"${named2}" names ${byName.length} fields on ${table.name}. Name the one you mean by key: ${byName.map((f) => f.id).join(", ")}.`
     );
   }
   throw new Error(
-    `${table.name} has no field called "${named}". Its fields are: ${table.fields.map((f) => f.name).join(", ")}.`
+    `${table.name} has no field called "${named2}". Its fields are: ${table.fields.map((f) => f.name).join(", ")}.`
   );
 }
 async function readTableSchema(client, tableId) {