@trypattern/sdk 0.1.24 → 0.1.26

package/dist/app.d.ts

@@ -10,6 +10,7 @@ import type { Clock } from './clock.ts';
 import type { Gate } from './gate.ts';
 import { ActionsStore } from './actions.ts';
 import type { Action, ActionsBuilder } from './actions.ts';
+import { Device } from './builtins/Device.ts';
 import { Toasts } from './builtins/Toasts.ts';
 import { PageStore } from './page.ts';
 import type { BuiltInModels } from './registered.ts';
@@ -83,6 +84,7 @@ export type StoresOf<Group extends Tables, Custom, Item extends Action = Action>
     app: AppStore;
     actions: ActionsStore<Item>;
     toasts: Toasts;
+    device: Device;
     page: PageStore;
 } & TableStores<Group> & PublicStores<Group> & BlockStores<Group> & Custom;
 type BlockTablesMissing<Name extends string> = StaticTypeError<`The ${Name} block keeps its rows in Pattern's own tables: add them to tables in schema.ts (for bookings, ...bookingTables from '@trypattern/sdk/schema'), then run app migration add_${Name}`>;

package/dist/app.js

@@ -10,6 +10,7 @@ import { AppSettings } from "./builtins/AppSettings.js";
 import { BUILT_IN_GROUPS, builtInActions } from "./builtins/actions.js";
 import { Palette } from "./builtins/Palette.js";
 import { SignIn } from "./builtins/SignIn.js";
+import { Device } from "./builtins/Device.js";
 import { Toasts } from "./builtins/Toasts.js";
 import { PageStore } from "./page.js";
 import { assertNotBuilding, snapshotsOf } from "./store.js";
@@ -126,15 +127,16 @@ export function defineApp(definition) {
                 new block.Store(cache.persisted(`stores.${block.name}`), api.services)
             ]));
             const toasts = new Toasts(cache.persisted('stores.toasts'), {});
+            const device = new Device(cache.persisted('stores.device'), {});
             const clash = clashOf([
-                ['session', 'app', 'actions', 'toasts', 'page'],
+                ['session', 'app', 'actions', 'toasts', 'device', 'page'],
                 Object.keys(data.tables),
                 Object.keys(data.publicViews),
                 Object.keys(blockStores),
                 Object.keys(custom)
             ]);
             if (clash !== undefined) {
-                throw new Error(`Two stores are called "${clash}". The built-in session, app, actions, toasts and page stores, each table, each table's public view, each block and each store in src/stores/index.ts need their own name.`);
+                throw new Error(`Two stores are called "${clash}". The built-in session, app, actions, toasts, device and page stores, each table, each table's public view, each block and each store in src/stores/index.ts need their own name.`);
             }
             const actions = new ActionsStore(this.#page, [...(definition.actions ?? []), ...builtInActions], [
                 ...(definition.actionGroups ?? []),
@@ -145,6 +147,7 @@ export function defineApp(definition) {
                 app,
                 actions,
                 toasts,
+                device,
                 page: this.#page,
                 ...data.tables,
                 ...data.publicViews,

package/dist/builtins/Device.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import type { Persisted } from '../state.ts';
+declare const Device_base: import("../store.ts").StoreClass<{
+    today: z.ZodDefault<z.ZodString>;
+    isCompact: z.ZodDefault<z.ZodBoolean>;
+}, [], Record<never, never>>;
+export declare class Device extends Device_base {
+    #private;
+    constructor(persisted: Persisted, services: Record<never, never>);
+    protected initialState(): {
+        today: string;
+        isCompact: boolean;
+    };
+}
+export {};

package/dist/builtins/Device.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { defineStore } from "../store.js";
+const Store = defineStore();
+const COMPACT = '(max-width: 767px)';
+function dayOf(at) {
+    const month = String(at.getMonth() + 1).padStart(2, '0');
+    const day = String(at.getDate()).padStart(2, '0');
+    return `${at.getFullYear()}-${month}-${day}`;
+}
+function msUntilTomorrow(at) {
+    const tomorrow = new Date(at);
+    tomorrow.setHours(24, 0, 1, 0);
+    return tomorrow.getTime() - at.getTime();
+}
+function compactQuery() {
+    return typeof window === 'undefined' || !('matchMedia' in window)
+        ? undefined
+        : window.matchMedia(COMPACT);
+}
+export class Device extends Store({
+    state: {
+        today: z.string().default(''),
+        isCompact: z.boolean().default(false)
+    }
+}) {
+    #midnight;
+    constructor(persisted, services) {
+        super(persisted, services);
+        const query = compactQuery();
+        if (query === undefined)
+            return;
+        query.addEventListener('change', () => this.set({ isCompact: query.matches }));
+        const refresh = () => this.#refreshToday();
+        window.addEventListener('focus', refresh);
+        document.addEventListener('visibilitychange', refresh);
+        this.#waitForMidnight();
+    }
+    initialState() {
+        return {
+            today: dayOf(new Date()),
+            isCompact: compactQuery()?.matches ?? false
+        };
+    }
+    #refreshToday() {
+        this.set({ today: dayOf(new Date()) });
+        this.#waitForMidnight();
+    }
+    #waitForMidnight() {
+        clearTimeout(this.#midnight);
+        this.#midnight = setTimeout(() => this.#refreshToday(), msUntilTomorrow(new Date()));
+    }
+}

package/dist/cli/app.js

@@ -217,9 +217,9 @@ changing seed.ts or starter/. Works while the dev server runs; reload the page t
 Compares the tables in schema.ts (plus Pattern's users, sessions and settings tables) with server/migrations and writes the
 SQL that moves the database from one to the other, named <number>_<name>.sql. app start applies new
 migrations to the local database. Prints "No schema changes" when the migrations already match.
-A new required column starts as empty, 0 or false on rows that already exist (the live site has rows),
-and a column made required fills its empty rows the same way; each is noted. To start them on a
-real value, add an UPDATE after it in the migration file.`,
+Rows that already exist (the live site has rows) need a value for a new required column, or for a
+column that becomes required: give it one in schema.ts with defaults: { colour: 'white' } on the
+table, or make it .nullable(). Without one this writes nothing and says which columns need it.`,
         run: migration,
         takesArgument: true
     },
@@ -1299,38 +1299,66 @@ async function migration(name) {
         '--name',
         name
     ]);
-    const notes = code === 0 ? startNewColumns(name) : [];
+    const unstarted = code === 0 ? startNewColumns(name) : [];
+    if (unstarted.length > 0) {
+        const named = unstarted.map(({ table, column }) => `${camelCase(table)}.${camelCase(column)}`);
+        const example = camelCase(unstarted[0]?.column ?? '');
+        return {
+            code: 1,
+            data: { error: 'no starting value', columns: named },
+            text: `✗ app migration ${name}: ${named.join(', ')} ${named.length === 1 ? 'is' : 'are'} required, and rows that already exist (the live site has rows) need a value. Nothing was written.\n  next  say what existing rows start with in schema.ts, on that table: defaults: { ${example}: … }, or make the column .nullable(). Then run app migration ${name} again.`
+        };
+    }
     const warning = code === 0 ? ownerBackfillWarning(name) : undefined;
     return {
         code,
-        data: {
-            output: output.trimEnd(),
-            startingValues: notes,
-            ...(warning && { warning })
-        },
-        text: `${code === 0 ? '✓' : '✗'} app migration ${name}\n\n${indent(output.trimEnd())}${notes.map((note) => `\n  note  ${note}`).join('')}${warning === undefined ? '' : `\n\n! ${warning}`}`
+        data: { output: output.trimEnd(), ...(warning && { warning }) },
+        text: `${code === 0 ? '✓' : '✗'} app migration ${name}\n\n${indent(output.trimEnd())}${warning === undefined ? '' : `\n\n! ${warning}`}`
     };
 }
-function newestMigration(name) {
-    return readdirSync(MIGRATIONS_DIR)
-        .filter((entry) => entry.endsWith(`_${name}.sql`))
-        .sort()
-        .at(-1);
+function camelCase(name) {
+    return name.replaceAll(/_([a-z0-9])/g, (_match, letter) => letter.toUpperCase());
 }
-function previousTables(file) {
+function journalEntries() {
     const journal = join(MIGRATIONS_DIR, 'meta', '_journal.json');
     if (!existsSync(journal))
-        return {};
+        return undefined;
+    const raw = JSON.parse(readText(journal));
     const entries = z
         .object({
         entries: z.array(z.object({ idx: z.number(), tag: z.string() }))
     })
-        .parse(JSON.parse(readText(journal))).entries;
+        .parse(raw).entries;
+    return { journal, raw, entries };
+}
+function snapshotPath(idx) {
+    return join(MIGRATIONS_DIR, 'meta', `${String(idx).padStart(4, '0')}_snapshot.json`);
+}
+function forgetMigration(file) {
+    rmSync(join(MIGRATIONS_DIR, file), { force: true });
+    const found = journalEntries();
+    const entry = found?.entries.find((item) => `${item.tag}.sql` === file);
+    if (found === undefined || entry === undefined)
+        return;
+    rmSync(snapshotPath(entry.idx), { force: true });
+    writeFileSync(found.journal, `${JSON.stringify({
+        ...Object(found.raw),
+        entries: Reflect.get(Object(found.raw), 'entries').filter((item) => Reflect.get(Object(item), 'tag') !== entry.tag)
+    }, null, 2)}\n`);
+}
+function newestMigration(name) {
+    return readdirSync(MIGRATIONS_DIR)
+        .filter((entry) => entry.endsWith(`_${name}.sql`))
+        .sort()
+        .at(-1);
+}
+function previousTables(file) {
+    const entries = journalEntries()?.entries ?? [];
     const at = entries.findIndex((entry) => `${entry.tag}.sql` === file);
     const before = at > 0 ? entries[at - 1] : undefined;
     if (before === undefined)
         return {};
-    const snapshot = join(MIGRATIONS_DIR, 'meta', `${String(before.idx).padStart(4, '0')}_snapshot.json`);
+    const snapshot = snapshotPath(before.idx);
     if (!existsSync(snapshot))
         return {};
     return z
@@ -1350,9 +1378,12 @@ function startNewColumns(name) {
         table,
         columns
     ]));
-    const { sql, notes } = withStartingValues(readText(path), tables);
-    writeFileSync(path, sql);
-    return notes.map((note) => `${file}: ${note}`);
+    const { sql, unstarted } = withStartingValues(readText(path), tables);
+    if (unstarted.length > 0)
+        forgetMigration(file);
+    else
+        writeFileSync(path, sql);
+    return unstarted;
 }
 function ownerBackfillWarning(name) {
     const file = newestMigration(name);

package/dist/cli/startingValues.d.ts

@@ -2,8 +2,12 @@ type Columns = Readonly<Record<string, {
     notNull: boolean;
 }>>;
 export type PreviousTables = Readonly<Record<string, Columns>>;
+export type Unstarted = {
+    table: string;
+    column: string;
+};
 export declare function withStartingValues(sql: string, previous: PreviousTables): {
     sql: string;
-    notes: string[];
+    unstarted: Unstarted[];
 };
 export {};

package/dist/cli/startingValues.js

@@ -1,58 +1,48 @@
-const ADDED = /^ALTER TABLE `(\w+)` ADD `(\w+)` (text|integer|real) NOT NULL;/gm;
+const ADDED = /^ALTER TABLE `(\w+)` ADD `(\w+)` (?:text|integer|real) NOT NULL;/gm;
 const REBUILT = /CREATE TABLE `__new_(\w+)` \(([^;]*?)\n\);(\n(?:--> statement-breakpoint\n)?\n?)INSERT INTO `__new_\1`\(([^)]*)\) SELECT ([^;]*) FROM `\1`;/g;
-const REQUIRED = /^(\s*`(\w+)` (text|integer|real)) NOT NULL(,?)$/;
-const STARTING_VALUES = {
-    text: "''",
-    integer: '0',
-    real: '0'
-};
-const SPOKEN = {
-    text: 'empty',
-    integer: '0 (or "no")',
-    real: '0'
-};
+const COLUMN = /^\s*`(\w+)` (?:text|integer|real)(.*)$/;
+const STARTS_AS = / DEFAULT ('(?:[^']|'')*'|[-\w.]+)/;
 function quoted(names) {
     return names.split(',').map((name) => name.trim().replaceAll('"', ''));
 }
+function startsOf(body) {
+    const starts = new Map();
+    for (const line of body.split('\n')) {
+        const match = COLUMN.exec(line);
+        const rest = match?.[2] ?? '';
+        if (match?.[1] === undefined || !rest.includes('NOT NULL'))
+            continue;
+        if (rest.includes('PRIMARY KEY'))
+            continue;
+        starts.set(match[1], STARTS_AS.exec(rest)?.[1] ?? null);
+    }
+    return starts;
+}
 export function withStartingValues(sql, previous) {
-    const started = [];
-    const added = sql.replaceAll(ADDED, (_line, table, column, type) => {
-        started.push({ table, column, type });
-        return `ALTER TABLE \`${table}\` ADD \`${column}\` ${type} NOT NULL DEFAULT ${STARTING_VALUES[type] ?? "''"};`;
-    });
-    const rebuilt = added.replaceAll(REBUILT, (whole, table, body, between, into, from) => {
+    const unstarted = [
+        ...Array.from(sql.matchAll(ADDED), ([, table = '', column = '']) => ({
+            table,
+            column
+        }))
+    ];
+    const rebuilt = sql.replaceAll(REBUILT, (whole, table, body, between, into, from) => {
         const old = previous[table];
         if (old === undefined)
             return whole;
-        const types = new Map();
-        const lines = body.split('\n').map((line) => {
-            const match = REQUIRED.exec(line);
-            if (match === null || line.includes('PRIMARY KEY'))
-                return line;
-            const [, start = '', column = '', type = '', comma = ''] = match;
-            types.set(column, type);
-            return `${start} NOT NULL DEFAULT ${STARTING_VALUES[type] ?? "''"}${comma}`;
-        });
+        const starts = startsOf(body);
         const selected = quoted(from).map((column) => {
-            const type = types.get(column);
             const before = old[column];
-            if (type === undefined)
+            if (!starts.has(column) || before?.notNull === true) {
                 return `"${column}"`;
-            const value = STARTING_VALUES[type] ?? "''";
-            if (before === undefined) {
-                started.push({ table, column, type });
-                return value;
             }
-            if (!before.notNull) {
-                started.push({ table, column, type });
-                return `coalesce("${column}", ${value})`;
+            const start = starts.get(column) ?? null;
+            if (start === null) {
+                unstarted.push({ table, column });
+                return `"${column}"`;
             }
-            return `"${column}"`;
+            return before === undefined ? start : `coalesce("${column}", ${start})`;
         });
-        return `CREATE TABLE \`__new_${table}\` (${lines.join('\n')}\n);${between}INSERT INTO \`__new_${table}\`(${into}) SELECT ${selected.join(', ')} FROM \`${table}\`;`;
+        return `CREATE TABLE \`__new_${table}\` (${body}\n);${between}INSERT INTO \`__new_${table}\`(${into}) SELECT ${selected.join(', ')} FROM \`${table}\`;`;
     });
-    return {
-        sql: rebuilt,
-        notes: started.map(({ table, column, type }) => `${table}.${column} starts as ${SPOKEN[type] ?? 'empty'} on rows that already exist. To start them on a real value, add UPDATE \`${table}\` SET \`${column}\` = … after it in the migration.`)
-    };
+    return { sql: rebuilt, unstarted };
 }

package/dist/registered.d.ts

@@ -2,6 +2,7 @@ import type { AppSnapshotShape, ModelServicesOf, NavigateCommand, PressKeyComman
 import { z } from 'zod';
 import type { Action, DefineActions } from './actions.ts';
 import type { ServiceClient, Services } from './services.ts';
+import type { StoreFactory } from './store.ts';
 import type { Instances, MessagesOf, ModelClassLike, ModelSnapshots } from './model.ts';
 import type { BUILT_IN_GROUPS } from './builtins/actions.ts';
 import type { Account } from './builtins/Account.ts';
@@ -48,7 +49,7 @@ export type ActionContext = {
 };
 export type ModelServices = ModelServicesOf<AppPath>;
 export declare const Model: <S extends import("./state.ts").StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config?: import("./model.ts").ModelConfig<S, P>) => import("./model.ts").ModelClass<AppStores, ModelServices, S, P>;
-export declare const Store: <S extends import("./state.ts").StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config: import("./store.ts").StoreConfig<S, P>) => import("./store.ts").StoreClass<S, P, ServiceClient<Empty>>;
+export declare const Store: StoreFactory<AppServices>;
 export declare const defineActions: DefineActions<ActionContext, RegisteredAction, AppCommand>;
 export declare const appPath: z.ZodCustom<AppPath, AppPath>;
 type ActionInput = Pick<AppAction, 'id' | 'label' | 'group' | 'icon'> & Partial<Pick<AppAction, 'keys' | 'keywords' | 'isDanger' | 'isSearchOnly' | 'isHidden'>> & {

package/dist/rules/checkAllFiles.js

@@ -378,14 +378,6 @@ function misplacedSourceFiles() {
     return ownedFiles(SRC_DIRECTORY).filter((path) => !isWhereItBelongs(relative(SRC_DIRECTORY, path)) || !isInItsFolder(path));
 }
 const SCHEMA_FILE = join(ROOT, 'schema.ts');
-function rowTypeName(table) {
-    const one = table.endsWith('ies')
-        ? `${table.slice(0, -3)}y`
-        : table.endsWith('s')
-            ? table.slice(0, -1)
-            : table;
-    return `${one.charAt(0).toUpperCase()}${one.slice(1)}`;
-}
 function isExported(node) {
     return (ts.canHaveModifiers(node) &&
         (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
@@ -403,8 +395,6 @@ function schemaFindings() {
         return [];
     const text = readFileSync(SCHEMA_FILE, 'utf8');
     const source = ts.createSourceFile(SCHEMA_FILE, text, ts.ScriptTarget.Latest, true);
-    const tables = [];
-    const rowTypes = new Set();
     let exportsTables = false;
     let exportsAdmins = false;
     const visit = (node) => {
@@ -422,29 +412,6 @@ function schemaFindings() {
                 definesTables(declaration.initializer, source))) {
             exportsTables = true;
         }
-        if (ts.isCallExpression(node) &&
-            node.expression.getText(source) === 'defineTables') {
-            const [definitions] = node.arguments;
-            if (definitions !== undefined &&
-                ts.isObjectLiteralExpression(definitions)) {
-                for (const property of definitions.properties) {
-                    const name = property.name;
-                    if (name !== undefined &&
-                        (ts.isIdentifier(name) || ts.isStringLiteral(name))) {
-                        tables.push({ key: name.text, offset: property.getStart(source) });
-                    }
-                }
-            }
-        }
-        if (ts.isTypeAliasDeclaration(node) &&
-            isExported(node) &&
-            ts.isTypeReferenceNode(node.type) &&
-            node.type.typeName.getText(source) === 'Row') {
-            const [argument] = node.type.typeArguments ?? [];
-            if (argument !== undefined && ts.isTypeQueryNode(argument)) {
-                rowTypes.add(argument.exprName.getText(source));
-            }
-        }
         ts.forEachChild(node, visit);
     };
     visit(source);
@@ -456,18 +423,9 @@ function schemaFindings() {
             }
         ];
     }
-    const missingAdmins = exportsAdmins
+    return exportsAdmins
         ? []
         : [{ offset: 0, fix: 'export const admins: string[] = []' }];
-    return [
-        ...missingAdmins,
-        ...tables
-            .filter(({ key }) => !rowTypes.has(`tables.${key}`))
-            .map(({ key, offset }) => ({
-            offset,
-            fix: `export type ${rowTypeName(key)} = Row<typeof tables.${key}>`
-        }))
-    ];
 }
 const ACCESS_FLOWS_FILE = join(ROOT, 'flows', 'Access.flow.ts');
 function toasterPlacements() {

package/dist/rules/messages.d.ts

@@ -22,7 +22,7 @@ export declare const DEV_ONLY_SIGN_IN_MESSAGE = "The server has exactly one dev-
 export declare const STATE_VIA_HOOKS_MESSAGE = "A screen reads only its model: const issueList = useModel('issueList'), then issueList.issues, issueList.isLoading and issueList.createIssue(). Reading .state, .models, .stores or getSnapshot() directly does not subscribe, so the screen would show stale data. If the screen needs something from a store, add a getter for it to the model.";
 export declare const CLASSES_NOT_FACTORIES_MESSAGE = "A function that returns an object of methods is a class in disguise: write it as a class, with private fields for its state and methods for its behaviour. One shape for everything that has state keeps the codebase predictable. Plain functions are for pure helpers that compute a value (sortProjects, newClientSideId).";
 export declare const ACCESS_FLOWS_MESSAGE = "flows/Access.flow.ts runs Pattern's generated access flows, which prove every table's access rules against the seed on each app test. Keep it: `import { accessFlows } from '@trypattern/sdk/flows'` and `accessFlows({ App })`.";
-export declare const SCHEMA_TABLES_MESSAGE = "schema.ts defines every saved table in one place and says who may do what: `export const tables = defineTables({ issues: { columns: { title: z.string() }, access: { read: 'signedIn', create: 'signedIn', update: 'signedIn', delete: 'signedIn' }, writes: 'optimistic' } })`. It exports a row type for each table, named for one row (`export type Issue = Row<typeof tables.issues>`), and the emails of the people who run the app, `export const admins: string[] = []`, even when there are none yet, so the question is answered on purpose. Add the line shown.";
+export declare const SCHEMA_TABLES_MESSAGE = "schema.ts defines every saved table in one place and says who may do what: `export const tables = defineTables({ issues: { columns: { title: z.string() }, access: { read: 'signedIn', create: 'signedIn', update: 'signedIn', delete: 'signedIn' }, writes: 'optimistic' } })`. When another file needs a table's row type, schema.ts exports it, named for one row (`export type Issue = Row<typeof tables.issues>`). It also exports the emails of the people who run the app, `export const admins: string[] = []`, even when there are none yet, so the question is answered on purpose. Add the line shown.";
 export declare const NO_UNUSED_EXPORTS_MESSAGE = "Export only what another file imports. Nothing imports this, so remove `export` (and the code itself if this file does not use it either). Unused exports hide dead code and make a file look like it offers more than it does. Pattern reads `tables` from schema.ts and `seed` from seed.ts, and vite.config.ts and server/worker.ts default-export their config, so those stay.";
 export declare const NO_RE_EXPORTS_MESSAGE = "Do not pass imports through: a file exports only what it defines. Import the thing from where it lives instead (command from @trypattern/sdk, a component from its own file), so every import names the real source. server/worker.ts is the one exception: Cloudflare runs the Workflow and Durable Object classes its Worker exports, so it may export them from where they live.";
 export declare const EXPLICIT_ACCESS_MESSAGE = "Mark every class member public or private (or protected, to override a base class member), so a reader sees at a glance what other code may call: `public setSort = command(...)`, `public override onPageOpen()`, `private loadIssues()`. Use the word private, never #name, so there is one way to say it. Constructors need neither.";
@@ -30,7 +30,7 @@ export declare const IMPORT_FROM_ROOT_MESSAGE = "Import project files by their p
 export declare const MODEL_MEMBERS_MESSAGE = "A model shows the outside world three kinds of public member, so a reader can tell them apart at a glance: getters are its answers (public get hasNext()), command() fields are what it can do (public openNext = command(() => ...)), and onPageOpen() runs when its page opens. Everything else is private, and a private helper that works something out is a method (private neighbours()), never a getter, because Pattern publishes every getter to the screen and the snapshot. A model has no `actions`: menu entries and shortcuts live in src/actions/.";
 export declare const MODEL_BY_NAME_MESSAGE = "Keep the model whole and read it by name: const issueList = useModel('issueList'), then issueList.isLoading and onClick={issueList.createIssue}. Destructuring it hides where each value comes from and leaves loose names a reader has to trace back.";
 export declare const USE_MODEL_WHERE_MESSAGE = "useModel is for screens (src/screens/) and layouts (src/layouts/). Other components take what they show as props and the commands they call as callbacks, so the screen decides what they read: <IssueListRow issue={issue} onDelete={issueList.deleteIssue} />.";
-export declare const PURE_GETTERS_MESSAGE = "A getter works an answer out from this.state and this.stores.<name>.state and nothing else. It never changes anything (this.set, a store method, this.app.navigate), never waits, and never reads the clock, randomness or a private field, because Pattern caches each getter until the state it read changes, and flows compare its value. Put the change in a command.";
+export declare const PURE_GETTERS_MESSAGE = "A getter works an answer out from this.state and this.stores.<name>.state and nothing else. It never changes anything (this.set, a store method, this.app.navigate), never waits, and never reads the clock, randomness or a private field, because Pattern caches each getter until the state it read changes, and flows compare its value. Put the change in a command. For the date today read this.stores.device.state.today (YYYY-MM-DD on this device, kept current past midnight), and for a phone-width screen this.stores.device.state.isCompact.";
 export declare const ACTIONS_WHERE_MESSAGE = "Menu entries and shortcuts are actions, and actions live only in src/actions/: one file per thing they act on, `export const issueActions = defineActions(({ page, models }) => [action({ id: 'issues.next', label: 'Next issue', keys: ['j'], send: [{ type: 'issueDetail.openNext' }] })])`, listed in src/actions/index.ts. If a person can see it in a menu or press a key for it, it is an action; what it does is a command on a model, and an action only sends commands. Models never build actions.";
 export declare const PURE_ACTIONS_MESSAGE = "An actions file works its entries out from `page` and `models` (each model's state and answers) and nothing else, because Pattern reruns it only when something it read changes, and flows compare the result. It never waits, never uses `this`, never reads the clock or randomness, and imports only types from src/models/, src/stores/ and src/components/. If an entry needs something a model does not answer yet, add a getter to that model.";
 export declare const USE_PRIMITIVES_MESSAGE = "Write <Button>, <IconButton>, <TextField>, <Select>, <Switch> or <Dialog> from @trypattern/sdk/react instead of this element. The primitives carry the focus, keyboard, disabled, pending and error behaviour and the design system's look, so a screen only says what the control does. If no primitive fits, the gap is in the SDK; do not build around it here.";

package/dist/rules/messages.js

@@ -22,7 +22,7 @@ export const DEV_ONLY_SIGN_IN_MESSAGE = 'The server has exactly one dev-only swi
 export const STATE_VIA_HOOKS_MESSAGE = "A screen reads only its model: const issueList = useModel('issueList'), then issueList.issues, issueList.isLoading and issueList.createIssue(). Reading .state, .models, .stores or getSnapshot() directly does not subscribe, so the screen would show stale data. If the screen needs something from a store, add a getter for it to the model.";
 export const CLASSES_NOT_FACTORIES_MESSAGE = 'A function that returns an object of methods is a class in disguise: write it as a class, with private fields for its state and methods for its behaviour. One shape for everything that has state keeps the codebase predictable. Plain functions are for pure helpers that compute a value (sortProjects, newClientSideId).';
 export const ACCESS_FLOWS_MESSAGE = "flows/Access.flow.ts runs Pattern's generated access flows, which prove every table's access rules against the seed on each app test. Keep it: `import { accessFlows } from '@trypattern/sdk/flows'` and `accessFlows({ App })`.";
-export const SCHEMA_TABLES_MESSAGE = "schema.ts defines every saved table in one place and says who may do what: `export const tables = defineTables({ issues: { columns: { title: z.string() }, access: { read: 'signedIn', create: 'signedIn', update: 'signedIn', delete: 'signedIn' }, writes: 'optimistic' } })`. It exports a row type for each table, named for one row (`export type Issue = Row<typeof tables.issues>`), and the emails of the people who run the app, `export const admins: string[] = []`, even when there are none yet, so the question is answered on purpose. Add the line shown.";
+export const SCHEMA_TABLES_MESSAGE = "schema.ts defines every saved table in one place and says who may do what: `export const tables = defineTables({ issues: { columns: { title: z.string() }, access: { read: 'signedIn', create: 'signedIn', update: 'signedIn', delete: 'signedIn' }, writes: 'optimistic' } })`. When another file needs a table's row type, schema.ts exports it, named for one row (`export type Issue = Row<typeof tables.issues>`). It also exports the emails of the people who run the app, `export const admins: string[] = []`, even when there are none yet, so the question is answered on purpose. Add the line shown.";
 export const NO_UNUSED_EXPORTS_MESSAGE = 'Export only what another file imports. Nothing imports this, so remove `export` (and the code itself if this file does not use it either). Unused exports hide dead code and make a file look like it offers more than it does. Pattern reads `tables` from schema.ts and `seed` from seed.ts, and vite.config.ts and server/worker.ts default-export their config, so those stay.';
 export const NO_RE_EXPORTS_MESSAGE = 'Do not pass imports through: a file exports only what it defines. Import the thing from where it lives instead (command from @trypattern/sdk, a component from its own file), so every import names the real source. server/worker.ts is the one exception: Cloudflare runs the Workflow and Durable Object classes its Worker exports, so it may export them from where they live.';
 export const EXPLICIT_ACCESS_MESSAGE = 'Mark every class member public or private (or protected, to override a base class member), so a reader sees at a glance what other code may call: `public setSort = command(...)`, `public override onPageOpen()`, `private loadIssues()`. Use the word private, never #name, so there is one way to say it. Constructors need neither.';
@@ -30,7 +30,7 @@ export const IMPORT_FROM_ROOT_MESSAGE = 'Import project files by their path from
 export const MODEL_MEMBERS_MESSAGE = 'A model shows the outside world three kinds of public member, so a reader can tell them apart at a glance: getters are its answers (public get hasNext()), command() fields are what it can do (public openNext = command(() => ...)), and onPageOpen() runs when its page opens. Everything else is private, and a private helper that works something out is a method (private neighbours()), never a getter, because Pattern publishes every getter to the screen and the snapshot. A model has no `actions`: menu entries and shortcuts live in src/actions/.';
 export const MODEL_BY_NAME_MESSAGE = "Keep the model whole and read it by name: const issueList = useModel('issueList'), then issueList.isLoading and onClick={issueList.createIssue}. Destructuring it hides where each value comes from and leaves loose names a reader has to trace back.";
 export const USE_MODEL_WHERE_MESSAGE = 'useModel is for screens (src/screens/) and layouts (src/layouts/). Other components take what they show as props and the commands they call as callbacks, so the screen decides what they read: <IssueListRow issue={issue} onDelete={issueList.deleteIssue} />.';
-export const PURE_GETTERS_MESSAGE = 'A getter works an answer out from this.state and this.stores.<name>.state and nothing else. It never changes anything (this.set, a store method, this.app.navigate), never waits, and never reads the clock, randomness or a private field, because Pattern caches each getter until the state it read changes, and flows compare its value. Put the change in a command.';
+export const PURE_GETTERS_MESSAGE = 'A getter works an answer out from this.state and this.stores.<name>.state and nothing else. It never changes anything (this.set, a store method, this.app.navigate), never waits, and never reads the clock, randomness or a private field, because Pattern caches each getter until the state it read changes, and flows compare its value. Put the change in a command. For the date today read this.stores.device.state.today (YYYY-MM-DD on this device, kept current past midnight), and for a phone-width screen this.stores.device.state.isCompact.';
 export const ACTIONS_WHERE_MESSAGE = "Menu entries and shortcuts are actions, and actions live only in src/actions/: one file per thing they act on, `export const issueActions = defineActions(({ page, models }) => [action({ id: 'issues.next', label: 'Next issue', keys: ['j'], send: [{ type: 'issueDetail.openNext' }] })])`, listed in src/actions/index.ts. If a person can see it in a menu or press a key for it, it is an action; what it does is a command on a model, and an action only sends commands. Models never build actions.";
 export const PURE_ACTIONS_MESSAGE = "An actions file works its entries out from `page` and `models` (each model's state and answers) and nothing else, because Pattern reruns it only when something it read changes, and flows compare the result. It never waits, never uses `this`, never reads the clock or randomness, and imports only types from src/models/, src/stores/ and src/components/. If an entry needs something a model does not answer yet, add a getter to that model.";
 export const USE_PRIMITIVES_MESSAGE = "Write <Button>, <IconButton>, <TextField>, <Select>, <Switch> or <Dialog> from @trypattern/sdk/react instead of this element. The primitives carry the focus, keyboard, disabled, pending and error behaviour and the design system's look, so a screen only says what the control does. If no primitive fits, the gap is in the SDK; do not build around it here.";

package/dist/server/tables.js

@@ -12,7 +12,7 @@ function typesOf(schema) {
         return [type];
     return Array.isArray(type) ? type : [];
 }
-function sqlColumn(key, schema) {
+function sqlColumn(key, schema, start) {
     const types = typesOf(schema);
     const name = snakeCase(key);
     const column = types.includes('boolean')
@@ -22,7 +22,8 @@ function sqlColumn(key, schema) {
             : types.includes('number')
                 ? real(name)
                 : text(name);
-    return types.includes('null') ? column : column.notNull();
+    const started = start === undefined ? column : column.default(start);
+    return types.includes('null') ? started : started.notNull();
 }
 function uniqueIndexName(table, columns) {
     return [table.name, ...columns, 'unique'].map(snakeCase).join('_');
@@ -30,7 +31,7 @@ function uniqueIndexName(table, columns) {
 export function sqlTable(table) {
     const columns = Object.fromEntries(Object.entries(table.columns).map(([key, schema]) => [
         key,
-        sqlColumn(key, schema)
+        sqlColumn(key, schema, table.defaults[key])
     ]));
     return sqliteTable(snakeCase(table.name), {
         id: text('id').primaryKey(),

package/dist/store.d.ts

@@ -34,7 +34,8 @@ export declare abstract class DeclaredStore<State extends object, Client = Recor
 export type StoreClass<S extends StateSpec, P extends readonly (keyof S & string)[], Client = Record<never, never>> = (abstract new (persisted: Persisted, services: Client) => DeclaredStore<StateOf<S>, Client>) & {
     readonly config: StoreConfig<S, P>;
 };
-export declare function defineStore<Client>(): <S extends StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config: StoreConfig<S, P>) => StoreClass<S, P, Client>;
+export type StoreFactory<Client> = <S extends StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config: StoreConfig<S, P>) => StoreClass<S, P, Client>;
+export declare function defineStore<Client>(): StoreFactory<Client>;
 export type Snapshots<Group> = {
     [Key in keyof Group]: Group[Key] extends {
         readonly state: infer State;

package/dist/table.d.ts

@@ -17,6 +17,7 @@ export type TableDefinition = {
     readonly owned?: boolean;
     readonly public?: readonly string[];
     readonly unique?: readonly (readonly string[])[];
+    readonly defaults?: Readonly<Record<string, Value>>;
 };
 type OwnerColumn<Owned> = [Owned] extends [true] ? {
     ownerId: z.ZodString;
@@ -29,6 +30,7 @@ export type Table = {
     readonly owned: boolean;
     readonly public: readonly string[];
     readonly unique: readonly (readonly string[])[];
+    readonly defaults: Readonly<Record<string, Value>>;
     readonly fields: z.ZodObject<Columns>;
     readonly incoming: z.ZodObject<{
         id: z.ZodString;
@@ -49,6 +51,7 @@ export type TableOf<Name extends string, Definition extends TableDefinition> = {
     readonly owned: Definition['owned'] extends true ? true : false;
     readonly public: readonly PublicColumn<Definition>[];
     readonly unique: readonly (readonly string[])[];
+    readonly defaults: Readonly<Record<string, Value>>;
     readonly fields: z.ZodObject<Definition['columns']>;
     readonly incoming: z.ZodObject<{
         id: z.ZodString;
@@ -96,6 +99,7 @@ type DraftTable = {
     readonly owned?: boolean;
     readonly public?: readonly string[];
     readonly unique?: readonly (readonly string[])[];
+    readonly defaults?: Readonly<Record<string, Value>>;
 };
 type StaticTypeError<Message extends string> = Message;
 type IsOwned<Definition> = Definition extends {
@@ -112,6 +116,11 @@ type ReadOf<Definition> = Definition extends {
 type ColumnOf<Definition> = Definition extends {
     readonly columns: infer C;
 } ? keyof C & string : never;
+type DefaultsOf<Definition> = Definition extends {
+    readonly columns: infer C extends Columns;
+} ? {
+    readonly [Key in keyof C]?: z.output<C[Key]>;
+} : never;
 type OwnerNeedsOwned = StaticTypeError<"'owner' needs owned: true on this table, so every row records who made it">;
 type CreateIsNeverOwner = StaticTypeError<"create can't be 'owner': nobody owns a row before it exists. Use 'signedIn' and the person who creates it becomes its owner">;
 type OwnedNeedsSignedInCreate = StaticTypeError<"An owned table can't let anyone create rows: a signed-out visitor has no account to own the row. Use 'signedIn'">;
@@ -132,7 +141,7 @@ type CheckedColumns<C> = {
     [Key in keyof C]: Key extends 'ownerId' ? OwnerIdIsPattern : C[Key];
 };
 type CheckedTable<Definition> = {
-    [Key in keyof Definition]: Key extends 'columns' ? CheckedColumns<SameOnTheWire<Definition[Key] & z.ZodRawShape>> : Key extends 'access' ? CheckedAccess<Definition, Definition[Key]> : Key extends 'writes' ? HasUnique<Definition> extends true ? Definition[Key] extends 'confirmed' ? Definition[Key] : UniqueNeedsConfirmed : Definition[Key] : Key extends 'public' ? ReadOf<Definition> extends 'anyone' ? PublicNeedsPrivateRead : Definition[Key] & readonly (ColumnOf<Definition> | 'createdAt')[] : Key extends 'unique' ? Definition[Key] & readonly (readonly ColumnOf<Definition>[])[] : Definition[Key];
+    [Key in keyof Definition]: Key extends 'columns' ? CheckedColumns<SameOnTheWire<Definition[Key] & z.ZodRawShape>> : Key extends 'access' ? CheckedAccess<Definition, Definition[Key]> : Key extends 'writes' ? HasUnique<Definition> extends true ? Definition[Key] extends 'confirmed' ? Definition[Key] : UniqueNeedsConfirmed : Definition[Key] : Key extends 'public' ? ReadOf<Definition> extends 'anyone' ? PublicNeedsPrivateRead : Definition[Key] & readonly (ColumnOf<Definition> | 'createdAt')[] : Key extends 'unique' ? Definition[Key] & readonly (readonly ColumnOf<Definition>[])[] : Key extends 'defaults' ? Definition[Key] & DefaultsOf<Definition> : Definition[Key];
 } & Missing<Definition, 'access', AccessIsRequired> & Missing<Definition, 'writes', WritesIsRequired>;
 export declare function defineTables<const Definitions extends Record<string, DraftTable> = Record<never, never>>(definitions: {
     [Key in keyof Definitions]: CheckedTable<Definitions[Key]>;

package/dist/table.js

@@ -28,6 +28,15 @@ function problemIn(name, definition) {
     if (unknown !== undefined) {
         return `Table "${name}" names "${unknown}", which is not one of its columns`;
     }
+    for (const [column, value] of Object.entries(definition.defaults ?? {})) {
+        const schema = columns[column];
+        if (schema === undefined) {
+            return `Table "${name}" has a default for "${column}", which is not one of its columns`;
+        }
+        if (!schema.safeParse(value).success) {
+            return `Table "${name}": the default for "${column}" isn't a valid ${column}`;
+        }
+    }
     if ((definition.unique ?? []).length > 0 &&
         definition.writes !== 'confirmed') {
         return `Table "${name}" has a unique constraint, so writes must be 'confirmed'`;
@@ -65,6 +74,7 @@ function table(name, definition, isPatterns = false) {
         owned,
         public: publicColumns,
         unique: definition.unique ?? [],
+        defaults: definition.defaults ?? {},
         fields: z.object(columns),
         incoming: z.object({ id: z.string(), ...columns }),
         row: z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trypattern/sdk",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "type": "module",
   "files": [
     "dist",