@trylight/app 0.1.8 → 0.2.0

package/dist/server/index.js

@@ -3,16 +3,17 @@
 // images, contracts, chat). Server-only.
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
-import { createMiiAuthCore } from "@shubh90/app-runtime/auth/core";
-import { createMiiChatHandler } from "@shubh90/app-runtime/chat/server";
-import { createMiiInvoke } from "@shubh90/app-runtime/invoke/server";
+import { createMiiAuthCore } from "../auth/core.js";
+import { createMiiChatHandler } from "../chat/server.js";
+import { createMiiInvoke } from "../invoke/server.js";
 import { createEntitiesHandler } from "./entities.js";
 import { env } from "./env.js";
 import { createImageHandler } from "./images.js";
 import { readSession, signIn } from "./session.js";
-export { cookieAttributes, safeNext, SESSION_COOKIE } from "@shubh90/app-runtime/auth/core";
-export { defineContracts, InvocationError } from "@shubh90/app-runtime/invoke/server";
-export { createHealthHandler, createSentryTunnelHandler } from "@shubh90/app-runtime/server";
+export { cookieAttributes, safeNext, SESSION_COOKIE } from "../auth/core.js";
+export { defineContracts, InvocationError } from "../invoke/server.js";
+export { createHealthHandler } from "./health.js";
+export { createSentryTunnelHandler } from "./sentry-tunnel.js";
 /** Connections one server process holds open to the app's database. */
 const POOL_MAX = 5;
 export function createLightServer(options) {

package/dist/server/sentry-tunnel.d.ts

@@ -0,0 +1,6 @@
+export type SentryTunnelOptions = {
+    /** Test hook; defaults to global fetch. */
+    readonly fetch?: typeof fetch;
+};
+/** POST for /monitoring: forward the envelope, answer what Sentry answered. */
+export declare function createSentryTunnelHandler({ fetch: doFetch }?: SentryTunnelOptions): (request: Request) => Promise<Response>;

package/dist/server/sentry-tunnel.js

@@ -0,0 +1,52 @@
+// The Sentry tunnel: browsers post error envelopes to this app's own
+// /monitoring route, which forwards them to Sentry — because ad-blockers
+// block *.sentry.io from the browser, and a platform whose error reporting
+// dies to a browser extension is blind exactly where it matters.
+//
+// The envelope's own header names the DSN, so the route needs no
+// configuration; it forwards only to hosts that are plainly Sentry's, so an
+// app cannot be turned into an open relay by a crafted envelope.
+import { z } from "zod/v4";
+const ALLOWED_HOST = /(^|\.)(sentry\.io|ingest\.sentry\.io|ingest\.[a-z0-9-]+\.sentry\.io)$/;
+/** The envelope's header line: the DSN it is for, whatever else it says. */
+const envelopeHeader = z.object({ dsn: z.string() });
+/** POST for /monitoring: forward the envelope, answer what Sentry answered. */
+export function createSentryTunnelHandler({ fetch: doFetch = fetch } = {}) {
+    return async function tunnel(request) {
+        const envelope = await request.text();
+        const newline = envelope.indexOf("\n");
+        const headerLine = newline === -1 ? envelope : envelope.slice(0, newline);
+        let parsed;
+        try {
+            parsed = JSON.parse(headerLine);
+        }
+        catch {
+            return Response.json({ error: "Not a Sentry envelope." }, { status: 400 });
+        }
+        const header = envelopeHeader.safeParse(parsed);
+        if (!header.success) {
+            return Response.json({ error: "Envelope names no DSN." }, { status: 400 });
+        }
+        let dsn;
+        try {
+            dsn = new URL(header.data.dsn);
+        }
+        catch {
+            return Response.json({ error: "Not a Sentry envelope." }, { status: 400 });
+        }
+        if (!ALLOWED_HOST.test(dsn.hostname)) {
+            // A DSN pointing anywhere else would make this route an open relay.
+            return Response.json({ error: "DSN host is not Sentry." }, { status: 400 });
+        }
+        const projectId = dsn.pathname.replace(/^\/+/, "");
+        if (!/^\d+$/.test(projectId)) {
+            return Response.json({ error: "DSN names no project." }, { status: 400 });
+        }
+        const upstream = await doFetch(`https://${dsn.hostname}/api/${projectId}/envelope/`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-sentry-envelope" },
+            body: envelope
+        });
+        return new Response(null, { status: upstream.status });
+    };
+}

package/dist/server/session.d.ts

@@ -1,4 +1,4 @@
-import { type MiiAuthCore, type MiiUser } from "@shubh90/app-runtime/auth/core";
+import { type MiiAuthCore, type MiiUser } from "../auth/core.js";
 export type SessionUser = Pick<MiiUser, "id" | "name" | "email" | "avatarUrl" | "role">;
 export type SessionState = {
     user: SessionUser | null;

package/dist/server/session.js

@@ -1,6 +1,6 @@
 // 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 { signInWithPlaza } from "../auth/core.js";
+import { readCookie } from "../chat/server.js";
 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) {

package/dist/uuid.d.ts

@@ -0,0 +1 @@
+export declare function isUuid(value: string): boolean;

package/dist/uuid.js

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+const uuidSchema = z.uuid();
+// The platform's invocation ids are uuid columns: an id of any
+// other shape names nothing, so it is refused here rather than forwarded.
+export function isUuid(value) {
+    return uuidSchema.safeParse(value).success;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trylight/app",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "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",
@@ -47,8 +47,9 @@
     "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"
+    "check": "tsx scripts/write-brand.ts --check && pnpm run typecheck && pnpm run lint && pnpm run test && pnpm run build",
+    "prepack": "pnpm run build",
+    "brand": "tsx scripts/write-brand.ts"
   },
   "peerDependencies": {
     "@tanstack/react-query": ">=5.69",
@@ -60,7 +61,6 @@
     "zod": ">=4"
   },
   "dependencies": {
-    "@shubh90/app-runtime": "^0.10.3",
     "drizzle-kit": "0.31.11",
     "drizzle-zod": "^0.8.3",
     "ipaddr.js": "^2.5.0",

package/dist/db/baseline.d.ts

@@ -1,36 +0,0 @@
-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

@@ -1,439 +0,0 @@
-// `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, hiddenConstraints, keys } = await catalogFacts(databaseUrl);
-    if (hiddenConstraints.length > 0) {
-        throw new BaselineRefused(`The database role baseline reads with can't see the constraints of ${hiddenConstraints.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 { snapshot, added } = addKeys(pulled.snapshot, keys);
-    const live = pulledTables.parse(snapshot.tables);
-    const declarations = pulled.source
-        .split(/\n(?=export const )/)
-        .slice(1)
-        .map(readDeclaration)
-        .map((declaration) => writeKeys(declaration, added));
-    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(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, tables
- * whose constraints this role can't see, and every table's primary key and
- * unique constraints (see addKeys).
- */
-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`;
-        // pg_constraint and pg_attribute show every table's constraints to any role, owner or not.
-        const keys = await sql `
-      select t.relname as table, c.conname as name, c.contype::text as kind,
-        array_agg(a.attname::text order by k.position) as columns
-      from pg_constraint c
-      join pg_class t on t.oid = c.conrelid
-      join pg_namespace n on n.oid = t.relnamespace
-      cross join lateral unnest(c.conkey) with ordinality as k(attnum, position)
-      join pg_attribute a on a.attrelid = c.conrelid and a.attnum = k.attnum
-      where n.nspname = 'public' and c.contype in ('p', 'u')
-      group by t.relname, c.conname, c.contype
-      order by 1, 2`;
-        return { specialOpclasses, hiddenConstraints: hidden.map((row) => row.table), keys };
-    }
-    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 });
-    }
-}
-/**
- * pull reads keys from information_schema.constraint_column_usage, which Postgres fills only for tables
- * the role owns, so as an app's reader it finds none. Adds each key its snapshot lacks, as pull records
- * it for an owner; returns those keys for writeKeys.
- */
-function addKeys(snapshot, keys) {
-    const tables = structuredClone(snapshot.tables);
-    const added = [];
-    for (const key of keys) {
-        const table = tables[`public.${key.table}`];
-        if (table === undefined)
-            throw new Error(`drizzle-kit pull didn't read ${key.table}, which has key ${key.name}.`);
-        const column = keyColumn(key);
-        if (key.kind === "u") {
-            if (key.name in table.uniqueConstraints)
-                continue;
-            table.uniqueConstraints[key.name] = { name: key.name, columns: key.columns, nullsNotDistinct: false };
-        }
-        else if (column === null) {
-            if (key.name in table.compositePrimaryKeys)
-                continue;
-            table.compositePrimaryKeys[key.name] = { name: key.name, columns: key.columns };
-        }
-        else {
-            const pulled = pulledColumn.parse(table.columns[column]);
-            if (pulled.primaryKey)
-                continue;
-            table.columns[column] = { ...pulled, primaryKey: true };
-        }
-        added.push(key);
-    }
-    return { snapshot: { ...snapshot, tables }, added };
-}
-/** A primary key's one column, which pull puts on the column itself; null for a composite key. */
-function keyColumn(key) {
-    const [column, ...rest] = key.columns;
-    return key.kind === "p" && column !== undefined && rest.length === 0 ? column : null;
-}
-/** A pulled table with the keys addKeys added to its snapshot, written as pull writes them. */
-function writeKeys(declaration, added) {
-    const keys = added.filter((key) => key.table === declaration.dbName);
-    if (declaration.kind !== "pgTable" || keys.length === 0)
-        return declaration;
-    const lines = declaration.text.split("\n");
-    const entries = [];
-    for (const key of keys) {
-        const column = keyColumn(key);
-        const columns = key.columns.map((name) => `table.${name}`).join(", ");
-        if (key.kind === "u") {
-            entries.push(`\tunique("${key.name}").on(${columns}),`);
-        }
-        else if (column === null) {
-            entries.push(`\tprimaryKey({ columns: [${columns}], name: "${key.name}"}),`);
-        }
-        else {
-            const at = lines.findIndex((line) => line.startsWith(`\t${column}: `) && line.endsWith(","));
-            const line = lines[at];
-            if (line === undefined)
-                throw new Error(`drizzle-kit pull wrote ${declaration.dbName}.${column} in a shape baseline can't read:\n${declaration.text}`);
-            lines[at] = `${line.slice(0, -1)}.primaryKey(),`;
-        }
-    }
-    let text = lines.join("\n");
-    if (entries.length > 0) {
-        const config = entries.join("\n");
-        if (text.endsWith("\n]);"))
-            text = `${text.slice(0, -"\n]);".length)}\n${config}\n]);`;
-        else if (text.endsWith("\n});"))
-            text = `${text.slice(0, -");".length)}, (table) => [\n${config}\n]);`;
-        else
-            throw new Error(`drizzle-kit pull wrote ${declaration.dbName} in a shape baseline can't read:\n${declaration.text}`);
-    }
-    return { ...declaration, text };
-}
-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());
-}
-// Not after a dot: a column's `.primaryKey()` imports nothing.
-const uses = (text, name, after) => new RegExp(`(?<![.\\w])${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 = [...new Set([...context.pgCore, "customType", "primaryKey", "unique"])].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 };
-}