@trylight/app 0.1.3 → 0.1.5

package/README.md

@@ -8,11 +8,11 @@ unchanged; entities and the schema sync are new here.
 | Import | What |
 |---|---|
 | `@trylight/app/schema` | `entity(name, columns, access)`: a Drizzle table plus `id`, `created_at`, `updated_at`, `created_by`, `field_sources`; `lightChanges` (the audit table); `lightImages` (the app's copy of its logos and photos); `fieldSource` (the `{url, evidence}` schema) |
-| `@trylight/app` | `createApp<typeof contracts>()` → `app.table(entity)` (`list/get/create/update/delete`, `useList/useGet/useCreate/useUpdate/useDelete`, typed by the entity passed), `app.contracts` (`useInvocation`), and `imageSrc(url)` (where a logo or photo loads from) |
+| `@trylight/app` | `createApp<typeof contracts>()` → `app.table(entity)` (`list/get/create/update/delete`, `useList/useGet/useCreate/useUpdate/useDelete`, typed by the entity passed; `useList(...).rows` is never undefined), `app.contracts` (`useInvocation`), and `imageSrc(url)` (where a logo or photo loads from) |
 | `@trylight/app/server` | `createLightServer({ schema, contracts })` → `light.db` (Drizzle), `light.session(request)`, `light.signIn(email, password)`, and the route handlers `light.entities`, `light.image`, `light.invoke.handler`, `light.chat` |
 | `@trylight/app/platform` | the door for server functions, framing, analytics/error policies, the pane bridge |
 | `@trylight/app/vite` | `lightDb()`: the dev server syncs `db/schema` into the database on every change |
-| `light-db` (bin) | `sync`, `migrate`, `check`: the app's `pnpm db:*` scripts |
+| `light-db` (bin) | `sync`, `migrate`, `check`: the app's `pnpm db:*` scripts; `baseline`: an older app's tables into `db/schema`, once |
 
 ## Entities
 
@@ -70,7 +70,7 @@ fails while `db/schema` has changes no migration holds.
 `src/db/audit.ts`, in Postgres itself. Every entity table has a row trigger
 that records each insert, update, delete and truncate in `light_changes` (the
 new row, `{ column: { from, to } }`, or the old row), whoever wrote it: the
-actor is `light.actor_kind/_id/_name`, which the entities route and Plaza's
+actor is `light.actor_kind/_id/_name`, which the entities route and the platform's
 `mii db write` set per transaction, or else the database role. A migration
 that drops a table or column or changes a column's type first copies what it
 destroys into `light_archive` (`light_archive_values`, called at the top of
@@ -81,6 +81,21 @@ table` through `mii db write`) is not archived.
 `migrate` installs the functions before applying migrations and the triggers
 after; the template's AGENTS.md has the restore SQL.
 
+## Baseline
+
+`light-db baseline` moves an app made before `db/schema` (the Vite or Next.js
+template, tables made by `migrations/*.sql`) onto it, once: `drizzle-kit pull`
+reads the live database, and `db/migrations/0000_baseline.sql` records the
+tables as they are (its SQL commented out, so migrating runs nothing). A table
+keyed by `id uuid` whose standard columns match becomes an `entity()` file;
+any other stays the plain `pgTable` pull wrote, which no sync changes. The old
+templates' own tables are left in the database. Before writing, it checks the
+files say exactly what the database has; the next sync then only adds the
+`entity()` columns a table lacks and the SDK's `light_*` tables. It refuses,
+writing nothing, a foreign key into a table it leaves out, or an index with a
+non-default operator class. It reads the tables' keys, which Postgres shows
+only to a role with more than SELECT: an app's reader has REFERENCES for it.
+
 ## Develop
 
 ```bash

package/dist/client.d.ts

@@ -23,8 +23,175 @@ declare function tableClient<T extends Entity>(entity: T): {
     create: (data: NewRow<T>) => Promise<Row<T>>;
     update: (id: string, patch: Patch<T>) => Promise<Row<T>>;
     delete: (id: string) => Promise<void>;
-    /** The rows, cached per options; refetched after any write to this table. */
-    useList: (options?: ListOptions<Row<T>>) => import("@tanstack/react-query").UseQueryResult<(T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never)[], EntityError>;
+    /**
+     * The query (`isPending`, `isError`, `error`, `refetch`) and its `rows`,
+     * cached per options and refetched after any write to this table. `rows`
+     * is never undefined: empty until the first answer, and the same array
+     * until the rows change, so it can sit in a hook's dependencies.
+     */
+    useList: (options?: ListOptions<Row<T>>) => {
+        rows: (T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never)[];
+        data: (T["$inferSelect"] extends infer T_2 ? { [K in keyof T_2]: Date extends T_2[K] ? string | Exclude<T_2[K], T_2[K] & Date> : T_2[K]; } : never)[];
+        error: EntityError;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: true;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: "error";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: EntityError | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_3 ? { [K in keyof T_3]: Date extends T_3[K] ? string | Exclude<T_3[K], T_3[K] & Date> : T_3[K]; } : never)[], EntityError>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_3 ? { [K in keyof T_3]: Date extends T_3[K] ? string | Exclude<T_3[K], T_3[K] & Date> : T_3[K]; } : never)[];
+        data: (T["$inferSelect"] extends infer T_4 ? { [K in keyof T_4]: Date extends T_4[K] ? string | Exclude<T_4[K], T_4[K] & Date> : T_4[K]; } : never)[];
+        error: null;
+        isError: false;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: false;
+        status: "success";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: EntityError | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_5 ? { [K in keyof T_5]: Date extends T_5[K] ? string | Exclude<T_5[K], T_5[K] & Date> : T_5[K]; } : never)[], EntityError>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_5 ? { [K in keyof T_5]: Date extends T_5[K] ? string | Exclude<T_5[K], T_5[K] & Date> : T_5[K]; } : never)[];
+        data: undefined;
+        error: EntityError;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: true;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: "error";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: EntityError | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_6 ? { [K in keyof T_6]: Date extends T_6[K] ? string | Exclude<T_6[K], T_6[K] & Date> : T_6[K]; } : never)[], EntityError>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_6 ? { [K in keyof T_6]: Date extends T_6[K] ? string | Exclude<T_6[K], T_6[K] & Date> : T_6[K]; } : never)[];
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoading: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: "pending";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: EntityError | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_7 ? { [K in keyof T_7]: Date extends T_7[K] ? string | Exclude<T_7[K], T_7[K] & Date> : T_7[K]; } : never)[], EntityError>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_7 ? { [K in keyof T_7]: Date extends T_7[K] ? string | Exclude<T_7[K], T_7[K] & Date> : T_7[K]; } : never)[];
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: "pending";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: EntityError | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isLoading: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_8 ? { [K in keyof T_8]: Date extends T_8[K] ? string | Exclude<T_8[K], T_8[K] & Date> : T_8[K]; } : never)[], EntityError>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_8 ? { [K in keyof T_8]: Date extends T_8[K] ? string | Exclude<T_8[K], T_8[K] & Date> : T_8[K]; } : never)[];
+        data: (T["$inferSelect"] extends infer T_9 ? { [K in keyof T_9]: Date extends T_9[K] ? string | Exclude<T_9[K], T_9[K] & Date> : T_9[K]; } : never)[];
+        isError: false;
+        error: null;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: true;
+        status: "success";
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: EntityError | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_10 ? { [K in keyof T_10]: Date extends T_10[K] ? string | Exclude<T_10[K], T_10[K] & Date> : T_10[K]; } : never)[], EntityError>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    };
     /** One row; `null` waits (nothing open yet). */
     useGet: (id: string | null) => import("@tanstack/react-query").UseQueryResult<T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never, EntityError>;
     useCreate: () => import("@tanstack/react-query").UseMutationResult<T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never, EntityError, NewRow<T>, unknown>;

package/dist/client.js

@@ -17,6 +17,8 @@ export { InvocationError } from "@shubh90/app-runtime/invoke";
 export function createApp() {
     return { table: tableClient, contracts: createInvoker() };
 }
+/** Every list's rows before its first answer: one array, so they never change identity while pending. */
+const NO_ROWS = [];
 /** One entity table's rows: plain calls, and TanStack Query hooks over them. */
 function tableClient(entity) {
     const base = `${ENTITIES_PATH}/${getTableName(entity)}`;
@@ -58,8 +60,19 @@ function tableClient(entity) {
         create,
         update,
         delete: remove,
-        /** The rows, cached per options; refetched after any write to this table. */
-        useList: (options = {}) => useQuery({ queryKey: keys.list(options), queryFn: () => list(options) }),
+        /**
+         * The query (`isPending`, `isError`, `error`, `refetch`) and its `rows`,
+         * cached per options and refetched after any write to this table. `rows`
+         * is never undefined: empty until the first answer, and the same array
+         * until the rows change, so it can sit in a hook's dependencies.
+         */
+        useList: (options = {}) => {
+            const query = useQuery({ queryKey: keys.list(options), queryFn: () => list(options) });
+            const { data: rows = NO_ROWS } = query;
+            // A spread reads every field, so the page re-renders on any of them (isFetching
+            // too); a list page shows those states anyway, and it keeps the result plain.
+            return { ...query, rows };
+        },
         /** One row; `null` waits (nothing open yet). */
         useGet: (id) => useQuery({
             queryKey: keys.get(id),

package/dist/db/baseline.d.ts

@@ -0,0 +1,36 @@
+import { type Snapshot } from "./migrations.js";
+export type Baseline = {
+    /** Each app table written to db/schema as an entity(), with the entity() columns it lacks (the first sync adds them). */
+    tables: {
+        name: string;
+        lacks: string[];
+    }[];
+    /** App tables entity() can't key or say exactly, and why: plain tables in db/schema. */
+    plain: {
+        name: string;
+        why: string;
+    }[];
+    /** Platform tables left as they are. */
+    skipped: string[];
+    /** Other things drizzle-kit found (views, sequences…) that db/schema doesn't hold. */
+    leftOut: string[];
+    /** What the first `light-db sync` will apply. */
+    pending: string[];
+};
+/** Why the database can't become db/schema as it is; nothing was written. */
+export declare class BaselineRefused extends Error {
+}
+export declare function baseline(root: string, databaseUrl: string, schemaModule?: string): Promise<Baseline>;
+/** Runs drizzle-kit pull into a temporary folder: the tables as TypeScript, and drizzle's snapshot of them. */
+export declare function pull(databaseUrl: string): {
+    source: string;
+    snapshot: Snapshot;
+};
+/**
+ * What drizzle-kit pull writes wrong: an empty-string default as `.default(')`,
+ * and a column of a type it can't parse (tsvector, bytea) as `unknown(...)`
+ * under a TODO naming the type, which becomes a custom type of that name.
+ */
+export declare function repairPull(text: string): string;
+/** What a sync would run to make the `live` tables (as pulled) into `recorded`'s; none when they match. */
+export declare function driftFrom(live: Snapshot, recorded: Snapshot): Promise<string[]>;

package/dist/db/baseline.js

@@ -0,0 +1,343 @@
+// `light-db baseline`: an older app's live tables become db/schema. drizzle-kit
+// pull reads the database; each app table becomes a file with its real
+// columns, and a first migration records the tables exactly as they are (its
+// SQL commented out: they already exist). A table entity() can key becomes an
+// entity(), so the next sync adds only the entity() columns it lacks; any
+// other stays the plain table pull wrote, which no sync changes.
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { generateDrizzleJson, generateMigration } from "drizzle-kit/api";
+import postgres from "postgres";
+import { z } from "zod/v4";
+import { getTableName, is } from "drizzle-orm";
+import { PgTable } from "drizzle-orm/pg-core";
+import * as sdkSchema from "../schema.js";
+import { EMPTY_SNAPSHOT, SCHEMA_ENTRY, plan, snapshotSchema, writeMigration } from "./migrations.js";
+/** The SDK's own tables (`lightChanges`, `lightImages`…): every app's db/schema exports them. */
+const SDK_TABLES = Object.entries(sdkSchema).flatMap(([name, value]) => (is(value, PgTable) ? [{ name, table: getTableName(value) }] : []));
+/**
+ * Tables the platform keeps rather than the app: app-runtime's sign-in, the
+ * Vite template's AI actions (record jobs, AI searches, intro bans), image
+ * copies and migration log (org-app-template-vite/migrations), the Next.js
+ * template's settings, analytics and migration log, and v2's archive and SDK
+ * tables. Baseline leaves them in the database as they are.
+ */
+const PLATFORM_TABLES = [
+    "mii_auth_users",
+    "mii_auth_sessions",
+    "record_jobs",
+    "ai_searches",
+    "excluded_people",
+    "mii_images",
+    "_migrations",
+    "app_migrations",
+    "app_settings",
+    "analytics_events",
+    "event_coverage",
+    "person_aliases",
+    "light_archive",
+    ...SDK_TABLES.map((sdk) => sdk.table)
+];
+/** What every table baseline writes lets through `app.table(...)`; the agent narrows it per table. */
+const ACCESS = '{ read: "door", write: "door" }';
+/** Why the database can't become db/schema as it is; nothing was written. */
+export class BaselineRefused extends Error {
+}
+const pulledColumn = z.looseObject({ type: z.string(), primaryKey: z.boolean() });
+const pulledTable = z.looseObject({
+    name: z.string(),
+    schema: z.string(),
+    columns: z.record(z.string(), pulledColumn),
+    compositePrimaryKeys: z.record(z.string(), z.looseObject({ columns: z.array(z.string()) })),
+    foreignKeys: z.record(z.string(), z.looseObject({ tableTo: z.string(), columnsFrom: z.array(z.string()) }))
+});
+const pulledTables = z.record(z.string(), pulledTable);
+/** `export const <name> = <kind>("<dbName>"`, the head of each declaration drizzle-kit pull writes. */
+const DECLARATION = /^export const (\w+) = (\w+)\("([^"]+)"/;
+const declarationParts = z.tuple([z.string(), z.string(), z.string()]);
+export async function baseline(root, databaseUrl, schemaModule = "@trylight/app/schema") {
+    const dbDir = join(root, "db");
+    if (existsSync(dbDir)) {
+        throw new BaselineRefused("db/ already exists. Baseline writes db/schema and db/migrations from the database, once; move db/ aside first.");
+    }
+    const pulled = pull(databaseUrl);
+    const { specialOpclasses, hiddenKeys } = await catalogFacts(databaseUrl);
+    if (hiddenKeys.length > 0) {
+        throw new BaselineRefused(`The database role baseline reads with can't see the keys of ${hiddenKeys.join(", ")}: Postgres shows them only to a role with REFERENCES (or more) on the table, ` +
+            "which the platform grants an app's reader (scripts/grant-reader-references.ts). Nothing was written.");
+    }
+    const live = pulledTables.parse(pulled.snapshot.tables);
+    const declarations = pulled.source.split(/\n(?=export const )/).slice(1).map(readDeclaration);
+    const tables = declarations.filter((d) => d.kind === "pgTable" && !PLATFORM_TABLES.includes(d.dbName));
+    const enums = declarations.filter((d) => d.kind === "pgEnum");
+    const skipped = declarations.filter((d) => d.kind === "pgTable" && PLATFORM_TABLES.includes(d.dbName)).map((d) => d.dbName);
+    const leftOut = declarations.filter((d) => d.kind !== "pgTable" && d.kind !== "pgEnum").map((d) => `${d.dbName} (${d.kind})`);
+    const standard = await standardSnapshot();
+    const judged = await Promise.all(tables.map((table) => entityMisfit(liveTable(live, table.dbName), standard).then((why) => ({ name: table.dbName, why }))));
+    const plain = judged.flatMap(({ name, why }) => (why === null ? [] : [{ name, why }]));
+    const entities = new Set(judged.filter(({ why }) => why === null).map(({ name }) => name));
+    const refusals = [
+        ...tables.flatMap((table) => refusalsFor(liveTable(live, table.dbName))),
+        ...specialOpclasses
+            .filter((index) => tables.some((table) => table.dbName === index.table))
+            .map((index) => `- ${index.table}: index ${index.index} uses operator class ${index.opclass}, which db/schema can't carry (drizzle-kit reads index operator classes wrongly). ` +
+            "Recreate it without one in the old app's own migrations (the CLI's `app migrate` applies them), or leave it out and add it back in db/schema after the move, then run baseline again.")
+    ];
+    if (refusals.length > 0) {
+        throw new BaselineRefused(`These tables can't go into db/schema as they are; nothing was written:\n${refusals.join("\n")}`);
+    }
+    const pgCore = importedNames(pulled.source);
+    mkdirSync(join(root, "db", "schema"), { recursive: true });
+    try {
+        for (const table of tables) {
+            const file = tableFile(table, liveTable(live, table.dbName), entities.has(table.dbName), { pgCore, tables, enums, schemaModule });
+            writeFileSync(join(root, "db", "schema", `${table.dbName}.ts`), file);
+        }
+        if (enums.length > 0) {
+            writeFileSync(join(root, "db", "schema", "enums.ts"), enumsFile(enums));
+        }
+        writeFileSync(join(root, SCHEMA_ENTRY), indexFile(tables, enums.length > 0, schemaModule));
+        const schema = await import(pathToFileURL(join(root, SCHEMA_ENTRY)).href);
+        const full = snapshotSchema.parse(JSON.parse(JSON.stringify(generateDrizzleJson(schema, EMPTY_SNAPSHOT.id))));
+        const recorded = asTheyAre(full, live);
+        // What entity() says must be exactly what the database has.
+        const drift = await driftFrom(pulled.snapshot, recorded);
+        if (drift.length > 0) {
+            throw new BaselineRefused(`db/schema can't say these tables exactly as the database has them; nothing was written. A sync would run:\n${drift.join("\n")}\n` +
+                "Change them in the old app's own migrations (the CLI's `app migrate` applies them) so they fit, then run baseline again.");
+        }
+        const created = await generateMigration(EMPTY_SNAPSHOT, recorded);
+        const commented = [
+            "-- light-db baseline: the app's tables as they were when it moved to db/schema.",
+            "-- They already exist, so nothing here runs; the schema's history starts from them.",
+            ...created.join("\n").split("\n").map((line) => `-- ${line}`)
+        ].join("\n");
+        writeMigration(root, { statements: [commented], archive: [], snapshot: recorded }, "baseline");
+        const pending = await plan(root, schema);
+        return {
+            tables: tables
+                .filter((table) => entities.has(table.dbName))
+                .map((table) => ({ name: table.dbName, lacks: lacking(liveTable(live, table.dbName)) })),
+            plain,
+            skipped,
+            leftOut,
+            pending: pending.statements
+        };
+    }
+    catch (error) {
+        rmSync(dbDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+/** What pull can't tell: indexes with a non-default operator class, and tables whose keys this role can't see. */
+async function catalogFacts(databaseUrl) {
+    const sql = postgres(databaseUrl, { max: 1, onnotice: () => undefined });
+    try {
+        const specialOpclasses = await sql `
+      select t.relname as table, i.relname as index, o.opcname as opclass
+      from pg_index x
+      join pg_class i on i.oid = x.indexrelid
+      join pg_class t on t.oid = x.indrelid
+      join pg_namespace n on n.oid = t.relnamespace
+      cross join lateral unnest(x.indclass::oid[]) as c(oid)
+      join pg_opclass o on o.oid = c.oid
+      where n.nspname = 'public' and not o.opcdefault`;
+        const hidden = await sql `
+      select c.relname as table from pg_class c join pg_namespace n on n.oid = c.relnamespace
+      where n.nspname = 'public' and c.relkind in ('r', 'p') and not has_table_privilege(c.oid, 'REFERENCES')
+      order by 1`;
+        return { specialOpclasses, hiddenKeys: hidden.map((row) => row.table) };
+    }
+    finally {
+        await sql.end();
+    }
+}
+/** Runs drizzle-kit pull into a temporary folder: the tables as TypeScript, and drizzle's snapshot of them. */
+export function pull(databaseUrl) {
+    const dir = mkdtempSync(join(tmpdir(), "light-db-baseline-"));
+    try {
+        const settings = { dialect: "postgresql", out: "./out", schemaFilter: ["public"], introspect: { casing: "preserve" } };
+        const config = join(dir, "drizzle.config.mjs");
+        // The URL stays in the environment, out of the file and the process list.
+        writeFileSync(config, `export default { ...${JSON.stringify(settings)}, dbCredentials: { url: process.env.DATABASE_URL } };\n`);
+        const drizzleKit = join(dirname(fileURLToPath(import.meta.resolve("drizzle-kit"))), "bin.cjs");
+        const run = spawnSync(process.execPath, [drizzleKit, "pull", "--config", config], {
+            cwd: dir,
+            env: { ...process.env, DATABASE_URL: databaseUrl },
+            encoding: "utf8"
+        });
+        const out = join(dir, "out");
+        if (run.status !== 0 || !existsSync(join(out, "schema.ts"))) {
+            throw new Error(`drizzle-kit pull failed:\n${run.stdout}${run.stderr}`);
+        }
+        const [snapshotName] = readdirSync(join(out, "meta")).filter((file) => file.endsWith("_snapshot.json"));
+        if (snapshotName === undefined)
+            throw new Error(`drizzle-kit pull wrote no snapshot:\n${run.stdout}`);
+        return {
+            source: readFileSync(join(out, "schema.ts"), "utf8"),
+            snapshot: snapshotSchema.parse(JSON.parse(readFileSync(join(out, "meta", snapshotName), "utf8")))
+        };
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+function readDeclaration(text) {
+    const match = DECLARATION.exec(text);
+    if (match === null)
+        throw new Error(`drizzle-kit pull wrote a declaration baseline can't read:\n${text}`);
+    const [name, kind, dbName] = declarationParts.parse(match.slice(1));
+    return { name, kind, dbName, text: text.trimEnd() };
+}
+function liveTable(live, name) {
+    const table = live[`public.${name}`];
+    if (table === undefined)
+        throw new Error(`drizzle-kit pull wrote ${name} without its snapshot.`);
+    return table;
+}
+function refusalsFor(table) {
+    return Object.values(table.foreignKeys)
+        .filter((key) => PLATFORM_TABLES.includes(key.tableTo))
+        .map((key) => `- ${table.name}.${key.columnsFrom.join(", ")} references ${key.tableTo}, a platform table db/schema doesn't hold. ` +
+        "Drop that foreign key in the old app's own migrations (the CLI's `app migrate` applies them; the column and its values stay), then run baseline again.");
+}
+/** The standard columns as entity() declares them, in drizzle-kit's snapshot form. */
+async function standardSnapshot() {
+    const probe = { probe: sdkSchema.entity("probe", {}, { read: "door", write: "door" }) };
+    const snapshot = snapshotSchema.parse(JSON.parse(JSON.stringify(generateDrizzleJson(probe, EMPTY_SNAPSHOT.id))));
+    const table = snapshot.tables["public.probe"];
+    if (table === undefined)
+        throw new Error("drizzle-kit wrote no snapshot of entity()'s columns.");
+    return table;
+}
+/**
+ * Why entity() can't say this table, or null when it can: it needs a lone
+ * `id uuid` key, and each standard column it already has exactly as entity()
+ * declares it (a sync would otherwise change it).
+ */
+async function entityMisfit(table, standard) {
+    const id = table.columns.id;
+    if (id === undefined || id.type !== "uuid" || !id.primaryKey || Object.keys(table.compositePrimaryKeys).length > 0) {
+        return "not keyed by a lone `id uuid` primary key";
+    }
+    const shared = sdkSchema.STANDARD_COLUMNS.filter((column) => column in table.columns);
+    const only = (columns) => ({
+        "public.probe": { ...standard, columns: Object.fromEntries(shared.map((column) => [column, columns[column]])) }
+    });
+    const changes = await generateMigration({ ...EMPTY_SNAPSHOT, tables: only(table.columns) }, { ...EMPTY_SNAPSHOT, tables: only(standard.columns) });
+    if (changes.length === 0)
+        return null;
+    return `entity() would change it: ${changes.map((change) => change.replaceAll('"probe"', `"${table.name}"`)).join(" ")}`;
+}
+/** The entity() columns a live table doesn't have yet. */
+function lacking(table) {
+    return sdkSchema.STANDARD_COLUMNS.filter((column) => !(column in table.columns));
+}
+/** The names drizzle-kit pull imported from pg-core. */
+function importedNames(source) {
+    const match = /^import \{ ([^}]+) \} from "drizzle-orm\/pg-core"/m.exec(source);
+    if (match === null)
+        throw new Error(`drizzle-kit pull wrote no pg-core import baseline can read:\n${source}`);
+    return z.string().parse(match[1]).split(",").map((name) => name.trim());
+}
+const uses = (text, name, after) => new RegExp(`\\b${name}${after}`).test(text);
+/**
+ * One pulled `pgTable` as a db/schema file: an `entity()` (which declares its
+ * standard columns itself) when it fits one, else the table as pulled.
+ */
+function tableFile(table, live, asEntity, context) {
+    const standard = new RegExp(`^\\t(${sdkSchema.STANDARD_COLUMNS.join("|")}): `);
+    const lines = repairPull(table.text)
+        .split("\n")
+        .filter((line) => !asEntity || !standard.test(line))
+        // pull names each index column's operator class, often the wrong one; baseline refused any that isn't the default.
+        .map((line) => (line.includes('.using("btree"') ? line.replace(/\.op\("[^"]*"\)/g, "") : line));
+    let body = lines.join("\n");
+    if (asEntity) {
+        body = body.replace(`= pgTable("${table.dbName}", {`, `= entity("${table.dbName}", {`);
+        body = body.endsWith("\n});")
+            ? `${body.slice(0, -"\n});".length)}\n}, ${ACCESS});`
+            : body.replace("\n}, (table) => [", `\n}, ${ACCESS}, (table) => [`);
+        if (!body.includes(ACCESS))
+            throw new Error(`drizzle-kit pull wrote ${table.dbName} in a shape baseline can't read:\n${table.text}`);
+    }
+    const pgCore = [...context.pgCore, "customType"].filter((name) => uses(body, name, "[<(]"));
+    const referenced = new Set(Object.values(live.foreignKeys).map((key) => key.tableTo));
+    const others = context.tables.filter((other) => other !== table && referenced.has(other.dbName));
+    const types = new Set(Object.values(live.columns).map((column) => column.type));
+    const enums = context.enums.filter((e) => types.has(e.dbName));
+    return [
+        ...(asEntity ? [`import { entity } from "${context.schemaModule}";`] : []),
+        ...(pgCore.length > 0 ? [`import { ${pgCore.join(", ")} } from "drizzle-orm/pg-core";`] : []),
+        ...(uses(body, "sql", "`") ? ['import { sql } from "drizzle-orm";'] : []),
+        ...(enums.length > 0 ? [`import { ${enums.map((e) => e.name).join(", ")} } from "./enums";`] : []),
+        ...others.map((other) => `import { ${other.name} } from "./${other.dbName}";`),
+        "",
+        body,
+        ""
+    ].join("\n");
+}
+/**
+ * What drizzle-kit pull writes wrong: an empty-string default as `.default(')`,
+ * and a column of a type it can't parse (tsvector, bytea) as `unknown(...)`
+ * under a TODO naming the type, which becomes a custom type of that name.
+ */
+export function repairPull(text) {
+    return text
+        .replaceAll(".default(')", '.default("")')
+        .replace(/\t\/\/ TODO: failed to parse database type '([^']+)'\n(\t\w+: )unknown\(/g, (_, type, column) => `${column}customType<{ data: unknown }>({ dataType: () => ${JSON.stringify(type)} })(`);
+}
+function enumsFile(enums) {
+    return ['import { pgEnum } from "drizzle-orm/pg-core";', "", ...enums.map((e) => e.text), ""].join("\n");
+}
+function indexFile(tables, hasEnums, schemaModule) {
+    return [
+        "// The app's tables: one file per table in this folder, each exported here.",
+        "// Writing a file here is the migration (see AGENTS.md).",
+        `export { ${SDK_TABLES.map((sdk) => sdk.name).join(", ")} } from "${schemaModule}";`,
+        ...(hasEnums ? ['export * from "./enums";'] : []),
+        ...tables.map((table) => `export * from "./${table.dbName}";`),
+        ""
+    ].join("\n");
+}
+/** The schema's snapshot as the database has it: its app tables, less the entity() columns they lack. */
+function asTheyAre(full, live) {
+    const tables = {};
+    for (const [key, table] of Object.entries(full.tables)) {
+        const now = live[key];
+        if (now === undefined)
+            continue;
+        tables[key] = { ...table, columns: Object.fromEntries(Object.entries(table.columns).filter(([column]) => column in now.columns)) };
+    }
+    return { ...full, tables };
+}
+/** What a sync would run to make the `live` tables (as pulled) into `recorded`'s; none when they match. */
+export function driftFrom(live, recorded) {
+    return generateMigration(comparable(live, recorded), comparable(recorded, recorded));
+}
+/**
+ * A snapshot with only what db/schema holds (`recorded`'s tables and enums),
+ * btree operator classes aside: pull misreads them, and the default is what
+ * the files say.
+ */
+function comparable(snapshot, recorded) {
+    const tables = {};
+    for (const key of Object.keys(recorded.tables)) {
+        const table = snapshot.tables[key];
+        if (table === undefined)
+            throw new Error(`${key} is in db/schema but not in the database drizzle-kit read.`);
+        tables[key] = { ...table, indexes: Object.fromEntries(Object.entries(table.indexes).map(([name, index]) => [name, withoutBtreeOpclass(index)])) };
+    }
+    return { ...snapshot, tables, schemas: {}, sequences: {}, roles: {}, policies: {}, views: {} };
+}
+const btreeIndex = z.looseObject({ method: z.literal("btree"), columns: z.array(z.record(z.string(), z.unknown())) });
+function withoutBtreeOpclass(index) {
+    const parsed = btreeIndex.safeParse(index);
+    if (!parsed.success)
+        return index;
+    const columns = parsed.data.columns.map((column) => Object.fromEntries(Object.entries(column).filter(([key]) => key !== "opclass")));
+    return { ...parsed.data, columns };
+}

package/dist/db/cli.js

@@ -1,5 +1,6 @@
 // `light-db sync`, `light-db migrate`, `light-db check`: the
-// app's `pnpm db:*` scripts. Run from the app's root.
+// app's `pnpm db:*` scripts; `light-db baseline` moves an older app's tables
+// under db/schema, once. Run from the app's root.
 import { existsSync } from "node:fs";
 import { request } from "node:http";
 import { userInfo } from "node:os";
@@ -10,6 +11,7 @@ import { migrate } from "drizzle-orm/postgres-js/migrator";
 import postgres from "postgres";
 import { z } from "zod/v4";
 import { archiveNotices, entityTables, prepareAudit, trackTables } from "./audit.js";
+import { BaselineRefused, baseline as writeBaseline } from "./baseline.js";
 import { MIGRATIONS_DIR, SCHEMA_ENTRY, plan, unwriteMigration, writeMigration } from "./migrations.js";
 import { env } from "../server/env.js";
 /**
@@ -125,7 +127,42 @@ async function migrateThroughPlatform() {
     process.stdout.write(reply.output);
     return reply.code;
 }
+/** Writes db/schema and a first migration from the live tables of an app made before db/schema. */
+async function baseline() {
+    const { databaseUrl } = env();
+    if (databaseUrl === undefined)
+        throw new Error("DATABASE_URL is not set: baseline reads the app's database.");
+    let written;
+    try {
+        written = await writeBaseline(root, databaseUrl);
+    }
+    catch (error) {
+        if (!(error instanceof BaselineRefused))
+            throw error;
+        console.error(error.message);
+        return 1;
+    }
+    console.log(`Wrote db/schema from the database, and ${MIGRATIONS_DIR}/0000_baseline.sql recording its tables as they are:`);
+    for (const table of written.tables) {
+        const lacks = table.lacks.length > 0 ? ` (lacks ${table.lacks.join(", ")}; the first sync adds them)` : "";
+        console.log(`  db/schema/${table.name}.ts${lacks}`);
+    }
+    console.log('Every entity is { read: "door", write: "door" }; make one `write: "agents"` if only agents fill it.');
+    if (written.plain.length > 0) {
+        console.log("Plain tables (no sync changes them; app.table can't serve them):");
+        for (const table of written.plain)
+            console.log(`  db/schema/${table.name}.ts: ${table.why}`);
+    }
+    if (written.skipped.length > 0)
+        console.log(`Skipped, the platform's own tables: ${written.skipped.join(", ")}.`);
+    if (written.leftOut.length > 0)
+        console.log(`Left in the database, not in db/schema: ${written.leftOut.join(", ")}.`);
+    console.log(written.pending.length === 0
+        ? "`pnpm db:sync` has nothing to change."
+        : `\`pnpm db:sync\` will only add this; nothing already there changes:\n${written.pending.join("\n")}`);
+    return 0;
+}
 // Last, so every const above is initialized before a command reads it.
-const commands = { sync, migrate: applyMigrations, check };
-const usage = z.enum(["sync", "migrate", "check"], { error: "Usage: light-db sync | migrate | check" });
+const commands = { sync, migrate: applyMigrations, check, baseline };
+const usage = z.enum(["sync", "migrate", "check", "baseline"], { error: "Usage: light-db sync | migrate | check | baseline" });
 process.exit(await commands[usage.parse(command)]());

package/dist/db/migrations.d.ts

@@ -10,7 +10,7 @@ export type Plan = {
     snapshot: Snapshot;
 };
 /** The parts of a drizzle-kit snapshot a removal touches; the rest passes through. */
-declare const snapshotSchema: z.ZodObject<{
+export declare const snapshotSchema: z.ZodObject<{
     id: z.ZodString;
     tables: z.ZodRecord<z.ZodString, z.ZodObject<{
         columns: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -28,7 +28,7 @@ declare const snapshotSchema: z.ZodObject<{
     policies: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     views: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$loose>;
-type Snapshot = z.infer<typeof snapshotSchema>;
+export type Snapshot = z.infer<typeof snapshotSchema>;
 /**
  * What `db/schema` needs beyond the last migration, in three diffs that each
  * only remove or only add, so drizzle-kit never has to ask whether something
@@ -37,11 +37,11 @@ type Snapshot = z.infer<typeof snapshotSchema>;
  * after the columns that used them have changed.
  */
 export declare function plan(root: string, schema: Record<string, unknown>): Promise<Plan>;
+export declare const EMPTY_SNAPSHOT: Snapshot;
 /**
  * Writes the plan as the next migration, in drizzle-kit's own layout (the
  * SQL, its snapshot, the journal entry), so drizzle's migrator applies it.
  */
-export declare function writeMigration(root: string, planned: Plan): string;
+export declare function writeMigration(root: string, planned: Plan, name?: string): string;
 /** Takes back the newest migration, one that didn't apply, so the schema's change is pending again. */
 export declare function unwriteMigration(root: string, tag: string): void;
-export {};

package/dist/db/migrations.js

@@ -12,7 +12,7 @@ export const SCHEMA_ENTRY = "db/schema/index.ts";
 export const MIGRATIONS_DIR = "db/migrations";
 const entries = z.record(z.string(), z.unknown());
 /** The parts of a drizzle-kit snapshot a removal touches; the rest passes through. */
-const snapshotSchema = z.looseObject({
+export const snapshotSchema = z.looseObject({
     id: z.string(),
     tables: z.record(z.string(), z.looseObject({
         columns: entries,
@@ -102,7 +102,7 @@ const journalSchema = z.object({
         breakpoints: z.boolean()
     }))
 });
-const EMPTY_SNAPSHOT = {
+export const EMPTY_SNAPSHOT = {
     version: "7",
     dialect: "postgresql",
     id: "00000000-0000-0000-0000-000000000000",
@@ -135,10 +135,10 @@ function latestSnapshot(root) {
  * Writes the plan as the next migration, in drizzle-kit's own layout (the
  * SQL, its snapshot, the journal entry), so drizzle's migrator applies it.
  */
-export function writeMigration(root, planned) {
+export function writeMigration(root, planned, name = "schema") {
     const journal = readJournal(root);
     const idx = journal.entries.length;
-    const tag = `${String(idx).padStart(4, "0")}_schema`;
+    const tag = `${String(idx).padStart(4, "0")}_${name}`;
     mkdirSync(join(root, MIGRATIONS_DIR, "meta"), { recursive: true });
     const statements = [...archiveStatements(planned.archive, tag), ...planned.statements];
     writeFileSync(join(root, MIGRATIONS_DIR, `${tag}.sql`), statements.join("\n--> statement-breakpoint\n") + "\n");

package/dist/platform.js

@@ -1,5 +1,5 @@
 // The platform contract a page and the global middleware need: framing by
-// Plaza's App pane, the server-function door, analytics and error policies,
+// the platform's App pane, the server-function door, analytics and error policies,
 // and the pane bridge. Behaviour lives in @shubh90/app-runtime.
 export { FRAME_ANCESTORS, isAgentBrowser, mayCallServerFn, miiAnalyticsPolicy, miiErrorPolicy, PLAZA_FRAME_ORIGINS } from "@shubh90/app-runtime/platform";
 export { MiiPaneBridge } from "@shubh90/app-runtime/react";

package/dist/schema.d.ts

@@ -36,6 +36,8 @@ declare function standardColumns(): {
     }>>>>>;
 };
 type StandardColumns = ReturnType<typeof standardColumns>;
+/** The columns `entity()` adds to every table, by name. */
+export declare const STANDARD_COLUMNS: readonly string[];
 /** The columns the platform sets, as a zod omit mask: never in a create or update. */
 export declare const PLATFORM_COLUMNS: {
     id: true;

package/dist/schema.js

@@ -32,6 +32,8 @@ function standardColumns() {
         field_sources: jsonb().$type().notNull().default({})
     };
 }
+/** The columns `entity()` adds to every table, by name. */
+export const STANDARD_COLUMNS = Object.keys(standardColumns());
 /** The columns the platform sets, as a zod omit mask: never in a create or update. */
 export const PLATFORM_COLUMNS = {
     id: true,

package/dist/server/entities.js

@@ -37,11 +37,11 @@ export function createEntitiesHandler(options) {
         .map((entity) => [getTableName(entity), tableRules(entity)]));
     return async (request) => {
         const url = new URL(request.url);
-        // Every org app shares one site (*.miis.run): only this app's pages may use it.
+        // Every org app shares one site (*.<domain>): only this app's pages may use it.
         if (!isSameOrigin(request, url)) {
             return refuse(403, "cross_site", "Only this app's own pages can use its data.");
         }
-        // No Plaza to sign in with: only a bare local dev server serves (as the
+        // No platform to sign in with: only a bare local dev server serves (as the
         // local developer). A deployment or a sandbox missing its sign-in config serves nothing.
         const { configured, local } = env();
         if (!configured && !local) {

package/dist/server/env.d.ts

@@ -2,10 +2,10 @@
 export declare function env(): {
     databaseUrl: string | undefined;
     unpooledDatabaseUrl: string | undefined;
-    /** Sign-in needs Plaza, this app's id in it, and a database for sessions. */
+    /** Sign-in needs the platform, this app's id in it, and a database for sessions. */
     configured: boolean;
     /**
-     * A bare local dev server: no Plaza and no app id at all (the platform
+     * A bare local dev server: no platform and no app id at all (the platform
      * gives every sandbox and deployment its MII_APP_ID), and not production.
      */
     local: boolean;

package/dist/server/env.js

@@ -13,10 +13,10 @@ const serverEnv = z
     .transform((env) => ({
     databaseUrl: env.DATABASE_URL,
     unpooledDatabaseUrl: env.DATABASE_URL_UNPOOLED,
-    /** Sign-in needs Plaza, this app's id in it, and a database for sessions. */
+    /** Sign-in needs the platform, this app's id in it, and a database for sessions. */
     configured: Boolean(env.MII_PLAZA_URL && env.MII_APP_ID && env.DATABASE_URL),
     /**
-     * A bare local dev server: no Plaza and no app id at all (the platform
+     * A bare local dev server: no platform and no app id at all (the platform
      * gives every sandbox and deployment its MII_APP_ID), and not production.
      */
     local: !env.MII_PLAZA_URL && !env.MII_APP_ID && env.NODE_ENV !== "production"

package/dist/server/index.d.ts

@@ -12,7 +12,7 @@ export declare function createLightServer<S extends Record<string, unknown>, C e
     session: (request: Request) => Promise<import("./session.js").SessionState>;
     /** Whether sign-in is configured (a bare local dev server has none). */
     configured: () => boolean;
-    /** Email and password, checked by Plaza; the session to set as a cookie, or why not. */
+    /** Email and password, checked by the platform; the session to set as a cookie, or why not. */
     signIn: (email: string, password: string) => Promise<import("./session.js").SignIn>;
     /** The app's database, typed by its schema: `light.db.select().from(companies)`. */
     readonly db: PostgresJsDatabase<S>;
@@ -22,7 +22,7 @@ export declare function createLightServer<S extends Record<string, unknown>, C e
     image: (request: Request) => Promise<Response>;
     /** Server-side starts and reads of the app's contracts. */
     invoke: import("@shubh90/app-runtime/invoke/server").MiiInvoke<C>;
-    /** `/api/mii/invoke/*`: the contract buttons, forwarded to Plaza as the person. */
+    /** `/api/mii/invoke/*`: the contract buttons, forwarded to the platform as the person. */
     invokeRoute: (request: Request) => Promise<Response>;
     /** `/api/mii/chat/*`: the chat bubble's calls to the org's agents. */
     chatRoute: (request: Request) => Promise<Response>;

package/dist/server/index.js

@@ -1,5 +1,5 @@
 // The app's server half, bound once in `src/server/light.ts`: its database,
-// its door (sign-in through Plaza), and the routes the SDK serves (entities,
+// its door (sign-in through the platform), and the routes the SDK serves (entities,
 // images, contracts, chat). Server-only.
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
@@ -35,7 +35,7 @@ export function createLightServer(options) {
         session,
         /** Whether sign-in is configured (a bare local dev server has none). */
         configured: () => env().configured,
-        /** Email and password, checked by Plaza; the session to set as a cookie, or why not. */
+        /** Email and password, checked by the platform; the session to set as a cookie, or why not. */
         signIn: (email, password) => signIn(auth, email, password),
         /** The app's database, typed by its schema: `light.db.select().from(companies)`. */
         get db() {
@@ -47,13 +47,13 @@ export function createLightServer(options) {
         image: createImageHandler({ db, session }),
         /** Server-side starts and reads of the app's contracts. */
         invoke,
-        /** `/api/mii/invoke/*`: the contract buttons, forwarded to Plaza as the person. */
+        /** `/api/mii/invoke/*`: the contract buttons, forwarded to the platform as the person. */
         invokeRoute: needsSignIn(invoke.handler),
         /** `/api/mii/chat/*`: the chat bubble's calls to the org's agents. */
         chatRoute: needsSignIn(chat)
     };
 }
-/** A route that forwards to Plaza as the person: nothing to forward without sign-in. */
+/** A route that forwards to the platform as the person: nothing to forward without sign-in. */
 function needsSignIn(handler) {
     return (request) => env().configured
         ? handler(request)

package/dist/server/session.d.ts

@@ -14,5 +14,5 @@ export type SignIn = {
     ok: false;
     message: string;
 };
-/** The login form's whole job: Plaza checks the password, the app starts a session. */
+/** The login form's whole job: the platform checks the password, the app starts a session. */
 export declare function signIn(auth: MiiAuthCore, email: string, password: string): Promise<SignIn>;

package/dist/server/session.js

@@ -1,10 +1,10 @@
-// Who is asking, as the app's door sees it, and signing in through Plaza.
+// Who is asking, as the app's door sees it, and signing in through the platform.
 import { signInWithPlaza } from "@shubh90/app-runtime/auth/core";
 import { readCookie } from "@shubh90/app-runtime/chat/server";
 import { env } from "./env.js";
 /** The session a request's cookie names, and whether the app is members-only. */
 export async function readSession(auth, request) {
-    // No Plaza to sign in with: a bare local dev server has no door; any other
+    // No platform to sign in with: a bare local dev server has no door; any other
     // server without its sign-in config keeps the door shut.
     const { configured, local } = env();
     if (!configured)
@@ -13,14 +13,14 @@ export async function readSession(auth, request) {
     let found = null;
     if (token !== null)
         found = await auth.resolveSession(token);
-    // Plaza unreachable on a cold start throws: an error page, not a door that guesses.
+    // The platform unreachable on a cold start throws: an error page, not a door that guesses.
     const mode = await auth.getAuthMode();
     if (found === null)
         return { user: null, mode };
     const { id, name, email, avatarUrl, role } = found;
     return { user: { id, name, email, avatarUrl, role }, mode };
 }
-/** The login form's whole job: Plaza checks the password, the app starts a session. */
+/** The login form's whole job: the platform checks the password, the app starts a session. */
 export async function signIn(auth, email, password) {
     if (!env().configured)
         return { ok: false, message: "Sign-in is not configured." };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trylight/app",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "The Light SDK every v2 org app depends on: entities (Drizzle tables with a typed client), sign-in, contracts and in-app chat.",
   "license": "UNLICENSED",
   "type": "module",
@@ -12,6 +12,7 @@
     "url": "https://github.com/shubh9/mii.git",
     "directory": "packages/light-app"
   },
+  "packageManager": "pnpm@11.0.9",
   "files": [
     "dist",
     "bin"
@@ -41,6 +42,14 @@
       "default": "./dist/vite.js"
     }
   },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src test --max-warnings 0",
+    "test": "node --test --import tsx \"test/**/*.test.ts\"",
+    "check": "pnpm run typecheck && pnpm run lint && pnpm run test && pnpm run build",
+    "prepack": "pnpm run build"
+  },
   "peerDependencies": {
     "@tanstack/react-query": ">=5.69",
     "drizzle-orm": ">=0.45",
@@ -63,6 +72,7 @@
     "@tanstack/react-query": "^5.104.0",
     "@types/node": "^22.20.4",
     "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
     "drizzle-orm": "^0.45.3",
     "eslint": "^10.11.0",
     "postgres": "^3.4.9",
@@ -72,12 +82,5 @@
     "typescript-eslint": "^8.70.1",
     "vite": "^8.2.0",
     "zod": "^4.6.5"
-  },
-  "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src test --max-warnings 0",
-    "test": "node --test --import tsx \"test/**/*.test.ts\"",
-    "check": "pnpm run typecheck && pnpm run lint && pnpm run test && pnpm run build"
   }
-}
+}