@adminiumjs/manifest 0.3.26 → 0.3.28

package/dist/sample.d.ts

@@ -21,6 +21,12 @@
  *   `{"@table": "<table>"}`    that table's stored name, for a column that
  *                               holds one (`rules.tableRef`): the name it has
  *                               on this install, whichever app made the table
+ *   `{"@person": "<key>"}`     one of the manifest's sample people
+ *                               (`sampleData.people`): the staff member made
+ *                               for that key. In a staff column (`rules.staff`)
+ *                               or another text column that holds a staff id,
+ *                               and anywhere inside a json value (a saved
+ *                               filter that names a rep)
  *
  * A `@day` may add `"@workdays": true`: its days count Monday to Friday, and
  * day 0 on a weekend is the Monday after — so "today's" busy day is never a
@@ -61,6 +67,10 @@
  * `"@onlyIfEmpty": true` is for a table that holds one row, the app's own
  * settings: the row is added only when the table has none, and otherwise its
  * `@label` names the row already there — the operator's own settings stay.
+ * With `"@fillEmpty": true` beside it, the row already there takes the
+ * sample's values in the columns it holds nothing in (a depot's name on a
+ * settings row the install wrote with its defaults): never over a value, and
+ * emptied again with the sample where nobody changed them since.
  *
  * AN APP'S ROWS FOR AN ADD-ON. An app that names an add-on may ship a second
  * file of the same format with a top-level `addOn`: rows of that add-on's
@@ -102,6 +112,8 @@ export declare const sampleValueSchema: z.ZodUnion<readonly [z.ZodUnion<readonly
     '@asset': z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     '@table': z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    '@person': z.ZodString;
 }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
 export declare const sampleRowSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodUnion<readonly [z.ZodObject<{
     '@ref': z.ZodString;
@@ -130,6 +142,8 @@ export declare const sampleRowSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readon
     '@asset': z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     '@table': z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    '@person': z.ZodString;
 }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
 /** `@byClock`: a row's columns by where its time falls against the adding moment. */
 export declare const byClockSchema: z.ZodObject<{
@@ -160,6 +174,8 @@ export declare const byClockSchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>]>;
     before: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodUnion<readonly [z.ZodObject<{
         '@ref': z.ZodString;
@@ -188,6 +204,8 @@ export declare const byClockSchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
     around: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodUnion<readonly [z.ZodObject<{
         '@ref': z.ZodString;
@@ -216,6 +234,8 @@ export declare const byClockSchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
     after: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodUnion<readonly [z.ZodObject<{
         '@ref': z.ZodString;
@@ -244,6 +264,8 @@ export declare const byClockSchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
 }, z.core.$strict>;
 export type ByClock = z.infer<typeof byClockSchema>;
@@ -276,6 +298,8 @@ export declare const byStaySchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>]>;
     to: z.ZodUnion<readonly [z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         '@ref': z.ZodString;
@@ -304,6 +328,8 @@ export declare const byStaySchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>]>;
     times: z.ZodOptional<z.ZodObject<{
         from: z.ZodOptional<z.ZodString>;
@@ -336,6 +362,8 @@ export declare const byStaySchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
     during: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodUnion<readonly [z.ZodObject<{
         '@ref': z.ZodString;
@@ -364,6 +392,8 @@ export declare const byStaySchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
     after: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodUnion<readonly [z.ZodObject<{
         '@ref': z.ZodString;
@@ -392,11 +422,15 @@ export declare const byStaySchema: z.ZodObject<{
         '@asset': z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         '@table': z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        '@person': z.ZodString;
     }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
 }, z.core.$strict>;
 export type ByStay = z.infer<typeof byStaySchema>;
 /** The keys of a row that are directives about the row, not columns. */
 export declare const ROW_DIRECTIVES: ReadonlySet<string>;
+/** The most moves one file asks for. */
+export declare const SAMPLE_MOVES_MAX = 50;
 /** The weekdays a bundle's week anchor names. */
 export declare const SAMPLE_WEEKDAYS: readonly ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
 export declare const sampleBundleSchema: z.ZodObject<{
@@ -447,8 +481,15 @@ export declare const sampleBundleSchema: z.ZodObject<{
             '@asset': z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
             '@table': z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            '@person': z.ZodString;
         }, z.core.$strict>]>, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
     }, z.core.$strict>>;
+    moves: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        to: z.ZodString;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type SampleBundle = z.infer<typeof sampleBundleSchema>;
 export type SampleValue = z.infer<typeof sampleValueSchema>;
@@ -489,7 +530,15 @@ export declare function sampleDirective(value: unknown): {
 } | {
     kind: 'table';
     ref: string;
+} | {
+    kind: 'person';
+    key: string;
 } | null;
+/**
+ * Every sample person a value names: itself, or anywhere inside it when it
+ * is a json value (an object or a list that is no directive of its own).
+ */
+export declare function samplePeopleIn(value: unknown): string[];
 /** An ISO-8601 duration in milliseconds. */
 export declare function isoDurationMs(duration: string): number;
 export interface SampleIssue {
@@ -535,6 +584,19 @@ export declare function seedRowIdentity(manifest: Manifest, table: string, row:
  * is written only by actions that count nothing. The receipt table never is.
  */
 export declare function ledgerCatalogueTables(addOn: AddOnManifest): ReadonlySet<string>;
+/**
+ * The tables a ledger writes that an app's file may still bring ROWS WITH NO
+ * HISTORY of: an item with no stock, an order still a draft. A table is one
+ * when a person may make its rows by hand (a role of the add-on is granted
+ * `create` on it), and it is not the receipt table. The row then leaves out
+ * every column the ledger keeps (`ledgerKeptColumns`) that it can be made
+ * without, and names no receipt.
+ * What only the ledger writes (a movement, a level, a reservation) comes only
+ * from the ledger: the file asks for it with `moves`, and the add-on writes it.
+ */
+export declare function ledgerBringableTables(addOn: AddOnManifest): ReadonlySet<string>;
+/** The columns of a table that an add-on's ledgers keep: what a plan may change of a row that is there (`update.set`). */
+export declare function ledgerKeptColumns(addOn: AddOnManifest, ref: string): ReadonlySet<string>;
 /**
  * An app's rows for an add-on it names (`sampleData.addOns.<key>.file`):
  * the file is for this app and that add-on, the app names the add-on, a

package/dist/sample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sample.d.ts","sourceRoot":"","sources":["../src/sample.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sample.d.ts","sourceRoot":"","sources":["../src/sample.ts"],"names":[],"mappings":"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"}

package/dist/sample.js

@@ -22,6 +22,12 @@
  *   `{"@table": "<table>"}`    that table's stored name, for a column that
  *                               holds one (`rules.tableRef`): the name it has
  *                               on this install, whichever app made the table
+ *   `{"@person": "<key>"}`     one of the manifest's sample people
+ *                               (`sampleData.people`): the staff member made
+ *                               for that key. In a staff column (`rules.staff`)
+ *                               or another text column that holds a staff id,
+ *                               and anywhere inside a json value (a saved
+ *                               filter that names a rep)
  *
  * A `@day` may add `"@workdays": true`: its days count Monday to Friday, and
  * day 0 on a weekend is the Monday after — so "today's" busy day is never a
@@ -62,6 +68,10 @@
  * `"@onlyIfEmpty": true` is for a table that holds one row, the app's own
  * settings: the row is added only when the table has none, and otherwise its
  * `@label` names the row already there — the operator's own settings stay.
+ * With `"@fillEmpty": true` beside it, the row already there takes the
+ * sample's values in the columns it holds nothing in (a depot's name on a
+ * settings row the install wrote with its defaults): never over a value, and
+ * emptied again with the sample where nobody changed them since.
  *
  * AN APP'S ROWS FOR AN ADD-ON. An app that names an add-on may ship a second
  * file of the same format with a top-level `addOn`: rows of that add-on's
@@ -112,6 +122,7 @@ const directive = z.union([
     z.object({ '@t': z.record(z.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/), z.string()).refine((m) => Object.keys(m).length > 0) }).strict(),
     z.object({ '@asset': label }).strict(),
     z.object({ '@table': z.string().regex(/^[a-z][a-z0-9_]*$/, 'a table') }).strict(),
+    z.object({ '@person': z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/, 'a sample person\'s key') }).strict(),
 ]);
 const plain = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 /** A column's value: a plain value, a directive, or (for a json column) any object or array. */
@@ -144,7 +155,9 @@ export const byStaySchema = z
 })
     .strict();
 /** The keys of a row that are directives about the row, not columns. */
-export const ROW_DIRECTIVES = new Set(['@label', '@byClock', '@byStay', '@onlyIfEmpty']);
+export const ROW_DIRECTIVES = new Set(['@label', '@byClock', '@byStay', '@onlyIfEmpty', '@fillEmpty']);
+/** The most moves one file asks for. */
+export const SAMPLE_MOVES_MAX = 50;
 /** The weekdays a bundle's week anchor names. */
 export const SAMPLE_WEEKDAYS = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
 export const sampleBundleSchema = z
@@ -170,6 +183,19 @@ export const sampleBundleSchema = z
     })
         .strict())
         .min(1),
+    /**
+     * In an app's rows for an add-on: changes of state made once the rows are in, each as a save of its own, in
+     * this order. Such a save is a real one, so what the add-on's ledger hands to a move (a receipt posted: stock
+     * in) is written by the add-on itself. One row by its label (`ref`), or every row this file wrote of a table.
+     */
+    moves: z
+        .array(z
+        .object({ ref: label.optional(), table: z.string().min(1).optional(), to: z.string().min(1).max(80) })
+        .strict()
+        .refine((move) => (move.ref === undefined) !== (move.table === undefined), { message: 'a move names one row (`ref`) or one table (`table`), not both' }))
+        .min(1)
+        .max(SAMPLE_MOVES_MAX)
+        .optional(),
 })
     .strict();
 /** A value's directive, when it is one. */
@@ -204,8 +230,24 @@ export function sampleDirective(value) {
         return { kind: 'asset', label: record['@asset'] };
     if (typeof record['@table'] === 'string')
         return { kind: 'table', ref: record['@table'] };
+    if (typeof record['@person'] === 'string')
+        return { kind: 'person', key: record['@person'] };
     return null;
 }
+/**
+ * Every sample person a value names: itself, or anywhere inside it when it
+ * is a json value (an object or a list that is no directive of its own).
+ */
+export function samplePeopleIn(value) {
+    const found = sampleDirective(value);
+    if (found !== null)
+        return found.kind === 'person' ? [found.key] : [];
+    if (Array.isArray(value))
+        return value.flatMap(samplePeopleIn);
+    if (typeof value === 'object' && value !== null)
+        return Object.values(value).flatMap(samplePeopleIn);
+    return [];
+}
 /** An ISO-8601 duration in milliseconds. */
 export function isoDurationMs(duration) {
     const match = ISO_DURATION.exec(duration);
@@ -257,8 +299,11 @@ export function sampleBundleIssues(bundle, manifest) {
         if (table.own === true)
             issues.push({ path: `tables.${String(t)}.own`, message: '"own" marks a table of the app in its rows for an add-on; a manifest\'s own sample file takes none.' });
     });
+    if (bundle.moves !== undefined)
+        issues.push({ path: 'moves', message: '"moves" are for an app\'s rows for an add-on (sampleData.addOns); a manifest\'s own sample file writes its rows as they should stand.' });
     const declared = new Map((manifest.requiredSchema?.tables ?? []).map((table) => [table.ref, table]));
-    issues.push(...rowIssues(bundle, declared, { names: new Set(declared.keys()), what: manifest.kind === 'add-on' ? 'add-on' : 'app', otherLabels: false, known: seedLabelsOf(manifest) }));
+    const people = new Set(((manifest.kind === 'app' ? manifest.sampleData?.people : undefined) ?? []).map((person) => person.key));
+    issues.push(...rowIssues(bundle, declared, { names: new Set(declared.keys()), what: manifest.kind === 'add-on' ? 'add-on' : 'app', otherLabels: false, known: seedLabelsOf(manifest), people }));
     issues.push(...ledgerOrderIssues(bundle, manifest, declared));
     return issues;
 }
@@ -403,6 +448,42 @@ export function ledgerCatalogueTables(addOn) {
         verdicts.set(ledger.receipts, false);
     return new Set([...verdicts].filter(([, catalogue]) => catalogue).map(([ref]) => ref));
 }
+/**
+ * The tables a ledger writes that an app's file may still bring ROWS WITH NO
+ * HISTORY of: an item with no stock, an order still a draft. A table is one
+ * when a person may make its rows by hand (a role of the add-on is granted
+ * `create` on it), and it is not the receipt table. The row then leaves out
+ * every column the ledger keeps (`ledgerKeptColumns`) that it can be made
+ * without, and names no receipt.
+ * What only the ledger writes (a movement, a level, a reservation) comes only
+ * from the ledger: the file asks for it with `moves`, and the add-on writes it.
+ */
+export function ledgerBringableTables(addOn) {
+    const byHand = new Set();
+    for (const role of addOn.roles ?? []) {
+        for (const permission of role.permissions ?? []) {
+            const [kind, table, action] = permission.split(':');
+            if (kind === 'table' && action === 'create' && table !== undefined)
+                byHand.add(table.replace(/^@/, ''));
+        }
+    }
+    const out = new Set();
+    for (const ledger of ledgersOf(addOn))
+        for (const ref of Object.keys(ledger.writes))
+            if (byHand.has(ref))
+                out.add(ref);
+    for (const ledger of ledgersOf(addOn))
+        out.delete(ledger.receipts);
+    return out;
+}
+/** The columns of a table that an add-on's ledgers keep: what a plan may change of a row that is there (`update.set`). */
+export function ledgerKeptColumns(addOn, ref) {
+    const out = new Set();
+    for (const ledger of ledgersOf(addOn))
+        for (const column of ledger.writes[ref]?.update?.set ?? [])
+            out.add(column);
+    return out;
+}
 /**
  * An app's rows for an add-on it names (`sampleData.addOns.<key>.file`):
  * the file is for this app and that add-on, the app names the add-on, a
@@ -429,6 +510,7 @@ export function sampleSectionIssues(bundle, app, addOn) {
     const theirs = addOn === undefined ? null : new Map((addOn.requiredSchema?.tables ?? []).map((table) => [table.ref, table]));
     const declared = new Map();
     const catalogue = addOn === undefined ? new Set() : ledgerCatalogueTables(addOn);
+    const bringable = addOn === undefined ? new Set() : ledgerBringableTables(addOn);
     const receipts = new Set(addOn === undefined ? [] : ledgersOf(addOn).map((ledger) => ledger.receipts));
     bundle.tables.forEach((table, t) => {
         const at = `tables.${String(t)}`;
@@ -450,7 +532,7 @@ export function sampleSectionIssues(bundle, app, addOn) {
         const shape = theirs.get(table.ref);
         // An add-on's history is its own to write: an app brings what a ledger counts, never what it counted.
         // What a ledger writes beside its books (which item a dish uses) is no history, and an app may bring it.
-        const ledger = addOn === undefined || catalogue.has(table.ref) ? undefined : ledgersOf(addOn).find((candidate) => candidate.receipts === table.ref || candidate.writes[table.ref] !== undefined);
+        const ledger = addOn === undefined || catalogue.has(table.ref) || bringable.has(table.ref) ? undefined : ledgersOf(addOn).find((candidate) => candidate.receipts === table.ref || candidate.writes[table.ref] !== undefined);
         if (shape === undefined)
             issues.push({ path: `${at}.ref`, message: `"${table.ref}" is not a table of "${key}". A table of the app itself is marked "own": true.` });
         else if (ledger !== undefined)
@@ -466,8 +548,21 @@ export function sampleSectionIssues(bundle, app, addOn) {
                         issues.push({ path: `${at}.rows.${String(r)}.${column.ref}`, message: `"${table.ref}.${column.ref}" names the receipt of a posting: an app's rows for an add-on are made by no posting, so leave it out.` });
                 });
             }
+            // A row with no history: what the ledger keeps of it (an average cost, a status it moves) is the ledger's to write.
+            // But for a column a row cannot be made without (an order line's quantity, which a receipt later adjusts): that one a person types.
+            const needed = new Set(shape.columns.filter((column) => column.nullable !== true && column.default === undefined).map((column) => column.ref));
+            const kept = addOn === undefined || catalogue.has(table.ref) ? new Set() : new Set([...ledgerKeptColumns(addOn, table.ref)].filter((column) => !needed.has(column)));
+            if (kept.size > 0) {
+                table.rows.forEach((row, r) => {
+                    for (const column of kept) {
+                        if (row[column] !== undefined)
+                            issues.push({ path: `${at}.rows.${String(r)}.${column}`, message: `"${table.ref}.${column}" is kept by "${key}"'s ledger: an app's row brings no history, so leave it out (a move asks the add-on to write it).` });
+                    }
+                });
+            }
         }
     });
+    issues.push(...sampleMoveIssues(bundle, theirs));
     const twice = bundle.tables.map((table) => table.ref).filter((ref, i, all) => all.indexOf(ref) !== i);
     for (const ref of new Set(twice))
         issues.push({ path: 'tables', message: `"${ref}" is listed twice.` });
@@ -475,6 +570,51 @@ export function sampleSectionIssues(bundle, app, addOn) {
     issues.push(...rowIssues(bundle, declared, { names: new Set(own.keys()), what: 'app', otherLabels: true }));
     return issues;
 }
+/**
+ * A section's `moves`: each names a labelled row, or a table, of the add-on's
+ * that this file itself writes, and a state that table has. Whether the move
+ * is one the table allows from where the row stands is judged when it is
+ * made, as for anybody's save.
+ */
+function sampleMoveIssues(bundle, theirs) {
+    const issues = [];
+    const tableOfLabel = new Map();
+    const written = new Map();
+    for (const table of bundle.tables) {
+        written.set(table.ref, table.own === true);
+        for (const row of table.rows)
+            if (typeof row['@label'] === 'string')
+                tableOfLabel.set(row['@label'], table.ref);
+    }
+    (bundle.moves ?? []).forEach((move, m) => {
+        const at = `moves.${String(m)}`;
+        const ref = move.table ?? (move.ref === undefined ? undefined : tableOfLabel.get(move.ref));
+        if (ref === undefined) {
+            issues.push({ path: `${at}.ref`, message: `No row of this file carries the label "${String(move.ref)}".` });
+            return;
+        }
+        if (!written.has(ref)) {
+            issues.push({ path: `${at}.table`, message: `This file writes no row of "${ref}": a move is of a row the file itself brings.` });
+            return;
+        }
+        if (written.get(ref) === true) {
+            issues.push({ path: at, message: `"${ref}" is the app's own table: a move is of a row of the add-on's, whose ledger then writes what follows.` });
+            return;
+        }
+        const shape = theirs?.get(ref);
+        if (shape === undefined)
+            return; // checked when the add-on's manifest is at hand
+        const states = shape.states;
+        if (states === undefined) {
+            issues.push({ path: at, message: `"${ref}" has no states, so its rows make no move.` });
+            return;
+        }
+        const values = shape.columns.find((column) => column.ref === states.column)?.enum ?? [];
+        if (!values.includes(move.to))
+            issues.push({ path: `${at}.to`, message: `"${ref}" has no state "${move.to}".` });
+    });
+    return issues;
+}
 /**
  * The checks every row of a file gets, over the tables `declared` knows. A
  * table it does not know is skipped: the caller has said why, or cannot see it.
@@ -511,9 +651,44 @@ function rowIssues(bundle, declared, opts) {
             }
         }
         // A number Adminium gives without gaps: a sample row names it, empty, or the load numbers it into the real series.
-        const gapless = shape.columns.filter((column) => column.rules?.sequence?.gapless === true).map((column) => column.ref);
+        // One the app opened to its sample (`sequence.sample`) may instead be given its number: checked below, with the text written from it.
+        const gapless = shape.columns.filter((column) => column.rules?.sequence?.gapless === true && column.rules.sequence.sample !== true).map((column) => column.ref);
+        const numberedBySample = shape.columns.filter((column) => column.rules?.sequence?.gapless === true && column.rules.sequence.sample === true);
+        const taken = new Map();
         for (const [r, row] of table.rows.entries()) {
             const at = `tables.${String(t)}.rows.${String(r)}`;
+            for (const numbered of numberedBySample) {
+                const column = numbered.ref;
+                const given = row[column];
+                if (given === null)
+                    continue;
+                if (typeof given !== 'number' || !Number.isInteger(given) || given < 1) {
+                    const now = given === undefined ? 'this row leaves it out' : 'this row gives it something else';
+                    issues.push({ path: `${at}.${column}`, message: `"${column}" is a running number, and ${now}. Write the row's number (1, 2, 3 …), or "${column}": null to give it none.` });
+                    continue;
+                }
+                // One series per parent row when the number is scoped: the same number under two parents is two numbers.
+                const scope = numbered.rules?.sequence?.scope;
+                const key = `${column}\u0000${scope === undefined ? '' : JSON.stringify(row[scope] ?? null)}\u0000${String(given)}`;
+                const before = taken.get(key);
+                if (before !== undefined)
+                    issues.push({ path: `${at}.${column}`, message: `"${column}" ${String(given)} is row ${String(before)}'s number already.` });
+                else
+                    taken.set(key, r);
+                // The text people read is written with it: nothing writes it for a sample row.
+                const text = shape.columns.find((other) => other.rules?.format?.from === column);
+                const format = text?.rules?.format;
+                if (text === undefined || format === undefined)
+                    continue;
+                const written = row[text.ref];
+                const want = format.prefixSetting === undefined ? `${format.prefix ?? ''}${String(given).padStart(format.pad ?? 0, '0')}` : null;
+                if (typeof written !== 'string' || written === '') {
+                    issues.push({ path: `${at}.${text.ref}`, message: `"${text.ref}" is the number as people read it${want === null ? '' : ` ("${want}")`}: a sample row that gives "${column}" writes it too.` });
+                }
+                else if (want !== null && written !== want) {
+                    issues.push({ path: `${at}.${text.ref}`, message: `"${text.ref}" is written from "${column}": for ${String(given)} it reads "${want}", not "${written}".` });
+                }
+            }
             for (const column of gapless) {
                 if (row[column] !== null) {
                     // Said as what to write: a model given only the reason left the key out, eight times running.
@@ -541,6 +716,13 @@ function rowIssues(bundle, declared, opts) {
                         issues.push({ path: `${at}.@onlyIfEmpty`, message: `"${table.ref}" is only for an empty table as a whole; a row of it says nothing more.` });
                     continue;
                 }
+                if (column === '@fillEmpty') {
+                    if (value !== true)
+                        issues.push({ path: `${at}.@fillEmpty`, message: '"@fillEmpty" is true, or absent.' });
+                    else if (row['@onlyIfEmpty'] !== true)
+                        issues.push({ path: `${at}.@fillEmpty`, message: '"@fillEmpty" goes with "@onlyIfEmpty": it says what to do with the row the table already holds.' });
+                    continue;
+                }
                 if (column === '@byStay') {
                     if (row['@byClock'] !== undefined)
                         issues.push({ path: `${at}.@byStay`, message: 'A row takes @byClock or @byStay, not both.' });
@@ -609,6 +791,11 @@ function rowIssues(bundle, declared, opts) {
                     issues.push({ path: `${at}.${column}`, message: `"${table.ref}" has no column "${column}".` });
                     continue;
                 }
+                // A file is uploaded by a signed-in person: no sample row brings one.
+                if (value !== null && !(Array.isArray(value) && value.length === 0) && shape.columns.find((c) => c.ref === column)?.rules?.file !== undefined) {
+                    issues.push({ path: `${at}.${column}`, message: `"${table.ref}.${column}" holds files a signed-in person uploads, so a sample row leaves it empty.` });
+                    continue;
+                }
                 // An object that looks like a directive must BE one: a malformed
                 // `@ago` would otherwise be written into the column as JSON.
                 if (typeof value === 'object' &&
@@ -620,6 +807,18 @@ function rowIssues(bundle, declared, opts) {
                     continue;
                 }
                 const found = sampleDirective(value);
+                // A sample person: one the manifest lists, in a column that can hold a staff member's id.
+                for (const key of samplePeopleIn(value)) {
+                    if (opts.people === undefined)
+                        issues.push({ path: `${at}.${column}`, message: 'A sample person is named in the app\'s own sample file, not in its rows for an add-on.' });
+                    else if (!opts.people.has(key))
+                        issues.push({ path: `${at}.${column}`, message: `"${key}" is not one of the manifest's sample people (sampleData.people).` });
+                }
+                if (found?.kind === 'person') {
+                    const holds = shape.columns.find((c) => c.ref === column);
+                    if (holds?.type !== 'text')
+                        issues.push({ path: `${at}.${column}`, message: `"${table.ref}.${column}" is not a text column, so it cannot hold a staff member.` });
+                }
                 if (found?.kind === 'table') {
                     const holds = shape.columns.find((c) => c.ref === column);
                     if (!opts.names.has(found.ref))