@stardeck-customer-apps/testing 0.19.0 → 0.21.0

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
     });
   }
@@ -2914,6 +3102,7 @@ function createEdge() {
 }
 
 // src/simulator/starlens.ts
+var LATEST_VERSION = "v2";
 function starlensFailure(error, status, code) {
   return json({ success: false, error, code }, status);
 }
@@ -2932,11 +3121,18 @@ function nullFlagged(output, issues) {
   }
   return copy;
 }
-async function handleStarlensExtract(request, signedDeploymentId) {
-  const body = await readJsonBody(request);
-  if (signedDeploymentId !== null && body.deploymentId !== signedDeploymentId) {
-    return starlensFailure("Deployment ID mismatch", 401, "AUTHENTICATION_ERROR");
-  }
+function isInputShape(input) {
+  if (!input || typeof input !== "object") return false;
+  const i = input;
+  return typeof i.url === "string" || typeof i.data === "string" && i.data.length > 0 && typeof i.mediaType === "string";
+}
+var NON_IMAGE_EXTENSION = /\.(pdf|mp3|m4a|wav|ogg|aac|flac|mp4|mov|webm|mkv)(\?|#|$)/i;
+function isCroppable(input) {
+  if (typeof input.mediaType === "string") return input.mediaType.startsWith("image/");
+  const name = typeof input.filename === "string" ? input.filename : input.url;
+  return !(typeof name === "string" && NON_IMAGE_EXTENSION.test(name));
+}
+function validateStarlensBody(body) {
   const inputs = Array.isArray(body.inputs) ? body.inputs : [];
   if (inputs.length === 0) {
     return starlensFailure(
@@ -2945,6 +3141,13 @@ async function handleStarlensExtract(request, signedDeploymentId) {
       "VALIDATION_ERROR"
     );
   }
+  if (!inputs.every(isInputShape)) {
+    return starlensFailure(
+      "Validation failed \u2014 inputs: each input needs a url, or data with a mediaType",
+      400,
+      "VALIDATION_ERROR"
+    );
+  }
   const schema = body.schema;
   if (!schema || schema.type !== "object" || typeof schema.properties !== "object") {
     return starlensFailure(
@@ -2953,8 +3156,35 @@ async function handleStarlensExtract(request, signedDeploymentId) {
       "VALIDATION_ERROR"
     );
   }
+  const version = body.version ?? "latest";
+  if (version !== "v1" && version !== "v2" && version !== "latest") {
+    return starlensFailure("Validation failed \u2014 version: unknown version", 400, "VALIDATION_ERROR");
+  }
+  const effort = body.effort ?? "low";
+  if (effort !== "low" && effort !== "high") {
+    return starlensFailure("Validation failed \u2014 effort: low or high", 400, "VALIDATION_ERROR");
+  }
+  const resolved = version === "latest" ? LATEST_VERSION : version;
+  if (effort === "high" && resolved === "v1") {
+    return starlensFailure(
+      `Starlens v1 does not support effort "high"; use version "v2"`,
+      400,
+      "unsupported_effort"
+    );
+  }
+  return { version, resolved, effort, inputs, schema };
+}
+async function handleStarlensExtract(request, signedDeploymentId) {
+  const body = await readJsonBody(request);
+  const valid = validateStarlensBody(body);
+  if (valid instanceof Response) return valid;
+  const { version, resolved, effort, inputs, schema } = valid;
+  if (signedDeploymentId !== null && body.deploymentId !== signedDeploymentId) {
+    return starlensFailure("Deployment ID mismatch", 401, "AUTHENTICATION_ERROR");
+  }
   const call = {
-    version: typeof body.version === "string" ? body.version : "latest",
+    version,
+    effort,
     inputs: inputs.map((i) => ({
       name: typeof i.filename === "string" ? i.filename : typeof i.url === "string" ? i.url : "upload",
       mediaType: typeof i.mediaType === "string" ? i.mediaType : null,
@@ -2976,8 +3206,10 @@ async function handleStarlensExtract(request, signedDeploymentId) {
     return starlensFailure(reply.reject, 422, "unsupported_document");
   }
   const issues = reply.issues ?? [];
+  const ran = reply.effort ?? (effort === "high" && !inputs.some(isCroppable) ? "low" : effort);
   return success({
-    version: call.version === "latest" ? "v1" : call.version,
+    version: resolved,
+    effort: ran,
     output: nullFlagged(reply.output, issues),
     issues,
     usage: { inputTokens: 0, outputTokens: 0, cost: 0 }
@@ -3247,8 +3479,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 +3488,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 +3499,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 +3553,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();