@stardeck-customer-apps/testing 0.19.0 → 0.20.0

package/SKILL.md

@@ -293,32 +293,32 @@ expect(app.edge.latestDisplay()?.action).toBe("show");
   - `schemaSql` — inline DDL instead of a file.
   - `seed(db)` — seed rows; re-runs on every `reset()`.
   - `allowNetwork` — permit non-Stardeck outbound fetches (off by default).
-- `app.reset()` — wipe + re-apply schema + re-seed + clear inbox/sessions.
-  Call in `beforeEach`.
-- `app.reset({ mode: "data" })` — available in testing SDK **0.14.0+**. Faster
-  opt-in for stable schemas: truncate ordinary tables in `public`, restart their
-  owned serial/identity sequences, re-run the data-only seed, and clear the same
-  simulator/user/session state as the default. It preserves tables and other
-  schema objects instead of rebuilding them. The default remains full schema
-  reset; `app.reset({ mode: "schema" })` explicitly selects that default.
+- `app.reset()` — restore the database to its state right after schema + seed,
+  and clear inbox/sessions/simulator state. Call in `beforeEach`.
+  Since testing SDK **0.20.0** it restores the rows the schema script inserted
+  and every sequence and identity value without firing app triggers, then
+  re-runs the seed, in about a fifth of the time of the old schema rebuild. If a
+  test ran DDL (CREATE, ALTER, DROP), the next reset rebuilds the schema
+  instead, so tests never need to choose a mode. DDL in the seed stays on the
+  fast path when it can run twice (`CREATE TABLE IF NOT EXISTS`); a seed that
+  fails on its second run makes every reset a rebuild.
+  `app.reset({ mode: "schema" })` forces the full rebuild; `mode: "data"` is an
+  older spelling of the default.
 
   ```ts
-  // Only after verifying this suite keeps its schema fixed and uses a data-only seed:
-  beforeEach(() => app.reset({ mode: "data" }));
+  beforeEach(() => app.reset());
   ```
 
-  Keep `app.reset()` for tests that change schema or depend on INSERTs in the
-  schema script. Also keep full reset for independent sequences, materialized
-  views, partitioned/foreign tables, temporary tables, and custom triggers or
-  cross-schema dependencies. Data mode does not restore those states or detect
-  eligibility; inspect both the tests and seed before opting in. All required
-  baseline rows must come from the data-only seed callback, not schema SQL.
-  Data mode refuses foreign keys requiring a cross-schema cascade. Database and
-  seed errors reject the reset; fix them before running the next test.
+  Reset never
+  cascades into tables outside `public`: a foreign key from another schema into
+  a `public` table rejects the reset with Postgres error `0A000`.
+  The first `createTestApp` for a schema saves a database snapshot under
+  `node_modules/.cache/stardeck-testing/`; later test files boot from it.
+  Deleting that directory is always safe.
 
   Do not use `it.concurrent` or `test.concurrent` with a shared test app: user,
   database, and simulator state are shared within the file. Keep file isolation
-  enabled and let Vitest parallelize files. This option does not change workers
+  enabled and let Vitest parallelize files. Reset does not change workers
   or the platform's test-run deadline.
 
 - `app.asUser(partial?)` — sign in a test user; `getSession()` in app code

package/dist/index.d.mts

@@ -633,10 +633,10 @@ interface TestApp {
      */
     issueSession(user?: Partial<TestUser>): SessionTokens;
     /**
-     * Rebuild the schema (default), re-run the seed, and clear simulator/user state.
-     * `mode: "data"` instead truncates ordinary public tables and restarts owned
-     * sequences. Use only with a stable schema and data-only seed; it does not
-     * restore DDL changes, schema-script data, or independent sequences.
+     * Restore the rows and sequence values the schema script left, re-run the
+     * seed, and clear simulator/user state. Any DDL since the last reset triggers a full
+     * schema rebuild instead. `mode: "schema"` forces the rebuild; `mode: "data"`
+     * is an older spelling of the default.
      */
     reset(options?: {
         mode: "schema" | "data";

package/dist/index.d.ts

@@ -633,10 +633,10 @@ interface TestApp {
      */
     issueSession(user?: Partial<TestUser>): SessionTokens;
     /**
-     * Rebuild the schema (default), re-run the seed, and clear simulator/user state.
-     * `mode: "data"` instead truncates ordinary public tables and restarts owned
-     * sequences. Use only with a stable schema and data-only seed; it does not
-     * restore DDL changes, schema-script data, or independent sequences.
+     * Restore the rows and sequence values the schema script left, re-run the
+     * seed, and clear simulator/user state. Any DDL since the last reset triggers a full
+     * schema rebuild instead. `mode: "schema"` forces the rebuild; `mode: "data"`
+     * is an older spelling of the default.
      */
     reset(options?: {
         mode: "schema" | "data";

package/dist/index.js

@@ -48,9 +48,9 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/test-app.ts
-var import_node_crypto8 = __toESM(require("crypto"));
-var import_node_fs = require("fs");
-var import_node_path = require("path");
+var import_node_crypto9 = __toESM(require("crypto"));
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 
 // src/pglite/database.ts
 var import_pglite = require("@electric-sql/pglite");
@@ -58,10 +58,10 @@ var import_citext = require("@electric-sql/pglite/contrib/citext");
 var import_pg_trgm = require("@electric-sql/pglite/contrib/pg_trgm");
 var import_pgcrypto = require("@electric-sql/pglite/contrib/pgcrypto");
 var import_uuid_ossp = require("@electric-sql/pglite/contrib/uuid_ossp");
-async function createPgliteDatabase() {
-  const db = new import_pglite.PGlite({
-    extensions: { pg_trgm: import_pg_trgm.pg_trgm, pgcrypto: import_pgcrypto.pgcrypto, uuid_ossp: import_uuid_ossp.uuid_ossp, citext: import_citext.citext }
-  });
+var EXTENSIONS = { pg_trgm: import_pg_trgm.pg_trgm, pgcrypto: import_pgcrypto.pgcrypto, uuid_ossp: import_uuid_ossp.uuid_ossp, citext: import_citext.citext };
+var PGLITE_EXTENSION_NAMES = Object.keys(EXTENSIONS);
+async function createPgliteDatabase(options = {}) {
+  const db = new import_pglite.PGlite({ extensions: EXTENSIONS, ...options });
   await db.waitReady;
   return db;
 }
@@ -82,10 +82,6 @@ async function listPublicTables(db) {
   `);
   return rows.map(({ name }) => name);
 }
-async function truncateAllTables(db) {
-  const tables = await listPublicTables(db);
-  if (tables.length) await db.exec(`TRUNCATE TABLE ${tables.join(", ")} RESTART IDENTITY`);
-}
 var identityParsers = null;
 function getIdentityParsers() {
   if (!identityParsers) {
@@ -98,6 +94,198 @@ function getIdentityParsers() {
   return identityParsers;
 }
 
+// src/pglite/baseline.ts
+var HARNESS_SCHEMA = "stardeck_test";
+var SCHEMA_CHANGES = `${HARNESS_SCHEMA}.schema_changes`;
+var SCHEMA_CHANGE_TRACKING_SQL = `
+    CREATE SCHEMA IF NOT EXISTS ${HARNESS_SCHEMA};
+    CREATE TABLE IF NOT EXISTS ${SCHEMA_CHANGES} ();
+    CREATE OR REPLACE FUNCTION ${HARNESS_SCHEMA}.mark_schema_changed() RETURNS event_trigger
+      LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog
+      AS $$ BEGIN INSERT INTO ${SCHEMA_CHANGES} DEFAULT VALUES; END $$;
+    DROP EVENT TRIGGER IF EXISTS stardeck_test_ddl;
+    DROP EVENT TRIGGER IF EXISTS stardeck_test_drop;
+    CREATE EVENT TRIGGER stardeck_test_ddl ON ddl_command_end
+      EXECUTE FUNCTION ${HARNESS_SCHEMA}.mark_schema_changed();
+    CREATE EVENT TRIGGER stardeck_test_drop ON sql_drop
+      EXECUTE FUNCTION ${HARNESS_SCHEMA}.mark_schema_changed();
+    ALTER EVENT TRIGGER stardeck_test_ddl ENABLE ALWAYS;
+    ALTER EVENT TRIGGER stardeck_test_drop ENABLE ALWAYS;
+  `;
+async function schemaChangedSinceBaseline(db) {
+  const { rows } = await db.query(
+    `SELECT EXISTS (SELECT FROM ${SCHEMA_CHANGES}) AS changed`
+  );
+  return rows[0]?.changed === true;
+}
+async function acceptSchemaChanges(db) {
+  await db.exec(`DELETE FROM ${SCHEMA_CHANGES};`);
+}
+async function sequenceStates(db) {
+  const { rows: sequences } = await db.query(`
+    SELECT format('%I.%I', n.nspname, c.relname) AS name
+    FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = 'public' AND c.relkind = 'S'
+  `);
+  if (!sequences.length) return null;
+  const { rows } = await db.query(
+    sequences.map(
+      ({ name }) => `SELECT ${quoteLiteral(name)} AS name, last_value::text, is_called FROM ${name}`
+    ).join(" UNION ALL ")
+  );
+  return `SELECT ${rows.map((s) => `setval(${quoteLiteral(s.name)}, ${s.last_value}, ${s.is_called})`).join(", ")};`;
+}
+function quoteLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+async function captureBaseline(db) {
+  const { rows: unsilenceable } = await db.query(`
+    SELECT FROM pg_trigger t JOIN pg_class c ON c.oid = t.tgrelid
+    WHERE c.relnamespace = 'public'::regnamespace AND NOT t.tgisinternal
+      AND t.tgenabled IN ('A', 'R')`);
+  if (unsilenceable.length) return null;
+  const tables = await listPublicTables(db);
+  const statements = [];
+  await db.exec(`DROP SCHEMA IF EXISTS ${HARNESS_SCHEMA}_baseline CASCADE;
+    CREATE SCHEMA ${HARNESS_SCHEMA}_baseline;`);
+  if (tables.length) {
+    const { rows: populated } = await db.query(
+      tables.map(
+        (table, index) => `SELECT ${index} AS index, (
+            SELECT string_agg(quote_ident(attname), ', ' ORDER BY attnum) FROM pg_attribute
+            WHERE attrelid = ${quoteLiteral(table)}::regclass AND attnum > 0
+              AND NOT attisdropped AND attgenerated = ''
+          ) AS columns WHERE EXISTS (SELECT 1 FROM ONLY ${table})`
+      ).join(" UNION ALL ")
+    );
+    for (const { index, columns } of populated) {
+      const copy = `${HARNESS_SCHEMA}_baseline.t${index}`;
+      await db.exec(`CREATE TABLE ${copy} AS SELECT ${columns} FROM ONLY ${tables[index]};`);
+      statements.push(
+        `INSERT INTO ${tables[index]} (${columns}) OVERRIDING SYSTEM VALUE SELECT ${columns} FROM ${copy};`
+      );
+    }
+  }
+  const setvals = await sequenceStates(db);
+  if (setvals) statements.push(setvals);
+  return { restoreSql: statements.join("\n") };
+}
+async function restoreBaseline(db, baseline) {
+  const tables = await listPublicTables(db);
+  const truncate = tables.length ? `TRUNCATE TABLE ${tables.join(", ")} RESTART IDENTITY;` : "";
+  try {
+    await db.exec(`BEGIN; SET LOCAL session_replication_role = replica;
+      ${truncate}
+      SELECT setval(format('%I.%I', schemaname, sequencename), start_value, false)
+        FROM pg_sequences WHERE schemaname = 'public';
+      ${baseline.restoreSql}
+      COMMIT;`);
+  } catch (error) {
+    await db.exec("ROLLBACK;").catch(() => {
+    });
+    throw error;
+  }
+}
+
+// src/pglite/snapshot.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var SNAPSHOT_FORMAT = 2;
+var MAX_SNAPSHOTS = 8;
+function snapshotKey(schemaSql) {
+  const day = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify({ format: SNAPSHOT_FORMAT, extensions: PGLITE_EXTENSION_NAMES, day })).update(SCHEMA_CHANGE_TRACKING_SQL).update(schemaSql).digest("hex").slice(0, 32);
+}
+function snapshotPath(schemaSql) {
+  return (0, import_node_path.resolve)(
+    process.cwd(),
+    "node_modules/.cache/stardeck-testing",
+    `${snapshotKey(schemaSql)}.tar`
+  );
+}
+var CUSTOM_SETTING = /\bset_config\s*\(\s*(?:'([^']*)'|(\$\w*\$)([\s\S]*?)\2)|\bSET\s+(?:SESSION\s+)?(?:"([^"]*)"|([a-z_][\w$]*\.[\w$.]+))/gi;
+async function sessionSettings(db, schemaSql) {
+  const custom = [...schemaSql.matchAll(CUSTOM_SETTING)].map(
+    ([, quoted, , dollarQuoted, identifier, bare]) => quoted ?? dollarQuoted ?? identifier ?? bare
+  ).filter((name) => name?.includes("."));
+  const { rows } = await db.query(
+    `SELECT string_agg(name || '=' || setting, ',' ORDER BY name) AS settings FROM (
+       SELECT name, setting FROM pg_settings WHERE source = 'session'
+       UNION ALL
+       SELECT name, current_setting(name, true) FROM unnest($1::text[]) AS name
+       WHERE current_setting(name, true) IS NOT NULL
+     ) settings`,
+    [custom]
+  );
+  return rows[0]?.settings ?? "";
+}
+async function buildSchemaDatabase(schemaSql) {
+  const db = await createPgliteDatabase();
+  try {
+    await db.exec(SCHEMA_CHANGE_TRACKING_SQL);
+    const settingsBefore = await sessionSettings(db, schemaSql);
+    await applySchema(db, schemaSql);
+    const { rows: sessionBound } = await db.query(
+      `SELECT FROM pg_class WHERE relpersistence IN ('u', 't')`
+    );
+    const cacheable = !sessionBound.length && await sessionSettings(db, schemaSql) === settingsBefore;
+    await db.exec(`COMMENT ON SCHEMA stardeck_test IS '${snapshotKey(schemaSql)}'`);
+    await db.exec("CHECKPOINT");
+    return { db, cacheable };
+  } catch (error) {
+    await db.close().catch(() => {
+    });
+    throw error;
+  }
+}
+function pruneSnapshots(dir) {
+  const snapshots = (0, import_node_fs.readdirSync)(dir).filter((name) => name.endsWith(".tar")).map((name) => ({ path: (0, import_node_path.join)(dir, name), mtime: (0, import_node_fs.statSync)((0, import_node_path.join)(dir, name)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  for (const { path } of snapshots.slice(MAX_SNAPSHOTS)) (0, import_node_fs.rmSync)(path, { force: true });
+}
+async function writeSnapshot(path, db) {
+  try {
+    const data = Buffer.from(await (await db.dumpDataDir("none")).arrayBuffer());
+    (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    (0, import_node_fs.writeFileSync)(tmp, data);
+    (0, import_node_fs.renameSync)(tmp, path);
+    pruneSnapshots((0, import_node_path.dirname)(path));
+  } catch (error) {
+    console.warn(`[stardeck-testing] could not cache schema snapshot at ${path}:`, error);
+  }
+}
+async function loadSnapshot(path, key) {
+  let db = null;
+  try {
+    db = await createPgliteDatabase({ loadDataDir: new Blob([(0, import_node_fs.readFileSync)(path)]) });
+    const { rows } = await db.query(
+      `SELECT obj_description(to_regnamespace('stardeck_test'), 'pg_namespace') AS key`
+    );
+    if (rows[0]?.key === key) {
+      const now3 = /* @__PURE__ */ new Date();
+      (0, import_node_fs.utimesSync)(path, now3, now3);
+      return db;
+    }
+    console.warn(`[stardeck-testing] rebuilding schema snapshot ${path}: key mismatch`);
+  } catch (error) {
+    console.warn(`[stardeck-testing] rebuilding unreadable schema snapshot ${path}:`, error);
+  }
+  await db?.close().catch(() => {
+  });
+  return null;
+}
+async function bootWithSchema(schemaSql) {
+  const path = snapshotPath(schemaSql);
+  if ((0, import_node_fs.existsSync)(path)) {
+    const loaded = await loadSnapshot(path, snapshotKey(schemaSql));
+    if (loaded) return loaded;
+  }
+  const { db, cacheable } = await buildSchemaDatabase(schemaSql);
+  if (cacheable) await writeSnapshot(path, db);
+  return db;
+}
+
 // src/global-singleton.ts
 function globalSingleton(key, create) {
   const symbol = /* @__PURE__ */ Symbol.for(`stardeck-testing.${key}`);
@@ -189,7 +377,7 @@ function requireDb() {
 }
 
 // src/simulator/hmac.ts
-var import_node_crypto = __toESM(require("crypto"));
+var import_node_crypto2 = __toESM(require("crypto"));
 var TIMESTAMP_TOLERANCE_SECONDS = 300;
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
@@ -210,10 +398,10 @@ function verifyDeploymentAuthHeader(secret, header) {
   } catch {
     return null;
   }
-  const expected = import_node_crypto.default.createHmac("sha256", secret).update(payloadJson).digest("hex");
+  const expected = import_node_crypto2.default.createHmac("sha256", secret).update(payloadJson).digest("hex");
   const expectedBuf = Buffer.from(expected, "utf-8");
   const actualBuf = Buffer.from(signature, "utf-8");
-  if (expectedBuf.length !== actualBuf.length || !import_node_crypto.default.timingSafeEqual(expectedBuf, actualBuf)) {
+  if (expectedBuf.length !== actualBuf.length || !import_node_crypto2.default.timingSafeEqual(expectedBuf, actualBuf)) {
     return null;
   }
   let parsed;
@@ -630,7 +818,7 @@ async function handleNeonSql(db, request) {
 }
 
 // src/simulator/auth.ts
-var import_node_crypto2 = __toESM(require("crypto"));
+var import_node_crypto3 = __toESM(require("crypto"));
 function handleAuthVerify(request) {
   const authHeader = request.headers.get("Authorization");
   const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
@@ -647,7 +835,7 @@ function handleAuthRefresh(request) {
   if (!user || !refreshToken) {
     return json({ error: "invalid_grant" }, 401);
   }
-  const accessToken = `test-access-${import_node_crypto2.default.randomUUID()}`;
+  const accessToken = `test-access-${import_node_crypto3.default.randomUUID()}`;
   state.sessions.set(accessToken, user);
   return json({
     access_token: accessToken,
@@ -715,7 +903,7 @@ function createInbox() {
 }
 
 // src/simulator/identities.ts
-var import_node_crypto3 = __toESM(require("crypto"));
+var import_node_crypto4 = __toESM(require("crypto"));
 var ATTACH_LINK_KINDS = /* @__PURE__ */ new Set(["line", "facebook", "instagram", "email", "phone"]);
 var TRUSTED_LINK_KINDS = /* @__PURE__ */ new Set([
   "line",
@@ -828,7 +1016,7 @@ function normalizedLinkKey(link) {
 function createPerson(displayName) {
   const createdAt = now();
   const identity = {
-    id: import_node_crypto3.default.randomUUID(),
+    id: import_node_crypto4.default.randomUUID(),
     type: "person",
     parentId: null,
     displayName,
@@ -844,7 +1032,7 @@ function createPerson(displayName) {
 }
 function createUnverifiedLink(identityId, kind, externalId) {
   const link = {
-    id: import_node_crypto3.default.randomUUID(),
+    id: import_node_crypto4.default.randomUUID(),
     identityId,
     kind,
     externalId,
@@ -895,7 +1083,7 @@ async function handleCreate(request) {
   }
   const createdAt = now();
   const identity = {
-    id: import_node_crypto3.default.randomUUID(),
+    id: import_node_crypto4.default.randomUUID(),
     type,
     parentId,
     displayName: body.displayName ?? null,
@@ -1173,8 +1361,8 @@ function claimableIdentity(identityId) {
   return identity;
 }
 function mintClaim(params) {
-  const claimId = import_node_crypto3.default.randomUUID();
-  const handle = import_node_crypto3.default.randomBytes(32).toString("base64url");
+  const claimId = import_node_crypto4.default.randomUUID();
+  const handle = import_node_crypto4.default.randomBytes(32).toString("base64url");
   const claim = {
     claimId,
     flow: params.flow,
@@ -1528,7 +1716,7 @@ function createDirectory() {
 }
 
 // src/simulator/payments.ts
-var import_node_crypto5 = __toESM(require("crypto"));
+var import_node_crypto6 = __toESM(require("crypto"));
 
 // src/next/headers-shim.ts
 var import_node_async_hooks = require("async_hooks");
@@ -1611,7 +1799,7 @@ function decodeNextRedirect(error) {
 }
 
 // src/simulator/webhook-signing.ts
-var import_node_crypto4 = __toESM(require("crypto"));
+var import_node_crypto5 = __toESM(require("crypto"));
 function signEventDelivery(secret, context, rawBody) {
   const payload = {
     type: "deployment-request",
@@ -1619,11 +1807,11 @@ function signEventDelivery(secret, context, rawBody) {
     projectId: context.projectId,
     deploymentId: context.deploymentId,
     timestamp: Math.floor(Date.now() / 1e3),
-    nonce: import_node_crypto4.default.randomUUID()
+    nonce: import_node_crypto5.default.randomUUID()
   };
   const payloadJson = JSON.stringify(payload);
   const payloadB64 = Buffer.from(payloadJson).toString("base64");
-  const signature = import_node_crypto4.default.createHmac("sha256", secret).update(payloadJson).update(rawBody).digest("hex");
+  const signature = import_node_crypto5.default.createHmac("sha256", secret).update(payloadJson).update(rawBody).digest("hex");
   return `${payloadB64}.${signature}`;
 }
 
@@ -2157,7 +2345,7 @@ function createPayments() {
     },
     async deliverStripeEvent(handler, event, options) {
       const envelope = {
-        id: `evt_test_${import_node_crypto5.default.randomUUID()}`,
+        id: `evt_test_${import_node_crypto6.default.randomUUID()}`,
         kind: "stripe_webhook",
         timestamp: Date.now(),
         stripeEvent: {
@@ -2170,7 +2358,7 @@ function createPayments() {
     },
     async deliverBeamEvent(handler, event, options) {
       const envelope = {
-        id: `beam_evt_test_${import_node_crypto5.default.randomUUID()}`,
+        id: `beam_evt_test_${import_node_crypto6.default.randomUUID()}`,
         kind: "beam_webhook",
         timestamp: Date.now(),
         beamEvent: {
@@ -2253,7 +2441,7 @@ function createPayments() {
 }
 
 // src/simulator/storage.ts
-var import_node_crypto6 = __toESM(require("crypto"));
+var import_node_crypto7 = __toESM(require("crypto"));
 function storageErr(error, status = 400) {
   return json({ error }, status);
 }
@@ -2332,7 +2520,7 @@ async function handleStorageRequest(request, url) {
     }
     return new Response(null, {
       status: 200,
-      headers: { etag: `"${import_node_crypto6.default.randomUUID()}"` }
+      headers: { etag: `"${import_node_crypto7.default.randomUUID()}"` }
     });
   }
   if (pathname === "/upload/presign/complete" && request.method === "POST") {
@@ -2480,7 +2668,7 @@ function createStorage() {
 }
 
 // src/simulator/messaging.ts
-var import_node_crypto7 = __toESM(require("crypto"));
+var import_node_crypto8 = __toESM(require("crypto"));
 function isValidLineImageUrl(url) {
   if (url.length > 2e3 || !url.startsWith("https://")) return false;
   try {
@@ -2534,7 +2722,7 @@ async function handleMessagingRequest(request, channel, subPath) {
     );
     return success({
       ok: true,
-      ts: `${Date.now()}.${import_node_crypto7.default.randomUUID().slice(0, 6)}`,
+      ts: `${Date.now()}.${import_node_crypto8.default.randomUUID().slice(0, 6)}`,
       channel: slackChannel
     });
   }
@@ -3247,8 +3435,8 @@ function buildUser(partial) {
 function loadSchemaSql(options) {
   if (options.schemaSql !== void 0) return options.schemaSql;
   if (options.schema === null) return null;
-  const schemaPath = (0, import_node_path.resolve)(process.cwd(), options.schema ?? DEFAULT_SCHEMA_PATH);
-  if (!(0, import_node_fs.existsSync)(schemaPath)) {
+  const schemaPath = (0, import_node_path2.resolve)(process.cwd(), options.schema ?? DEFAULT_SCHEMA_PATH);
+  if (!(0, import_node_fs2.existsSync)(schemaPath)) {
     if (options.schema) {
       throw new Error(
         `[stardeck-testing] Schema snapshot not found at ${schemaPath}. Run \`npx stardeck-data-store generate-types\` to regenerate it.`
@@ -3256,7 +3444,7 @@ function loadSchemaSql(options) {
     }
     return null;
   }
-  return (0, import_node_fs.readFileSync)(schemaPath, "utf-8");
+  return (0, import_node_fs2.readFileSync)(schemaPath, "utf-8");
 }
 async function createTestApp(options = {}) {
   if (state.db) {
@@ -3267,15 +3455,23 @@ async function createTestApp(options = {}) {
   applyTestEnv(options);
   state.allowNetwork = options.allowNetwork ?? false;
   installFetchRouter();
-  const db = await createPgliteDatabase();
+  const schemaSql = loadSchemaSql(options) ?? "";
+  const db = await bootWithSchema(schemaSql);
   state.db = db;
-  const initialize = async () => {
-    const schemaSql = loadSchemaSql(options);
-    if (schemaSql) await applySchema(db, schemaSql);
+  let baseline;
+  const seed = async () => {
     if (options.seed) await options.seed(db);
+    await acceptSchemaChanges(db);
+  };
+  const rebuild = async () => {
+    await dropAllTables(db);
+    await applySchema(db, schemaSql);
+    baseline = await captureBaseline(db);
+    await seed();
   };
   try {
-    await initialize();
+    baseline = await captureBaseline(db);
+    await seed();
   } catch (error) {
     state.db = null;
     await db.close().catch(() => {
@@ -3313,20 +3509,23 @@ async function createTestApp(options = {}) {
     issueSession(user) {
       const fullUser = buildUser(user);
       const tokens = {
-        accessToken: `test-access-${import_node_crypto8.default.randomUUID()}`,
-        refreshToken: `test-refresh-${import_node_crypto8.default.randomUUID()}`
+        accessToken: `test-access-${import_node_crypto9.default.randomUUID()}`,
+        refreshToken: `test-refresh-${import_node_crypto9.default.randomUUID()}`
       };
       state.sessions.set(tokens.accessToken, fullUser);
       state.refreshSessions.set(tokens.refreshToken, fullUser);
       return tokens;
     },
     async reset(resetOptions) {
-      if (resetOptions?.mode === "data") {
-        await truncateAllTables(db);
-        if (options.seed) await options.seed(db);
+      if (resetOptions?.mode === "schema" || !baseline || await schemaChangedSinceBaseline(db)) {
+        await rebuild();
       } else {
-        await dropAllTables(db);
-        await initialize();
+        await restoreBaseline(db, baseline);
+        try {
+          await seed();
+        } catch {
+          await rebuild();
+        }
       }
       state.currentUser = null;
       state.sessions.clear();

package/dist/index.mjs

@@ -1,7 +1,7 @@
 // src/test-app.ts
 import crypto8 from "crypto";
-import { readFileSync, existsSync } from "fs";
-import { resolve } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
 
 // src/pglite/database.ts
 import { PGlite } from "@electric-sql/pglite";
@@ -9,10 +9,10 @@ import { citext } from "@electric-sql/pglite/contrib/citext";
 import { pg_trgm } from "@electric-sql/pglite/contrib/pg_trgm";
 import { pgcrypto } from "@electric-sql/pglite/contrib/pgcrypto";
 import { uuid_ossp } from "@electric-sql/pglite/contrib/uuid_ossp";
-async function createPgliteDatabase() {
-  const db = new PGlite({
-    extensions: { pg_trgm, pgcrypto, uuid_ossp, citext }
-  });
+var EXTENSIONS = { pg_trgm, pgcrypto, uuid_ossp, citext };
+var PGLITE_EXTENSION_NAMES = Object.keys(EXTENSIONS);
+async function createPgliteDatabase(options = {}) {
+  const db = new PGlite({ extensions: EXTENSIONS, ...options });
   await db.waitReady;
   return db;
 }
@@ -33,10 +33,6 @@ async function listPublicTables(db) {
   `);
   return rows.map(({ name }) => name);
 }
-async function truncateAllTables(db) {
-  const tables = await listPublicTables(db);
-  if (tables.length) await db.exec(`TRUNCATE TABLE ${tables.join(", ")} RESTART IDENTITY`);
-}
 var identityParsers = null;
 function getIdentityParsers() {
   if (!identityParsers) {
@@ -49,6 +45,208 @@ function getIdentityParsers() {
   return identityParsers;
 }
 
+// src/pglite/baseline.ts
+var HARNESS_SCHEMA = "stardeck_test";
+var SCHEMA_CHANGES = `${HARNESS_SCHEMA}.schema_changes`;
+var SCHEMA_CHANGE_TRACKING_SQL = `
+    CREATE SCHEMA IF NOT EXISTS ${HARNESS_SCHEMA};
+    CREATE TABLE IF NOT EXISTS ${SCHEMA_CHANGES} ();
+    CREATE OR REPLACE FUNCTION ${HARNESS_SCHEMA}.mark_schema_changed() RETURNS event_trigger
+      LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog
+      AS $$ BEGIN INSERT INTO ${SCHEMA_CHANGES} DEFAULT VALUES; END $$;
+    DROP EVENT TRIGGER IF EXISTS stardeck_test_ddl;
+    DROP EVENT TRIGGER IF EXISTS stardeck_test_drop;
+    CREATE EVENT TRIGGER stardeck_test_ddl ON ddl_command_end
+      EXECUTE FUNCTION ${HARNESS_SCHEMA}.mark_schema_changed();
+    CREATE EVENT TRIGGER stardeck_test_drop ON sql_drop
+      EXECUTE FUNCTION ${HARNESS_SCHEMA}.mark_schema_changed();
+    ALTER EVENT TRIGGER stardeck_test_ddl ENABLE ALWAYS;
+    ALTER EVENT TRIGGER stardeck_test_drop ENABLE ALWAYS;
+  `;
+async function schemaChangedSinceBaseline(db) {
+  const { rows } = await db.query(
+    `SELECT EXISTS (SELECT FROM ${SCHEMA_CHANGES}) AS changed`
+  );
+  return rows[0]?.changed === true;
+}
+async function acceptSchemaChanges(db) {
+  await db.exec(`DELETE FROM ${SCHEMA_CHANGES};`);
+}
+async function sequenceStates(db) {
+  const { rows: sequences } = await db.query(`
+    SELECT format('%I.%I', n.nspname, c.relname) AS name
+    FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+    WHERE n.nspname = 'public' AND c.relkind = 'S'
+  `);
+  if (!sequences.length) return null;
+  const { rows } = await db.query(
+    sequences.map(
+      ({ name }) => `SELECT ${quoteLiteral(name)} AS name, last_value::text, is_called FROM ${name}`
+    ).join(" UNION ALL ")
+  );
+  return `SELECT ${rows.map((s) => `setval(${quoteLiteral(s.name)}, ${s.last_value}, ${s.is_called})`).join(", ")};`;
+}
+function quoteLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+async function captureBaseline(db) {
+  const { rows: unsilenceable } = await db.query(`
+    SELECT FROM pg_trigger t JOIN pg_class c ON c.oid = t.tgrelid
+    WHERE c.relnamespace = 'public'::regnamespace AND NOT t.tgisinternal
+      AND t.tgenabled IN ('A', 'R')`);
+  if (unsilenceable.length) return null;
+  const tables = await listPublicTables(db);
+  const statements = [];
+  await db.exec(`DROP SCHEMA IF EXISTS ${HARNESS_SCHEMA}_baseline CASCADE;
+    CREATE SCHEMA ${HARNESS_SCHEMA}_baseline;`);
+  if (tables.length) {
+    const { rows: populated } = await db.query(
+      tables.map(
+        (table, index) => `SELECT ${index} AS index, (
+            SELECT string_agg(quote_ident(attname), ', ' ORDER BY attnum) FROM pg_attribute
+            WHERE attrelid = ${quoteLiteral(table)}::regclass AND attnum > 0
+              AND NOT attisdropped AND attgenerated = ''
+          ) AS columns WHERE EXISTS (SELECT 1 FROM ONLY ${table})`
+      ).join(" UNION ALL ")
+    );
+    for (const { index, columns } of populated) {
+      const copy = `${HARNESS_SCHEMA}_baseline.t${index}`;
+      await db.exec(`CREATE TABLE ${copy} AS SELECT ${columns} FROM ONLY ${tables[index]};`);
+      statements.push(
+        `INSERT INTO ${tables[index]} (${columns}) OVERRIDING SYSTEM VALUE SELECT ${columns} FROM ${copy};`
+      );
+    }
+  }
+  const setvals = await sequenceStates(db);
+  if (setvals) statements.push(setvals);
+  return { restoreSql: statements.join("\n") };
+}
+async function restoreBaseline(db, baseline) {
+  const tables = await listPublicTables(db);
+  const truncate = tables.length ? `TRUNCATE TABLE ${tables.join(", ")} RESTART IDENTITY;` : "";
+  try {
+    await db.exec(`BEGIN; SET LOCAL session_replication_role = replica;
+      ${truncate}
+      SELECT setval(format('%I.%I', schemaname, sequencename), start_value, false)
+        FROM pg_sequences WHERE schemaname = 'public';
+      ${baseline.restoreSql}
+      COMMIT;`);
+  } catch (error) {
+    await db.exec("ROLLBACK;").catch(() => {
+    });
+    throw error;
+  }
+}
+
+// src/pglite/snapshot.ts
+import { createHash } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  utimesSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, resolve } from "path";
+var SNAPSHOT_FORMAT = 2;
+var MAX_SNAPSHOTS = 8;
+function snapshotKey(schemaSql) {
+  const day = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return createHash("sha256").update(JSON.stringify({ format: SNAPSHOT_FORMAT, extensions: PGLITE_EXTENSION_NAMES, day })).update(SCHEMA_CHANGE_TRACKING_SQL).update(schemaSql).digest("hex").slice(0, 32);
+}
+function snapshotPath(schemaSql) {
+  return resolve(
+    process.cwd(),
+    "node_modules/.cache/stardeck-testing",
+    `${snapshotKey(schemaSql)}.tar`
+  );
+}
+var CUSTOM_SETTING = /\bset_config\s*\(\s*(?:'([^']*)'|(\$\w*\$)([\s\S]*?)\2)|\bSET\s+(?:SESSION\s+)?(?:"([^"]*)"|([a-z_][\w$]*\.[\w$.]+))/gi;
+async function sessionSettings(db, schemaSql) {
+  const custom = [...schemaSql.matchAll(CUSTOM_SETTING)].map(
+    ([, quoted, , dollarQuoted, identifier, bare]) => quoted ?? dollarQuoted ?? identifier ?? bare
+  ).filter((name) => name?.includes("."));
+  const { rows } = await db.query(
+    `SELECT string_agg(name || '=' || setting, ',' ORDER BY name) AS settings FROM (
+       SELECT name, setting FROM pg_settings WHERE source = 'session'
+       UNION ALL
+       SELECT name, current_setting(name, true) FROM unnest($1::text[]) AS name
+       WHERE current_setting(name, true) IS NOT NULL
+     ) settings`,
+    [custom]
+  );
+  return rows[0]?.settings ?? "";
+}
+async function buildSchemaDatabase(schemaSql) {
+  const db = await createPgliteDatabase();
+  try {
+    await db.exec(SCHEMA_CHANGE_TRACKING_SQL);
+    const settingsBefore = await sessionSettings(db, schemaSql);
+    await applySchema(db, schemaSql);
+    const { rows: sessionBound } = await db.query(
+      `SELECT FROM pg_class WHERE relpersistence IN ('u', 't')`
+    );
+    const cacheable = !sessionBound.length && await sessionSettings(db, schemaSql) === settingsBefore;
+    await db.exec(`COMMENT ON SCHEMA stardeck_test IS '${snapshotKey(schemaSql)}'`);
+    await db.exec("CHECKPOINT");
+    return { db, cacheable };
+  } catch (error) {
+    await db.close().catch(() => {
+    });
+    throw error;
+  }
+}
+function pruneSnapshots(dir) {
+  const snapshots = readdirSync(dir).filter((name) => name.endsWith(".tar")).map((name) => ({ path: join(dir, name), mtime: statSync(join(dir, name)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  for (const { path } of snapshots.slice(MAX_SNAPSHOTS)) rmSync(path, { force: true });
+}
+async function writeSnapshot(path, db) {
+  try {
+    const data = Buffer.from(await (await db.dumpDataDir("none")).arrayBuffer());
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, data);
+    renameSync(tmp, path);
+    pruneSnapshots(dirname(path));
+  } catch (error) {
+    console.warn(`[stardeck-testing] could not cache schema snapshot at ${path}:`, error);
+  }
+}
+async function loadSnapshot(path, key) {
+  let db = null;
+  try {
+    db = await createPgliteDatabase({ loadDataDir: new Blob([readFileSync(path)]) });
+    const { rows } = await db.query(
+      `SELECT obj_description(to_regnamespace('stardeck_test'), 'pg_namespace') AS key`
+    );
+    if (rows[0]?.key === key) {
+      const now3 = /* @__PURE__ */ new Date();
+      utimesSync(path, now3, now3);
+      return db;
+    }
+    console.warn(`[stardeck-testing] rebuilding schema snapshot ${path}: key mismatch`);
+  } catch (error) {
+    console.warn(`[stardeck-testing] rebuilding unreadable schema snapshot ${path}:`, error);
+  }
+  await db?.close().catch(() => {
+  });
+  return null;
+}
+async function bootWithSchema(schemaSql) {
+  const path = snapshotPath(schemaSql);
+  if (existsSync(path)) {
+    const loaded = await loadSnapshot(path, snapshotKey(schemaSql));
+    if (loaded) return loaded;
+  }
+  const { db, cacheable } = await buildSchemaDatabase(schemaSql);
+  if (cacheable) await writeSnapshot(path, db);
+  return db;
+}
+
 // src/global-singleton.ts
 function globalSingleton(key, create) {
   const symbol = /* @__PURE__ */ Symbol.for(`stardeck-testing.${key}`);
@@ -3198,8 +3396,8 @@ function buildUser(partial) {
 function loadSchemaSql(options) {
   if (options.schemaSql !== void 0) return options.schemaSql;
   if (options.schema === null) return null;
-  const schemaPath = resolve(process.cwd(), options.schema ?? DEFAULT_SCHEMA_PATH);
-  if (!existsSync(schemaPath)) {
+  const schemaPath = resolve2(process.cwd(), options.schema ?? DEFAULT_SCHEMA_PATH);
+  if (!existsSync2(schemaPath)) {
     if (options.schema) {
       throw new Error(
         `[stardeck-testing] Schema snapshot not found at ${schemaPath}. Run \`npx stardeck-data-store generate-types\` to regenerate it.`
@@ -3207,7 +3405,7 @@ function loadSchemaSql(options) {
     }
     return null;
   }
-  return readFileSync(schemaPath, "utf-8");
+  return readFileSync2(schemaPath, "utf-8");
 }
 async function createTestApp(options = {}) {
   if (state.db) {
@@ -3218,15 +3416,23 @@ async function createTestApp(options = {}) {
   applyTestEnv(options);
   state.allowNetwork = options.allowNetwork ?? false;
   installFetchRouter();
-  const db = await createPgliteDatabase();
+  const schemaSql = loadSchemaSql(options) ?? "";
+  const db = await bootWithSchema(schemaSql);
   state.db = db;
-  const initialize = async () => {
-    const schemaSql = loadSchemaSql(options);
-    if (schemaSql) await applySchema(db, schemaSql);
+  let baseline;
+  const seed = async () => {
     if (options.seed) await options.seed(db);
+    await acceptSchemaChanges(db);
+  };
+  const rebuild = async () => {
+    await dropAllTables(db);
+    await applySchema(db, schemaSql);
+    baseline = await captureBaseline(db);
+    await seed();
   };
   try {
-    await initialize();
+    baseline = await captureBaseline(db);
+    await seed();
   } catch (error) {
     state.db = null;
     await db.close().catch(() => {
@@ -3272,12 +3478,15 @@ async function createTestApp(options = {}) {
       return tokens;
     },
     async reset(resetOptions) {
-      if (resetOptions?.mode === "data") {
-        await truncateAllTables(db);
-        if (options.seed) await options.seed(db);
+      if (resetOptions?.mode === "schema" || !baseline || await schemaChangedSinceBaseline(db)) {
+        await rebuild();
       } else {
-        await dropAllTables(db);
-        await initialize();
+        await restoreBaseline(db, baseline);
+        try {
+          await seed();
+        } catch {
+          await rebuild();
+        }
       }
       state.currentUser = null;
       state.sessions.clear();

package/dist/setup.js

@@ -504,6 +504,8 @@ var import_citext = require("@electric-sql/pglite/contrib/citext");
 var import_pg_trgm = require("@electric-sql/pglite/contrib/pg_trgm");
 var import_pgcrypto = require("@electric-sql/pglite/contrib/pgcrypto");
 var import_uuid_ossp = require("@electric-sql/pglite/contrib/uuid_ossp");
+var EXTENSIONS = { pg_trgm: import_pg_trgm.pg_trgm, pgcrypto: import_pgcrypto.pgcrypto, uuid_ossp: import_uuid_ossp.uuid_ossp, citext: import_citext.citext };
+var PGLITE_EXTENSION_NAMES = Object.keys(EXTENSIONS);
 var identityParsers = null;
 function getIdentityParsers() {
   if (!identityParsers) {

package/dist/setup.mjs

@@ -480,6 +480,8 @@ import { citext } from "@electric-sql/pglite/contrib/citext";
 import { pg_trgm } from "@electric-sql/pglite/contrib/pg_trgm";
 import { pgcrypto } from "@electric-sql/pglite/contrib/pgcrypto";
 import { uuid_ossp } from "@electric-sql/pglite/contrib/uuid_ossp";
+var EXTENSIONS = { pg_trgm, pgcrypto, uuid_ossp, citext };
+var PGLITE_EXTENSION_NAMES = Object.keys(EXTENSIONS);
 var identityParsers = null;
 function getIdentityParsers() {
   if (!identityParsers) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stardeck-customer-apps/testing",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Vitest test harness for Stardeck customer apps — in-process Postgres (PGlite) plus a control-plane simulator so the real Stardeck SDKs run unmodified in tests",
   "main": "dist/index.js",
   "module": "dist/index.mjs",