@trypattern/sdk 0.1.12 → 0.1.13

package/README.md

@@ -73,10 +73,11 @@ export default createServer({ tables, admins })
   `session`, `actions`, `toasts` and `page` stores, with the appearance, Log out and ⌘K actions), `defineRoutes` (route ids are the page names), `startApp` (the browser entry:
   creates the router, with the dev tools `app send` and visual flows use), `Model`, `Store`,
   `command`, `appPath`, `defineActions`, `action`, `rankActions` (the command menu's search),
-  `EntityStore`, `TableStore` (`create` takes the columns only), `Cache`, `Gate`, and the types
+  `EntityStore`, `TableStore` (`create` takes the columns only), `Cache`, `Gate`, the `bookings`
+  block (below), and the types
   `AppStores`, `AppSnapshot`, `AppCommand`, `AppPath`, `AppAction`, `AppActionGroup`,
   `Interaction`, `PublishedOf`, `MessagesOf`.
-- `@trypattern/sdk/schema`: `defineTables` and the types `Row`, `PublicRow` and `Seed`. Every row gets an
+- `@trypattern/sdk/schema`: `defineTables` and the types `Row`, `PublicRow`, `Seed` and `Starter`. Every row gets an
   `id` and `createdAt` that Pattern sets. Every table declares `access` (`anyone`, `signedIn`,
   `owner`, `admin` or `server` for read, create, update and delete) and `writes` (`optimistic` or
   `confirmed`), and may add `owned: true` (an `ownerId` the server fills), `public` columns (a
@@ -84,7 +85,19 @@ export default createServer({ tables, admins })
   own table of photos (`key`, `width`, `height`, `placeholder`, `alt`, `type`, `bytes`): an app
   that shows photos adds it to its tables (`{ ...defineTables({ … }), media }`), binds an R2
   bucket as `MEDIA` in `wrangler.jsonc` with `"/media/*"` in `run_worker_first`, and stores the
-  media row's `id` in its own columns. Anyone reads it; only the server creates rows. `src/access.ts` is
+  media row's `id` in its own columns. Anyone reads it; only the server creates rows.
+  `bookingTables` are the bookings block's own tables (`bookingRules`, one row of weekday windows
+  `{ weekday, label, start, end, capacity }` with `leadTimeHours`, `daysAhead` and `autoAccept`;
+  `bookingBlackouts`, `{ date, reason }`; `bookingRequests`, `{ offering, date, window, name,
+email, phone, address, notes, status }` with `status` `requested`, `accepted`, `declined` or
+  `cancelled`): an app that takes bookings spreads them into its tables
+  (`{ ...defineTables({ … }), ...bookingTables }`) so migrations, the seed and the dashboard's
+  database see them, and every operation on them is `server`. `seed.ts` is
+  sample data for dev and flows and never ships; `starter/` is the content a new site opens with,
+  written once on its first publish, then owned by the owner. `starter/rows.ts` exports
+  `starter: Starter<typeof tables>`: rows for tables that are not `owned`, and `media` rows as
+  `{ id, photo, alt }`, where `photo` names a file in `starter/photos/`. After that first publish
+  the folder is inert and may be deleted. `src/access.ts` is
   the one rule engine; the Worker and the flow runner's memory API both use it, and
   `accessFlows({ App })` from `@trypattern/sdk/flows` checks every table's rules against the seed.
   Store writes return `'saved' | 'conflict' | 'forbidden' | 'missing' | 'failed'`. Safe to import
@@ -93,11 +106,15 @@ export default createServer({ tables, admins })
   auth.trypattern.ai (Google, and emailed 6-digit codes; locally the code prints in the dev log),
   dev sign-in, sessions, `/api/me` and every table under `/api/tables`. A deployed app holds one
   `AUTH_SECRET` that Pattern's deploy sets, and no Google secrets. Also `users`, `sessions`,
-  With `media` in its tables it also serves `POST /api/media` (admins only, a form with `file`
-  and `alt`, up to 10 MB of JPEG, PNG, WebP, GIF or AVIF; HEIC is refused): it reads the size from
+  With `media` in its tables it also serves `POST /api/media` (admins only, or Pattern with a
+  `media:write` assertion; a form with `file`, `alt` and an optional `id`, which makes a repeat
+  answer 200 with the row already there; up to 10 MB of JPEG, PNG, WebP, GIF or AVIF; HEIC is
+  refused): it reads the size from
   the file's header (EXIF rotation included), stores it in `MEDIA` as `images/<sha256-16>.<ext>`,
   asks the zone's image transformations for a 24-pixel JPEG placeholder (skipped in dev, so it is
-  `null` locally) and adds the row; and `GET /media/<key>`, immutable with an ETag. With
+  `null` locally) and adds the row; and `GET /media/<key>`, immutable with an ETag, which in dev
+  fetches a photo the local bucket lacks from `https://<name>.onpattern.app`, so a pulled project
+  shows the live photos without storing them. With
   `pages` (`definePages(tables, { '/': head, '/items/:itemId': { head, paths } })` in
   `server/pages.ts`) it renders the `<head>` of public pages: each `head` reads tables anyone may
   read (`rows`, `row`, `photoUrl`) and returns `{ title, description, image, hero, jsonLd, data }`
@@ -108,7 +125,23 @@ export default createServer({ tables, admins })
   and the alt as caption) and `robots.txt` come from the same list (`paths` lists a pattern's
   params). It needs `"binding": "ASSETS"` and the page paths, `/sitemap.xml` and `/robots.txt` in
   `run_worker_first`; other paths still get the built files. `localBusiness({ … })` and
-  `product({ … })` write the JSON-LD. Also `users`, `sessions`,
+  `product({ … })` write the JSON-LD. With
+  `blocks: [bookings({ timezone: 'America/Toronto' })]` (an IANA zone; the owner's days and
+  windows are in it) it serves the bookings block under `/api/bookings`, open to signed-out
+  visitors: `GET days?month=2026-11` (every day of the month as `open`, `closed` or `full`),
+  `GET windows?date=2026-11-13` (that day's bookable windows, `{ id, label, start, end,
+remaining }`, the `id` being `start-end`), and `POST requests` (public; it checks again that the
+  day and window are bookable, then inserts only while the window's `requested` and `accepted`
+  requests are under its capacity, in one statement, so two visitors never both get the last place:
+  400 for a day or window that can't be booked, 409 when it just filled). A day is `closed` before
+  today, after `daysAhead`, on a blackout, or when none of its weekday's windows starts at least
+  `leadTimeHours` from now; `full` when every window left has no room. The owner's routes need an
+  admin: `GET requests`, `POST requests/:id/accept` (from `requested`), `POST requests/:id/decline`
+  (from `requested` or `accepted`, which frees the place), `GET rules` and `POST rules` (windows,
+  lead time, days ahead, `autoAccept` and the blackouts together). Emails to the owner and the
+  requester are not sent yet: `sendBookingEmail` in `src/server/bookings.ts` is the one place they
+  will go, and it prints each one in the dev log. `createServer` refuses a block whose tables are
+  missing from `tables`, and booking tables without the block. Also `users`, `sessions`,
   `sqlTables`, `seedSql`, the sign-in wire schemas (`verifiedIdentity`, `exchangeRequest`,
   `exchangeReply`, `sendCodeRequest`, `sendCodeReply`, `verifyCodeRequest`, `verifyCodeReply`) and
   the Worker types `D1Database` and `R2Bucket`.
@@ -121,14 +154,21 @@ export default createServer({ tables, admins })
   (`multiline` with `rows` for a few lines), `Select`, `Switch`,
   `SegmentedControl`, `ChoiceGroup` (a wrapping radio group of `Choice` children, each with a
   `title`, `subline`, `isDisabled` or any children such as an `Image` with a `label`; the chosen
-  one is ringed, the others fade, arrow keys move between them), `Menu`, `ContextMenu`, `Dialog`, `Tooltip`, `Kbd`, `ScrollArea`, `Avatar`,
-  `Badge`, `Skeleton`, `Spinner`, `Icon`. Photos: `Image` (`image` is a media row, `sizes` is
+  one is ringed, unchosen photos fade, arrow keys move between them), `Calendar` (a month grid of `open`, `closed` and `full` days, with month arrows and arrow-key movement), `Menu`, `ContextMenu`, `Dialog` (`size` up to `xl`, 800 pixels), `Tooltip`, `Kbd`, `ScrollArea`, `Avatar`,
+  `Badge`, `Skeleton`, `Spinner`, `Icon`. Dates: `Calendar` (a month grid; the caller owns the
+  month: `month="2026-11"` and `onMonthChange`, with `firstMonth` and `lastMonth` to stop the
+  arrows; `days` lists `{ date, state }` with `open`, `closed` (greyed) or `full` (struck
+  through), and a day it does not list is closed; `value` is filled and `onPick` gets an open day;
+  today, from the browser or `today`, is ringed; weeks start on Monday and the month and weekday
+  names follow `locale`; arrow keys move by day and week, Home and End to the week's ends, PageUp
+  and PageDown by month, moving the month with them). Photos: `Image` (`image` is a media row, `sizes` is
   required, `priority` for the first photo on a page only, `aspect` crops with `fit=cover`): it
   reserves the size from the row's `width` and `height`, offers 320 to 1920 pixel widths (never
   wider than the original) through `/cdn-cgi/image/…` (plain `/media/<key>` on localhost), lazy-loads
   unless `priority`, shows the blurred placeholder and fades the photo in over 200 ms unless it was
   already loaded or motion is reduced, and shows a neutral block when the photo is missing or fails. Types: `IconName`, `MenuEntry`, `SidebarLink`,
-  `Toast`, `SelectOption`, `SegmentedOption`, `CommandMenuItem`, `SpaceName` and `Placement`.
+  `Toast`, `SelectOption`, `SegmentedOption`, `CommandMenuItem`, `CalendarDay`, `SpaceName` and
+  `Placement`.
   Everything takes closed choices (`variant`, `tone`, `size`, `gap`, `width`) and a `style`
   limited to placement, and every interactive primitive reports to `startApp`'s `onInteraction`.
   App screens have no styles; `app check` holds them to that.
@@ -141,6 +181,22 @@ export default createServer({ tables, admins })
   the app tsconfig preset loads, fills `Register` from `src/App.ts`, `schema.ts`,
   `src/stores/index.ts` and `src/routes.tsx`. `Model`, `AppStores`, `AppSnapshot`, `AppCommand` and `AppPath` come from `@trypattern/sdk`.
 
+- Blocks: an SDK module with its own tables, server routes and store, and no look; the app's
+  components draw it. The first is `bookings`, request-and-accept with windows and capacity:
+  `createServer({ tables, admins, blocks: [bookings({ timezone })] })` in `server/worker.ts` and
+  `defineApp({ tables, blocks: [bookings], stores, models, routes })` in `src/App.ts`, with
+  `...bookingTables` in `tables`. Every model then has `this.stores.bookings`, whose calls
+  (`bookings.days`, `bookings.windows`, `bookings.request`, `bookings.requests`, `bookings.accept`,
+  `bookings.decline`, `bookings.rules`, `bookings.saveRules`) go through the Gate:
+  `loadDays(month)` and `loadWindows(date)` fill `days[month]` and `windows[date]`;
+  `request({ offering, date, window, name, email, phone?, address?, notes? })` sets `sent` and
+  reloads that month and date; `loadRequests()` fills `requests` and `requestsStatus`;
+  `accept(id)`, `decline(id)`, `loadRules()` and `saveRules(rules)` keep `requests` and `rules`
+  current. Writes return `'saved' | 'conflict' | 'forbidden' | 'missing' | 'failed'` like table
+  writes. `offering` is any id the app gives it (an item, a size); the block never owns products.
+  In flows and `?memory` the calls fake against `world.bookings` (`BookingsWorld`: `now`,
+  `timezone`, `rules`, `requests`), with the same availability code as the Worker; the fake does
+  not check who is signed in. A type error names a block whose tables are not in `tables`.
 - `@trypattern/sdk/flows`: `defineFlow({ App })`; the `flow()` it returns fakes the server
   from the app's tables and the seed in `vite.config.ts`, and runs headless in Node or in Chrome with `app test --visual`.
 - `@trypattern/sdk/vite`: `pattern({ tables, admins, seed })`, the whole Vite and Vitest setup, including the
@@ -151,7 +207,12 @@ export default createServer({ tables, admins })
   and its icons. Pattern's dashboard renders the design system from it.
 - `@trypattern/sdk/tsconfig/app.json` and `/tsconfig/server.json`: the presets project tsconfigs extend.
 - The `app` command: start, check, fix, reset, migration, media (`app media add photo.jpg --alt "…"`
-  uploads to the dev server as the first admin), build, send, screenshot, test, sign-in, setup.
+  uploads to the dev server as the first admin; `--live` first uploads it to the live site through
+  onpattern.app, then locally under the same id), build, send, screenshot, test, sign-in, setup,
+  login, pull, publish, versions, restore. `app start` and `app reset` fill the local database
+  from `seed.ts` and `starter/rows.ts` and put `starter/photos` in the local `MEDIA` bucket;
+  `app publish --starter` sends `starter/` with the starter, and a new site's first publish adds
+  the photos through its own `POST /api/media`, then the rows.
 
 Published to npm as `@trypattern/sdk`, compiled to `dist/`; in this repo the blueprint runs the
-source directly. Still to come: payments, workflows and blocks.
+source directly. Still to come: payments, workflows and more blocks.

package/dist/access.d.ts

@@ -16,10 +16,6 @@ export declare function viewerOf(user: {
     id: string;
     isAdmin: boolean;
 } | null | undefined): Viewer | null;
-export declare function viewerByEmail(user: {
-    id: string;
-    email: string;
-} | null | undefined, admins: ReadonlySet<string>): Viewer | null;
 export declare function readScope(table: Table, viewer: Viewer | null): ReadScope;
 export declare function listRefusal(table: Table, viewer: Viewer | null): Refusal | undefined;
 export declare function canSee(table: Table, viewer: Viewer | null, row: Owned): boolean;

package/dist/access.js

@@ -6,11 +6,6 @@ export function viewerOf(user) {
         return null;
     return { userId: user.id, isAdmin: user.isAdmin };
 }
-export function viewerByEmail(user, admins) {
-    if (user === null || user === undefined)
-        return null;
-    return { userId: user.id, isAdmin: admins.has(user.email.toLowerCase()) };
-}
 function mayUse(level, viewer) {
     if (level === 'server')
         return false;

package/dist/api.d.ts

@@ -24,7 +24,9 @@ export declare function memoryApi<Group extends Tables>(tables: Group, seed: See
     admins: readonly string[];
     title: string;
 } & ServicesSetup): AppApi<Group>;
-export declare function browserApi<Group extends Tables>(tables: Group, seed: Seed<Group>, gate: Gate, { inMemory, admins, ...setup }: {
+export declare function browserApi<Group extends Tables>(tables: Group, seed: Seed<Group>, gate: Gate, { inMemory, signedInAs, admins, title, ...setup }: {
     inMemory: boolean;
+    signedInAs: string | null;
     admins: readonly string[];
+    title: string;
 } & ServicesSetup): AppApi<Group>;

package/dist/api.js

@@ -1,9 +1,8 @@
-import { adminEmails, viewerByEmail, viewerOf } from "./access.js";
+import { viewerOf } from "./access.js";
 import { HttpSessionApi, MemorySessionApi, sessionCalls } from "./auth/sessionApi.js";
 import { HttpAppInfoApi, MemoryAppInfoApi, appInfoCalls } from "./appInfo.js";
 import { httpServices, memoryServices } from "./serviceClients.js";
 import { serviceCallNames } from "./services.js";
-import { ownerIdOf } from "./table.js";
 import { httpTables, memoryTables, tableCalls } from "./tables.js";
 export function apiCalls(tables, services = {}) {
     return [
@@ -42,25 +41,8 @@ export function memoryApi(tables, seed, { gate, signedInAs, admins, title, ...se
         services: memoryClient(setup, options)
     };
 }
-export function browserApi(tables, seed, gate, { inMemory, admins, ...setup }) {
-    const session = new HttpSessionApi(gate);
-    const emails = adminEmails(admins);
-    const options = { latencyMs: 0, gate };
-    return {
-        tables: inMemory
-            ? memoryTables(tables, seed, () => {
-                const user = session.rememberedUser();
-                return viewerByEmail(user === undefined
-                    ? undefined
-                    : { ...user, id: ownerIdOf(user.email) }, emails);
-            }, { latencyMs: 0, gate })
-            : httpTables(tables, gate, () => session.reportSignedOut()),
-        session,
-        app: new HttpAppInfoApi(gate),
-        services: inMemory
-            ? memoryClient(setup, options)
-            : setup.services === undefined
-                ? {}
-                : httpServices(setup.services, gate, () => session.reportSignedOut())
-    };
+export function browserApi(tables, seed, gate, { inMemory, signedInAs, admins, title, ...setup }) {
+    return inMemory
+        ? memoryApi(tables, seed, { gate, signedInAs, admins, title, ...setup })
+        : httpApi(tables, gate, setup);
 }

package/dist/app.d.ts

@@ -1,6 +1,9 @@
 import type { DataRouter } from 'react-router';
 import type { AppApi } from './api.ts';
 import { AppStore } from './appInfo.ts';
+import type { AppBlock } from './blocks.ts';
+import type { bookingRequests } from './bookings.ts';
+import type { Bookings } from './bookingsStore.ts';
 import { SessionStore } from './auth/sessionStore.ts';
 import type { Cache } from './cache.ts';
 import type { Clock } from './clock.ts';
@@ -70,15 +73,27 @@ export type PublicStores<Group extends Tables> = {
         never
     ] ? never : `public${Capitalize<Key>}`]: PublicTableStore<Group[Key]>;
 };
+export type BlockStores<Group extends Tables> = [
+    typeof bookingRequests
+] extends [Group[keyof Group]] ? {
+    bookings: Bookings;
+} : Record<never, never>;
 export type StoresOf<Group extends Tables, Custom, Item extends Action = Action> = {
     session: SessionStore;
     app: AppStore;
     actions: ActionsStore<Item>;
     toasts: Toasts;
     page: PageStore;
-} & TableStores<Group> & PublicStores<Group> & Custom;
-export type AppDefinition<Group extends Tables, Custom extends StoreClasses, Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[]> = {
+} & 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}`>;
+export type CheckedBlocks<Group extends Tables, Blocks extends readonly AppBlock[]> = {
+    [Key in keyof Blocks]: [
+        Blocks[Key]['tables'][keyof Blocks[Key]['tables']]
+    ] extends [Group[keyof Group]] ? Blocks[Key] : BlockTablesMissing<Blocks[Key]['name']>;
+};
+export type AppDefinition<Group extends Tables, Custom extends StoreClasses, Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[], Blocks extends readonly AppBlock[] = readonly []> = {
     tables: Group;
+    blocks?: Blocks & CheckedBlocks<Group, Blocks>;
     stores?: Custom;
     models: {
         [Key in keyof Classes]: Key extends keyof BuiltInModels | 'app' ? StaticTypeError<`${Key & string} is a built-in model of @trypattern/sdk: its state, answers and commands come from Pattern. Name yours for what it holds.`> : PlainJsonModel<Classes[Key]>;
@@ -105,12 +120,12 @@ export type AppSnapshotShape<Models, Stores, Page> = {
     stores: Snapshots<Stores>;
 };
 type AppCommandOf<Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[]> = MessagesOf<Instances<BuiltInModels>> | MessagesOf<Instances<Classes>> | NavigateCommand<PathOf<Routes>> | PressKeyCommand;
-export type DefinedApp<Group extends Tables, Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[], Custom extends StoreClasses> = {
+export type DefinedApp<Group extends Tables, Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[], Custom extends StoreClasses, Blocks extends readonly AppBlock[] = readonly []> = {
     new (router: DataRouter, dependencies: AppDependencies<AppApi<Group>>): RunningApp<AppCommandOf<Classes, Routes>, AppSnapshotShape<Instances<BuiltInModels & Classes>, StoresOf<Group, StoreInstances<Custom>>, PageOf<Routes>>> & {
         readonly models: Instances<BuiltInModels & Classes>;
         readonly stores: StoresOf<Group, StoreInstances<Custom>>;
         pressKey(key: string): Promise<void> | undefined;
     };
-    readonly definition: AppDefinition<Group, Custom, Classes, Routes>;
+    readonly definition: AppDefinition<Group, Custom, Classes, Routes, Blocks>;
 };
-export declare function defineApp<Group extends Tables, Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[], Custom extends StoreClasses = Record<never, never>>(definition: AppDefinition<Group, Custom, Classes, Routes>): DefinedApp<Group, Classes, Routes, Custom>;
+export declare function defineApp<Group extends Tables, Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[], Custom extends StoreClasses = Record<never, never>, const Blocks extends readonly AppBlock[] = readonly []>(definition: AppDefinition<Group, Custom, Classes, Routes, Blocks>): DefinedApp<Group, Classes, Routes, Custom, Blocks>;

package/dist/app.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { viewerOf } from "./access.js";
 import { AppStore } from "./appInfo.js";
+import { blockWiringProblem } from "./blocks.js";
 import { SessionStore } from "./auth/sessionStore.js";
 import { realClock } from "./clock.js";
 import { ActionsStore } from "./actions.js";
@@ -54,7 +55,30 @@ const builtInModels = {
     signIn: SignIn
 };
 const appPathInput = z.custom((value) => typeof value === 'string' && isRoutedPath(value), { error: 'Not a page in src/routes.tsx' });
+function withBlocks(definition, blocks) {
+    if (blocks.length === 0)
+        return definition;
+    const services = {
+        ...definition.services
+    };
+    const memory = { ...definition.memory };
+    for (const block of blocks) {
+        for (const group of Object.keys(block.services)) {
+            if (Object.hasOwn(services, group)) {
+                throw new Error(`The ${block.name} block serves the ${group} calls, and so does src/services/index.ts: give your own services another name.`);
+            }
+            services[group] = block.services[group] ?? {};
+            memory[group] = Reflect.get(block.memory, group);
+        }
+    }
+    return { ...definition, services, memory };
+}
 export function defineApp(definition) {
+    const blocks = definition.blocks ?? [];
+    const wiring = blockWiringProblem(definition.tables, blocks, 'app');
+    if (wiring !== undefined)
+        throw new Error(wiring);
+    const defined = withBlocks(definition, blocks);
     const pages = new Set(pageIds(definition.routes));
     registerRoutes(definition.routes);
     if (Object.hasOwn(definition.models, 'app')) {
@@ -66,7 +90,7 @@ export function defineApp(definition) {
         }
     }
     return class App {
-        static definition = definition;
+        static definition = defined;
         router;
         models;
         stores;
@@ -97,15 +121,20 @@ export function defineApp(definition) {
                 key,
                 new Store(cache.persisted(`stores.${key}`), api.services)
             ]));
+            const blockStores = Object.fromEntries(blocks.map((block) => [
+                block.name,
+                new block.Store(cache.persisted(`stores.${block.name}`), api.services)
+            ]));
             const toasts = new Toasts(cache.persisted('stores.toasts'), {});
             const clash = clashOf([
                 ['session', 'app', 'actions', 'toasts', '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 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 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 ?? []),
@@ -119,6 +148,7 @@ export function defineApp(definition) {
                 page: this.#page,
                 ...data.tables,
                 ...data.publicViews,
+                ...blockStores,
                 ...custom
             };
             this.#session = session;

package/dist/blocks.d.ts

@@ -0,0 +1,18 @@
+import type { Persisted } from './state.ts';
+import type { Services } from './services.ts';
+import type { Tables } from './table.ts';
+export type BlockStoreClass = new (persisted: Persisted, services: never) => {
+    readonly state: object;
+    readonly subscribe: (listener: () => void) => () => void;
+};
+export type AppBlock = {
+    readonly name: string;
+    readonly tables: Tables;
+    readonly services: Services;
+    readonly memory: object;
+    readonly Store: BlockStoreClass;
+};
+export declare function blockWiringProblem(tables: Tables, blocks: readonly {
+    readonly name: string;
+    readonly tables: Tables;
+}[], side: 'server' | 'app'): string | undefined;

package/dist/blocks.js

@@ -0,0 +1,36 @@
+import { bookingTables } from "./bookings.js";
+const KNOWN_BLOCKS = [
+    {
+        name: 'bookings',
+        tables: bookingTables,
+        tablesExport: 'bookingTables',
+        server: "bookings({ timezone: 'America/Toronto' })"
+    }
+];
+function includesAll(tables, wanted) {
+    const present = new Set(Object.values(tables));
+    return Object.values(wanted).every((table) => present.has(table));
+}
+function includesAny(tables, wanted) {
+    const present = new Set(Object.values(tables));
+    return Object.values(wanted).some((table) => present.has(table));
+}
+export function blockWiringProblem(tables, blocks, side) {
+    for (const block of blocks) {
+        if (includesAll(tables, block.tables))
+            continue;
+        const known = KNOWN_BLOCKS.find((item) => item.name === block.name);
+        const name = known?.tablesExport ?? `the ${block.name} tables`;
+        return `The ${block.name} block keeps its rows in Pattern's own tables: add ...${name} from '@trypattern/sdk/schema' to tables in schema.ts, then run app migration add_${block.name}`;
+    }
+    for (const known of KNOWN_BLOCKS) {
+        if (!includesAny(tables, known.tables))
+            continue;
+        if (blocks.some((block) => block.name === known.name))
+            continue;
+        return side === 'server'
+            ? `tables has the ${known.name} block's tables, so the server needs the block: add blocks: [${known.server}] from '@trypattern/sdk/server' to createServer in server/worker.ts`
+            : `tables has the ${known.name} block's tables, so the app needs the block: add blocks: [${known.name}] from '@trypattern/sdk' to defineApp in src/App.ts`;
+    }
+    return undefined;
+}