@malloy-publisher/server 0.0.234 → 0.0.236

package/tests/integration/legacy_routes/legacy_routes.integration.spec.ts

@@ -1,259 +0,0 @@
-/// <reference types="bun-types" />
-
-// TODO: Remove this during projects cleanup
-/**
- * Smoke tests for the legacy `/api/v0/projects/...` REST surface registered
- * by `server-old.ts`. These routes exist purely to keep pre-rename SDK
- * clients (e.g. `@malloydata/db-publisher`) working after the
- * projects→environments rename.
- *
- * One test per route group: projects CRUD, packages, connections, models,
- * notebooks, databases, queries, materializations, manifest. The
- * materialization test additionally asserts the response field rename
- * (`projectId` not `environmentId`). `/status` is no longer in the legacy
- * surface — both old and new clients hit the single `/api/v0/status`
- * handler in server.ts, which returns `environments`.
- *
- * This file is intentionally separate from the regular integration suite so
- * it can be deleted in one motion when legacy support is dropped.
- */
-
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import path from "path";
-import { fileURLToPath } from "url";
-import { RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Use a distinct project name so this suite doesn't collide with the
-// materialization integration suite (which also uses "test-project") if
-// they ever run in the same DB instance.
-const PROJECT_NAME = "legacy-routes-test-project";
-const PACKAGE_NAME = "persist-test";
-
-describe("Legacy /api/v0/projects/* REST routes (E2E)", () => {
-   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
-   let baseUrl: string;
-
-   beforeAll(async () => {
-      env = await startRestE2E();
-      baseUrl = env.baseUrl;
-
-      // Create the test environment via the LEGACY route — proves POST
-      // /projects works end-to-end.
-      const fixtureDir = path.resolve(__dirname, "../../fixtures/persist-test");
-      const createRes = await fetch(`${baseUrl}/api/v0/projects`, {
-         method: "POST",
-         headers: { "Content-Type": "application/json" },
-         body: JSON.stringify({
-            name: PROJECT_NAME,
-            packages: [{ name: PACKAGE_NAME, location: fixtureDir }],
-            connections: [],
-         }),
-      });
-      if (!createRes.ok) {
-         const body = await createRes.text();
-         throw new Error(
-            `Failed to create test project via legacy route (${createRes.status}): ${body}`,
-         );
-      }
-
-      // Wait for the package to finish loading via the legacy GET path.
-      const deadline = Date.now() + 30_000;
-      let pkgReady = false;
-      while (!pkgReady && Date.now() < deadline) {
-         try {
-            const res = await fetch(
-               `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}`,
-            );
-            if (res.ok) {
-               pkgReady = true;
-               break;
-            }
-         } catch {
-            // not ready yet
-         }
-         await new Promise((r) => setTimeout(r, 500));
-      }
-      if (!pkgReady) {
-         throw new Error("Test package did not become available in time");
-      }
-   });
-
-   afterAll(async () => {
-      if (baseUrl) {
-         try {
-            // Clean up via the legacy DELETE route.
-            await fetch(`${baseUrl}/api/v0/projects/${PROJECT_NAME}`, {
-               method: "DELETE",
-            });
-         } catch {
-            // best-effort cleanup
-         }
-      }
-      await env?.stop();
-      env = null;
-   });
-
-   describe("projects CRUD", () => {
-      it("GET /projects lists environments under the legacy URL", async () => {
-         const res = await fetch(`${baseUrl}/api/v0/projects`);
-         expect(res.status).toBe(200);
-         const body = (await res.json()) as Array<{ name?: string }>;
-         expect(Array.isArray(body)).toBe(true);
-         expect(body.some((e) => e.name === PROJECT_NAME)).toBe(true);
-      });
-
-      it("GET /projects/:projectName returns the project", async () => {
-         const res = await fetch(`${baseUrl}/api/v0/projects/${PROJECT_NAME}`);
-         expect(res.status).toBe(200);
-         const body = (await res.json()) as { name?: string };
-         expect(body.name).toBe(PROJECT_NAME);
-      });
-   });
-
-   describe("packages", () => {
-      it("GET /projects/:projectName/packages returns the package list", async () => {
-         const res = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages`,
-         );
-         expect(res.status).toBe(200);
-         const body = (await res.json()) as Array<{ name?: string }>;
-         expect(Array.isArray(body)).toBe(true);
-         expect(body.some((p) => p.name === PACKAGE_NAME)).toBe(true);
-      });
-
-      it("GET /projects/:projectName/packages/:packageName returns the package", async () => {
-         const res = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}`,
-         );
-         expect(res.status).toBe(200);
-         const body = (await res.json()) as { name?: string };
-         expect(body.name).toBe(PACKAGE_NAME);
-      });
-   });
-
-   describe("connections", () => {
-      it("GET /projects/:projectName/connections returns 200 (may be empty)", async () => {
-         const res = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/connections`,
-         );
-         expect(res.status).toBe(200);
-         const body = await res.json();
-         expect(Array.isArray(body)).toBe(true);
-      });
-   });
-
-   describe("models", () => {
-      it("GET /projects/:projectName/packages/:packageName/models returns the model list", async () => {
-         const res = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/models`,
-         );
-         expect(res.status).toBe(200);
-         const body = await res.json();
-         expect(Array.isArray(body)).toBe(true);
-      });
-   });
-
-   describe("notebooks", () => {
-      it("GET /projects/:projectName/packages/:packageName/notebooks returns 200", async () => {
-         const res = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/notebooks`,
-         );
-         expect(res.status).toBe(200);
-         const body = await res.json();
-         expect(Array.isArray(body)).toBe(true);
-      });
-   });
-
-   describe("databases", () => {
-      it("GET /projects/:projectName/packages/:packageName/databases returns 200", async () => {
-         const res = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/databases`,
-         );
-         expect(res.status).toBe(200);
-         const body = await res.json();
-         expect(Array.isArray(body)).toBe(true);
-      });
-   });
-
-   describe("queries", () => {
-      it("POST /projects/:projectName/packages/:packageName/models/.../query reaches the handler", async () => {
-         // Hit the route with a bogus model name. We only need to prove the
-         // legacy URL is wired up to the controller — a structured JSON
-         // error (not Express's HTML fall-through 404) is sufficient signal.
-         const res = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/models/does-not-exist.malloy/query`,
-            {
-               method: "POST",
-               headers: { "Content-Type": "application/json" },
-               body: JSON.stringify({ query: "run: nothing" }),
-            },
-         );
-         expect(res.status).toBeGreaterThanOrEqual(400);
-         expect(res.status).toBeLessThan(600);
-         // Controller errors come back as JSON with a `message` field.
-         // An unhandled Express 404 returns HTML — that would fail here.
-         const body = (await res.json()) as Record<string, unknown>;
-         expect(typeof body.message).toBe("string");
-      });
-   });
-
-   describe("materializations", () => {
-      it("GET list and POST create return 'projectId' (not 'environmentId') under the legacy URL", async () => {
-         const listRes = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/materializations`,
-         );
-         expect(listRes.status).toBe(200);
-         const list = (await listRes.json()) as unknown;
-         expect(Array.isArray(list)).toBe(true);
-
-         // Create one so we can assert the field rename on a populated payload.
-         const createRes = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/materializations`,
-            {
-               method: "POST",
-               headers: { "Content-Type": "application/json" },
-               body: JSON.stringify({ autoLoadManifest: true }),
-            },
-         );
-         expect(createRes.status).toBe(201);
-         const created = (await createRes.json()) as Record<string, unknown>;
-
-         // Legacy contract: materialization payloads expose `projectId`, not
-         // `environmentId`. This is the response remapper in server-old.ts.
-         expect(created).toHaveProperty("projectId");
-         expect(created).not.toHaveProperty("environmentId");
-
-         const id = created.id as string;
-         // Best-effort cleanup so we don't leak a PENDING materialization
-         // into other tests. We don't poll-to-terminal; the suite teardown
-         // of the project will mop up.
-         try {
-            await fetch(
-               `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/materializations/${id}?action=stop`,
-               { method: "POST" },
-            );
-            await fetch(
-               `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/materializations/${id}`,
-               { method: "DELETE" },
-            );
-         } catch {
-            // ignore
-         }
-      });
-   });
-
-   describe("manifest", () => {
-      it("GET /projects/:projectName/packages/:packageName/manifest returns 200 or a structured 4xx", async () => {
-         const res = await fetch(
-            `${baseUrl}/api/v0/projects/${PROJECT_NAME}/packages/${PACKAGE_NAME}/manifest`,
-         );
-         // Without a built materialization the manifest may be empty/404 —
-         // we only assert the legacy URL reaches the handler, not 404 from
-         // Express's catch-all.
-         expect([200, 400, 404]).toContain(res.status);
-      });
-   });
-});

package/tests/integration/materialization/environment_list.integration.spec.ts

@@ -1,133 +0,0 @@
-/// <reference types="bun-types" />
-
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import path from "path";
-import { fileURLToPath } from "url";
-import { RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const PROJECT = "env-mat-list-project";
-const PKG_A = "persist-test";
-const PKG_B = "persist-schedule-test";
-const ENV_MATS_PATH = `/api/v0/environments/${PROJECT}/packages/materializations`;
-
-// Verifies the environment-scoped list:
-// GET /environments/{env}/packages/materializations returns runs from every
-// package in the env, newest-first, each labeled with its packageName.
-describe("Environment-scoped materialization list", () => {
-   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
-   let baseUrl: string;
-
-   const fixture = (name: string) =>
-      path.resolve(__dirname, `../../fixtures/${name}`);
-
-   async function createAndFinish(pkg: string): Promise<string> {
-      const res = await fetch(
-         `${baseUrl}/api/v0/environments/${PROJECT}/packages/${pkg}/materializations`,
-         {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ forceRefresh: true }),
-         },
-      );
-      expect(res.status).toBe(201);
-      const created = (await res.json()) as { id: string };
-      const deadline = Date.now() + 60_000;
-      while (Date.now() < deadline) {
-         const poll = await fetch(
-            `${baseUrl}/api/v0/environments/${PROJECT}/packages/${pkg}/materializations/${created.id}`,
-         );
-         const m = (await poll.json()) as { status: string };
-         if (
-            ["MANIFEST_FILE_READY", "FAILED", "CANCELLED"].includes(m.status)
-         ) {
-            break;
-         }
-         await new Promise((r) => setTimeout(r, 250));
-      }
-      return created.id;
-   }
-
-   beforeAll(async () => {
-      env = await startRestE2E();
-      baseUrl = env.baseUrl;
-
-      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
-         method: "POST",
-         headers: { "Content-Type": "application/json" },
-         body: JSON.stringify({
-            name: PROJECT,
-            packages: [
-               { name: PKG_A, location: fixture(PKG_A) },
-               { name: PKG_B, location: fixture(PKG_B) },
-            ],
-            connections: [],
-         }),
-      });
-      if (!createRes.ok) {
-         throw new Error(
-            `Failed to create project (${createRes.status}): ${await createRes.text()}`,
-         );
-      }
-
-      // Wait for both packages to load.
-      for (const pkg of [PKG_A, PKG_B]) {
-         const deadline = Date.now() + 30_000;
-         while (Date.now() < deadline) {
-            const res = await fetch(
-               `${baseUrl}/api/v0/environments/${PROJECT}/packages/${pkg}`,
-            );
-            if (res.ok) break;
-            await new Promise((r) => setTimeout(r, 500));
-         }
-      }
-   });
-
-   afterAll(async () => {
-      if (baseUrl) {
-         try {
-            await fetch(`${baseUrl}/api/v0/environments/${PROJECT}`, {
-               method: "DELETE",
-            });
-         } catch {
-            // best-effort
-         }
-      }
-      await env?.stop();
-      env = null;
-   });
-
-   it("returns materializations from every package in the environment", async () => {
-      await createAndFinish(PKG_A);
-      await createAndFinish(PKG_B);
-
-      const res = await fetch(`${baseUrl}${ENV_MATS_PATH}`);
-      expect(res.status).toBe(200);
-      const rows = (await res.json()) as Array<{
-         packageName: string;
-         createdAt?: string;
-      }>;
-
-      const packages = new Set(rows.map((r) => r.packageName));
-      expect(packages.has(PKG_A)).toBe(true);
-      expect(packages.has(PKG_B)).toBe(true);
-
-      // Newest-first ordering.
-      const times = rows
-         .map((r) => (r.createdAt ? new Date(r.createdAt).getTime() : 0))
-         .filter((t) => t > 0);
-      const sorted = [...times].sort((a, b) => b - a);
-      expect(times).toEqual(sorted);
-   });
-
-   it("does not shadow the per-package list route", async () => {
-      const res = await fetch(
-         `${baseUrl}/api/v0/environments/${PROJECT}/packages/${PKG_A}/materializations`,
-      );
-      expect(res.status).toBe(200);
-      const rows = (await res.json()) as Array<{ packageName: string }>;
-      expect(rows.every((r) => r.packageName === PKG_A)).toBe(true);
-   });
-});

package/tests/integration/materialization/freshness_gate.integration.spec.ts

@@ -1,292 +0,0 @@
-/// <reference types="bun-types" />
-
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import * as fsp from "fs/promises";
-import os from "os";
-import path from "path";
-import { fileURLToPath } from "url";
-import { RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const PROJECT_NAME = "freshness-gate-project";
-const PACKAGE_NAME = "persist-test";
-const MODEL_PATH = "persist_test.malloy";
-const API = `/api/v0/environments/${PROJECT_NAME}/packages/${PACKAGE_NAME}`;
-
-/**
- * Covers the per-query freshness gate (persistence.md §9.3, §14 Phase B): a
- * query on a `#@ persist` source uses its materialized table only while the
- * table is within its declared freshness window; otherwise it falls back per the
- * entry's declared `fallback`.
- *
- *  - fresh (or un-gated)      → routes to the materialized table
- *  - stale + fallback live    → serves live SQL (entry dropped)
- *  - stale + fallback stale_ok→ serves the stale table
- *  - a fresh entry that crosses its window → serves live on the NEXT query,
- *    with no rebind (proves per-query re-evaluation, not bind-time filtering)
- *
- * The manifest is bound once physically (auto-run builds the table), then a
- * manifest URI keyed by the source's real sourceEntityId routes served queries.
- * `executedSql()` is the routing evidence: it scans `order_summary` when routed
- * to the table, and `data/orders.csv` when serving live.
- */
-describe("Per-query freshness gate (E2E)", () => {
-   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
-   let baseUrl: string;
-   let tmpDir: string;
-   let sourceEntityId: string;
-
-   beforeAll(async () => {
-      env = await startRestE2E();
-      baseUrl = env.baseUrl;
-      tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), "freshness-gate-"));
-
-      const fixtureDir = path.resolve(__dirname, "../../fixtures/persist-test");
-      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
-         method: "POST",
-         headers: { "Content-Type": "application/json" },
-         body: JSON.stringify({
-            name: PROJECT_NAME,
-            packages: [{ name: PACKAGE_NAME, location: fixtureDir }],
-            connections: [],
-         }),
-      });
-      if (!createRes.ok) {
-         throw new Error(
-            `Failed to create test project (${createRes.status}): ${await createRes.text()}`,
-         );
-      }
-
-      const deadline = Date.now() + 30_000;
-      while (Date.now() < deadline) {
-         const res = await fetch(`${baseUrl}${API}`);
-         if (res.ok) break;
-         await new Promise((r) => setTimeout(r, 500));
-      }
-
-      // Physically build the persist source (auto-run self-assigns
-      // physicalTableName = "order_summary"), then revert to live so the
-      // manifest-URI bind is the only thing that can route the served query.
-      await buildTableThenRevertToLive();
-      sourceEntityId = await orderSummarySourceEntityId();
-   }, 120_000);
-
-   afterAll(async () => {
-      if (baseUrl) {
-         await fetch(`${baseUrl}/api/v0/environments/${PROJECT_NAME}`, {
-            method: "DELETE",
-         }).catch(() => {});
-      }
-      await env?.stop();
-      await fsp.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
-      env = null;
-   });
-
-   function url(p: string): string {
-      return `${baseUrl}${API}${p}`;
-   }
-
-   const ROUTING_QUERY = "run: order_summary -> { aggregate: c is count() }";
-
-   /** The SQL the served query actually compiled to (routing evidence). */
-   async function executedSql(): Promise<string> {
-      const res = await fetch(`${baseUrl}${API}/models/${MODEL_PATH}/query`, {
-         method: "POST",
-         headers: { "Content-Type": "application/json" },
-         body: JSON.stringify({ query: ROUTING_QUERY }),
-      });
-      expect(res.status).toBe(200);
-      const body = (await res.json()) as { result: string };
-      return (JSON.parse(body.result) as { sql: string }).sql;
-   }
-
-   async function orderSummarySourceEntityId(): Promise<string> {
-      const res = await fetch(url(""));
-      expect(res.status).toBe(200);
-      const pkg = (await res.json()) as {
-         buildPlan?: { sources?: Record<string, { sourceEntityId?: string }> };
-      };
-      const sources = pkg.buildPlan?.sources ?? {};
-      const id = Object.values(sources)[0]?.sourceEntityId;
-      expect(typeof id).toBe("string");
-      return id as string;
-   }
-
-   async function pollUntilTerminal(
-      id: string,
-      timeoutMs = 90_000,
-   ): Promise<Record<string, unknown>> {
-      const terminal = ["MANIFEST_FILE_READY", "FAILED", "CANCELLED"];
-      const deadline = Date.now() + timeoutMs;
-      while (Date.now() < deadline) {
-         const res = await fetch(url(`/materializations/${id}`));
-         expect(res.status).toBe(200);
-         const data = (await res.json()) as Record<string, unknown>;
-         if (terminal.includes(data.status as string)) return data;
-         await new Promise((r) => setTimeout(r, 250));
-      }
-      throw new Error(`Materialization ${id} did not reach a terminal state`);
-   }
-
-   async function buildTableThenRevertToLive(): Promise<void> {
-      const createRes = await fetch(url("/materializations"), {
-         method: "POST",
-         headers: { "Content-Type": "application/json" },
-         body: JSON.stringify({}),
-      });
-      expect(createRes.status).toBe(201);
-      const { id } = (await createRes.json()) as { id: string };
-      const built = await pollUntilTerminal(id);
-      expect(built.status).toBe("MANIFEST_FILE_READY");
-      await fetch(url("?reload=true"));
-      await fetch(url(`/materializations/${id}`), { method: "DELETE" });
-   }
-
-   /** Write a CP-shaped manifest carrying the freshness fields. */
-   async function writeFreshnessManifest(opts: {
-      dataAsOf: string;
-      freshnessWindowSeconds: number;
-      freshnessFallback: "live" | "stale_ok" | "fail";
-   }): Promise<string> {
-      const file = path.join(
-         tmpDir,
-         `freshness-${Date.now()}-${Math.random()}.json`,
-      );
-      await fsp.writeFile(
-         file,
-         JSON.stringify({
-            builtAt: new Date().toISOString(),
-            strict: false,
-            entries: {
-               [sourceEntityId]: {
-                  sourceEntityId,
-                  sourceName: "order_summary",
-                  physicalTableName: "order_summary",
-                  connectionName: "duckdb",
-                  dataAsOf: opts.dataAsOf,
-                  freshnessWindowSeconds: opts.freshnessWindowSeconds,
-                  freshnessFallback: opts.freshnessFallback,
-               },
-            },
-         }),
-         "utf8",
-      );
-      return file;
-   }
-
-   async function bind(manifestFile: string): Promise<void> {
-      const patchRes = await fetch(url(""), {
-         method: "PATCH",
-         headers: { "Content-Type": "application/json" },
-         body: JSON.stringify({
-            name: PACKAGE_NAME,
-            manifestLocation: manifestFile,
-         }),
-      });
-      expect(patchRes.status).toBe(200);
-      const patched = (await patchRes.json()) as Record<string, unknown>;
-      // The bind is recorded regardless of per-query freshness — freshness is
-      // evaluated per query, not at bind.
-      expect(patched.manifestBindingStatus).toBe("bound");
-      expect(patched.manifestEntryCount).toBe(1);
-   }
-
-   async function revertToLive(): Promise<void> {
-      await fetch(url(""), {
-         method: "PATCH",
-         headers: { "Content-Type": "application/json" },
-         body: JSON.stringify({ name: PACKAGE_NAME, manifestLocation: null }),
-      });
-      await fetch(url("?reload=true"));
-   }
-
-   it(
-      "routes a fresh entry to the materialized table",
-      async () => {
-         const manifestFile = await writeFreshnessManifest({
-            dataAsOf: new Date().toISOString(),
-            freshnessWindowSeconds: 86_400, // 1 day — comfortably fresh
-            freshnessFallback: "live",
-         });
-         await bind(manifestFile);
-
-         const routed = await executedSql();
-         expect(routed).not.toContain("data/orders.csv");
-         expect(routed).toContain("order_summary");
-
-         await revertToLive();
-      },
-      { timeout: 120_000 },
-   );
-
-   it(
-      "serves live for a stale entry with fallback live",
-      async () => {
-         const manifestFile = await writeFreshnessManifest({
-            // 2h old against a 1h window ⇒ stale.
-            dataAsOf: new Date(Date.now() - 7200_000).toISOString(),
-            freshnessWindowSeconds: 3600,
-            freshnessFallback: "live",
-         });
-         await bind(manifestFile);
-
-         const served = await executedSql();
-         expect(served).toContain("data/orders.csv");
-
-         await revertToLive();
-      },
-      { timeout: 120_000 },
-   );
-
-   it(
-      "serves the stale table for a stale entry with fallback stale_ok",
-      async () => {
-         const manifestFile = await writeFreshnessManifest({
-            dataAsOf: new Date(Date.now() - 7200_000).toISOString(),
-            freshnessWindowSeconds: 3600,
-            freshnessFallback: "stale_ok",
-         });
-         await bind(manifestFile);
-
-         const served = await executedSql();
-         expect(served).not.toContain("data/orders.csv");
-         expect(served).toContain("order_summary");
-
-         await revertToLive();
-      },
-      { timeout: 120_000 },
-   );
-
-   it(
-      "serves live once a fresh entry crosses its window, with no rebind",
-      async () => {
-         const windowSeconds = 10;
-         const anchor = Date.now();
-         const manifestFile = await writeFreshnessManifest({
-            dataAsOf: new Date(anchor).toISOString(),
-            freshnessWindowSeconds: windowSeconds,
-            freshnessFallback: "live",
-         });
-         await bind(manifestFile);
-
-         // While inside the window, the served query routes to the table.
-         expect(Date.now() - anchor).toBeLessThan(windowSeconds * 1000);
-         const fresh = await executedSql();
-         expect(fresh).not.toContain("data/orders.csv");
-         expect(fresh).toContain("order_summary");
-
-         // Wait for the window to elapse — no rebind, no reload.
-         const waitMs = windowSeconds * 1000 - (Date.now() - anchor) + 1500;
-         await new Promise((r) => setTimeout(r, Math.max(waitMs, 0)));
-
-         // The very next query re-evaluates freshness and now serves live.
-         const afterCrossing = await executedSql();
-         expect(afterCrossing).toContain("data/orders.csv");
-
-         await revertToLive();
-      },
-      { timeout: 120_000 },
-   );
-});