@malloy-publisher/server 0.0.219 → 0.0.221

package/src/service/connection_fingerprint.spec.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "bun:test";
+import { components } from "../api";
+import {
+   buildEnvironmentMalloyConfig,
+   EnvironmentMalloyConfig,
+} from "./connection";
+
+type ApiConnection = components["schemas"]["Connection"];
+
+/**
+ * The connection `fingerprint` seam: when a connection carries an API
+ * fingerprint, the resolved Malloy connection's getDigest() must return it
+ * verbatim. Every consumer of a connection's identity — build planning, the
+ * package-load worker's digest RPC, and Malloy's serve-time manifest
+ * resolution — reads getDigest() off a connection resolved through the same
+ * environment lookup wrapper, so this one seam is what keeps build-time and
+ * serve-time source ids in agreement.
+ *
+ * Uses a postgres connection because it is constructed lazily (no network I/O
+ * until a query runs), so digests can be read offline.
+ */
+
+function pgConnection(overrides: Partial<ApiConnection> = {}): ApiConnection {
+   return {
+      name: "pg",
+      type: "postgres",
+      postgresConnection: {
+         host: "db.example.com",
+         port: 5432,
+         databaseName: "analytics",
+         userName: "svc_user",
+         password: "hunter2",
+      },
+      ...overrides,
+   };
+}
+
+async function digestOf(connection: ApiConnection): Promise<string> {
+   let config: EnvironmentMalloyConfig | undefined;
+   try {
+      config = buildEnvironmentMalloyConfig([connection]);
+      const resolved = await config.malloyConfig.connections.lookupConnection(
+         connection.name,
+      );
+      return resolved.getDigest();
+   } finally {
+      await config?.releaseConnections();
+   }
+}
+
+describe("connection fingerprint", () => {
+   it("uses the fingerprint verbatim as the connection digest", async () => {
+      const digest = await digestOf(
+         pgConnection({ fingerprint: "fp-opaque-token-1" }),
+      );
+      expect(digest).toBe("fp-opaque-token-1");
+   });
+
+   it("keeps the digest stable across a credential rotation", async () => {
+      const before = await digestOf(pgConnection({ fingerprint: "fp-stable" }));
+      const after = await digestOf(
+         pgConnection({
+            fingerprint: "fp-stable",
+            postgresConnection: {
+               host: "db.example.com",
+               port: 5432,
+               databaseName: "analytics",
+               userName: "rotated_user",
+               password: "rotated-password",
+            },
+         }),
+      );
+      expect(after).toBe(before);
+   });
+
+   it("changes the digest when the fingerprint changes", async () => {
+      const one = await digestOf(pgConnection({ fingerprint: "fp-1" }));
+      const two = await digestOf(pgConnection({ fingerprint: "fp-2" }));
+      expect(one).not.toBe(two);
+   });
+
+   it("falls back to the locally derived digest when omitted", async () => {
+      const digest = await digestOf(pgConnection());
+      expect(typeof digest).toBe("string");
+      expect(digest.length).toBeGreaterThan(0);
+      // Behavior is unchanged from before the fingerprint existed: the digest
+      // is the connection's own derivation, deterministic for one config.
+      expect(await digestOf(pgConnection())).toBe(digest);
+   });
+
+   it("round-trips the fingerprint on the API connection", async () => {
+      const config = buildEnvironmentMalloyConfig([
+         pgConnection({ fingerprint: "fp-round-trip" }),
+      ]);
+      try {
+         const api = config.apiConnections.find((c) => c.name === "pg");
+         expect(api?.fingerprint).toBe("fp-round-trip");
+      } finally {
+         await config.releaseConnections();
+      }
+   });
+});

package/src/service/manifest_loader.spec.ts

@@ -29,9 +29,9 @@ describe("fetchManifestEntries", () => {
          builtAt: new Date().toISOString(),
          strict: false,
          entries: {
-            b1: { buildId: "b1", physicalTableName: "schema.orders_mz" },
+            b1: { sourceEntityId: "b1", physicalTableName: "schema.orders_mz" },
             b2: {
-               buildId: "b2",
+               sourceEntityId: "b2",
                physicalTableName: "schema.daily_mz",
                connectionName: "bq",
             },
@@ -48,7 +48,7 @@ describe("fetchManifestEntries", () => {
 
    it("reads via a file:// URI", async () => {
       const file = await writeManifest({
-         entries: { b1: { buildId: "b1", physicalTableName: "t1" } },
+         entries: { b1: { sourceEntityId: "b1", physicalTableName: "t1" } },
       });
 
       const entries = await fetchManifestEntries(pathToFileURL(file).href);
@@ -59,8 +59,8 @@ describe("fetchManifestEntries", () => {
    it("skips entries without a physicalTableName", async () => {
       const file = await writeManifest({
          entries: {
-            good: { buildId: "good", physicalTableName: "t1" },
-            bad: { buildId: "bad" },
+            good: { sourceEntityId: "good", physicalTableName: "t1" },
+            bad: { sourceEntityId: "bad" },
          },
       });
 

package/src/service/manifest_loader.ts

@@ -58,7 +58,7 @@ async function readManifestBytes(uri: string): Promise<string> {
 
 /**
  * Fetch and parse the control-plane-computed build manifest at `uri`, returning
- * the Malloy-runtime binding map (`buildId -> { tableName }`). The wire manifest
+ * the Malloy-runtime binding map (`sourceEntityId -> { tableName }`). The wire manifest
  * keys physical tables under `physicalTableName`; the Malloy runtime consumes
  * `tableName`, so we translate here. Entries missing a physical table are
  * skipped. Throws if the URI can't be read or parsed.
@@ -80,16 +80,16 @@ export async function fetchManifestEntries(
    }
 
    const entries: BuildManifest["entries"] = {};
-   for (const [buildId, entry] of Object.entries(parsed.entries ?? {})) {
+   for (const [sourceEntityId, entry] of Object.entries(parsed.entries ?? {})) {
       const physicalTableName = entry?.physicalTableName;
       if (!physicalTableName) {
          logger.warn("Manifest entry has no physicalTableName; skipping", {
             uri,
-            buildId,
+            sourceEntityId,
          });
          continue;
       }
-      entries[buildId] = { tableName: physicalTableName };
+      entries[sourceEntityId] = { tableName: physicalTableName };
    }
    return entries;
 }

package/src/service/materialization_cron_gate.spec.ts

@@ -0,0 +1,137 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+
+import { Environment } from "./environment";
+import type { Package } from "./package";
+
+/**
+ * The publish gate for the package-level materialization cron (§9.4
+ * artifact-anchored scheduling): a declared `materialization.schedule` is the
+ * power tier and is valid only when every persist source in the compiled
+ * build plan resolves to an explicit `sharing=private`. These tests run a real
+ * `Environment` + `Package.create` over temp dirs, so they also prove
+ * end-to-end that the pinned compiler ACCEPTS `sharing=` / `refresh=` keys in
+ * the `#@ persist` annotation and that the values survive to the wire build
+ * plan verbatim (unset stays null — never defaulted to "shared").
+ */
+describe("materialization cron gate", () => {
+   let rootDir: string;
+   let envPath: string;
+
+   async function loadPackage(model: string, schedule?: string) {
+      const dir = path.join(envPath, "pkg");
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(
+         path.join(dir, "publisher.json"),
+         JSON.stringify({
+            name: "pkg",
+            description: "fixture",
+            ...(schedule ? { materialization: { schedule } } : {}),
+         }),
+      );
+      await fs.writeFile(path.join(dir, "model.malloy"), model);
+      const env = await Environment.create("testEnv", envPath, []);
+      await env.addPackage("pkg");
+      return env.getPackage("pkg", false);
+   }
+
+   function sourceByName(pkg: Package, name: string) {
+      const sources = pkg.getBuildPlan()?.sources ?? {};
+      const found = Object.values(sources).find((s) => s.name === name);
+      if (!found) throw new Error(`persist source '${name}' not in build plan`);
+      return found;
+   }
+
+   beforeEach(async () => {
+      rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "publisher-cron-"));
+      envPath = path.join(rootDir, "env");
+      await fs.mkdir(envPath, { recursive: true });
+   });
+
+   afterEach(async () => {
+      await fs.rm(rootDir, { recursive: true, force: true }).catch(() => {});
+   });
+
+   const MIXED_MODEL = `##! experimental.persistence
+
+#@ persist name="priv_table" sharing=private refresh=incremental
+source: priv is duckdb.sql("SELECT 1 as x")
+
+#@ persist name="open_table" sharing=shared
+source: open is duckdb.sql("SELECT 2 as x")
+
+#@ persist name="unset_table"
+source: unspecified is duckdb.sql("SELECT 3 as x")
+`;
+
+   const ALL_PRIVATE_MODEL = `##! experimental.persistence
+
+#@ persist name="a_table" sharing=private
+source: a is duckdb.sql("SELECT 1 as x")
+
+#@ persist name="b_table" sharing=private refresh=full
+source: b is duckdb.sql("SELECT 2 as x")
+`;
+
+   it(
+      "surfaces declared sharing/refresh verbatim on the build plan (null when unset)",
+      async () => {
+         const pkg = await loadPackage(MIXED_MODEL);
+
+         const priv = sourceByName(pkg, "priv");
+         expect(priv.sharing).toBe("private");
+         expect(priv.refresh).toBe("incremental");
+
+         const open = sourceByName(pkg, "open");
+         expect(open.sharing).toBe("shared");
+         expect(open.refresh).toBeNull();
+
+         // Unset must be reported as null — distinguishable from an explicit
+         // "shared" — because the control plane applies the platform default
+         // (unset => shared) itself.
+         const unspecified = sourceByName(pkg, "unspecified");
+         expect(unspecified.sharing).toBeNull();
+         expect(unspecified.refresh).toBeNull();
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "rejects a cron over shared/unset persist sources, pointing at freshness.window",
+      async () => {
+         const pkg = await loadPackage(MIXED_MODEL, "0 6 * * *");
+
+         const warnings = pkg.scheduleWarnings();
+         // One actionable message per offending source; the compliant private
+         // source is not flagged.
+         expect(warnings).toHaveLength(2);
+         const joined = pkg.formatInvalidSchedule();
+         expect(joined).toContain("'open' resolves to 'shared'");
+         expect(joined).toContain("'unspecified' resolves to unset");
+         expect(joined).not.toContain("'priv'");
+         expect(joined).toContain("materialization.freshness.window");
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "allows a cron when every persist source is explicitly private",
+      async () => {
+         const pkg = await loadPackage(ALL_PRIVATE_MODEL, "0 6 * * *");
+         expect(pkg.scheduleWarnings()).toEqual([]);
+         expect(pkg.formatInvalidSchedule()).toBe("");
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "is inert when no cron is declared, whatever the sources' sharing",
+      async () => {
+         const pkg = await loadPackage(MIXED_MODEL);
+         expect(pkg.scheduleWarnings()).toEqual([]);
+      },
+      { timeout: 30000 },
+   );
+});

package/src/service/materialization_schedule_surface.spec.ts

@@ -53,6 +53,30 @@ describe("materialization schedule surfacing", () => {
          const pkg = await env.getPackage("pkg", false);
          expect(pkg.getPackageMetadata().materialization).toEqual({
             schedule: "0 6 * * *",
+            freshness: null,
+         });
+      },
+      { timeout: 20000 },
+   );
+
+   it(
+      "surfaces the manifest's materialization.freshness on load",
+      async () => {
+         const env = await Environment.create("testEnv", envPath, []);
+         await writePackageDir({
+            materialization: {
+               freshness: { window: "24h", fallback: "stale_ok" },
+            },
+         });
+         await env.addPackage("pkg");
+
+         // Freshness rides the same channel as schedule: present-and-verbatim
+         // when declared, null when unset — the control plane owns the
+         // scheduling/gating logic and only needs the values surfaced.
+         const pkg = await env.getPackage("pkg", false);
+         expect(pkg.getPackageMetadata().materialization).toEqual({
+            schedule: null,
+            freshness: { window: "24h", fallback: "stale_ok" },
          });
       },
       { timeout: 20000 },
@@ -71,6 +95,7 @@ describe("materialization schedule surfacing", () => {
          const pkg = await env.getPackage("pkg", false);
          expect(pkg.getPackageMetadata().materialization).toEqual({
             schedule: null,
+            freshness: null,
          });
       },
       { timeout: 20000 },
@@ -91,11 +116,15 @@ describe("materialization schedule surfacing", () => {
             name: "pkg",
             description: "updated",
          });
-         expect(updated.materialization).toEqual({ schedule: "0 6 * * *" });
+         expect(updated.materialization).toEqual({
+            schedule: "0 6 * * *",
+            freshness: null,
+         });
 
          const pkg = await env.getPackage("pkg", false);
          expect(pkg.getPackageMetadata().materialization).toEqual({
             schedule: "0 6 * * *",
+            freshness: null,
          });
       },
       { timeout: 20000 },

package/src/service/materialization_service.spec.ts

@@ -236,13 +236,15 @@ describe("MaterializationService", () => {
          ).toMatchObject({ mode: "orchestrated" });
       });
 
-      it("rejects instructions referencing an unknown buildId before creating", async () => {
+      it("rejects instructions referencing an unknown sourceEntityId before creating", async () => {
          setPackage(ctx.environmentStore, {
             getBuildPlan: () => makeBuildPlan(),
          });
          await expect(
             ctx.service.createMaterialization("my-env", "pkg", {
-               buildInstructions: [makeInstruction({ buildId: "ghost" })],
+               buildInstructions: [
+                  makeInstruction({ sourceEntityId: "ghost" }),
+               ],
             }),
          ).rejects.toThrow(BadRequestError);
          expect(ctx.repository.createMaterialization.called).toBe(false);
@@ -347,7 +349,7 @@ describe("MaterializationService", () => {
                   strict: false,
                   entries: {
                      b1: {
-                        buildId: "b1",
+                        sourceEntityId: "b1",
                         physicalTableName: "orders_mz",
                         connectionName: "duckdb",
                      },
@@ -383,7 +385,7 @@ describe("MaterializationService", () => {
                   strict: false,
                   entries: {
                      b1: {
-                        buildId: "b1",
+                        sourceEntityId: "b1",
                         physicalTableName: "orders_mz",
                         connectionName: "duckdb",
                      },
@@ -423,7 +425,7 @@ describe("MaterializationService", () => {
                   strict: false,
                   entries: {
                      b1: {
-                        buildId: "b1",
+                        sourceEntityId: "b1",
                         // Container path on a hyphenated BigQuery project: each
                         // segment must be backtick-quoted independently.
                         physicalTableName: "my-proj.ds.engaged",
@@ -460,7 +462,7 @@ describe("MaterializationService", () => {
                   strict: false,
                   entries: {
                      b1: {
-                        buildId: "b1",
+                        sourceEntityId: "b1",
                         physicalTableName: "orders_mz",
                         connectionName: "duckdb",
                      },
@@ -481,7 +483,7 @@ describe("MaterializationService", () => {
 });
 
 describe("stagingSuffix", () => {
-   it("derives a short, stable suffix from the buildId", () => {
+   it("derives a short, stable suffix from the sourceEntityId", () => {
       expect(stagingSuffix("abcdef1234567890")).toBe("_abcdef123456");
    });
 });
@@ -492,17 +494,17 @@ describe("deriveSelfInstructions", () => {
       ctx = createMocks();
    });
 
-   it("carries forward unchanged buildIds and builds the rest (deduping repeats)", () => {
+   it("carries forward unchanged sourceEntityIds and builds the rest (deduping repeats)", () => {
       const compiled = compiledWith(
          {
-            s1: fakeSource({ name: "s1", buildId: "b1aaaaaaaaaaaaaa" }),
-            s2: fakeSource({ name: "s2", buildId: "b2bbbbbbbbbbbbbb" }),
+            s1: fakeSource({ name: "s1", sourceEntityId: "b1aaaaaaaaaaaaaa" }),
+            s2: fakeSource({ name: "s2", sourceEntityId: "b2bbbbbbbbbbbbbb" }),
          },
          [["s1", "s2"], ["s2"]],
       );
       const priorEntries = {
          b1aaaaaaaaaaaaaa: {
-            buildId: "b1aaaaaaaaaaaaaa",
+            sourceEntityId: "b1aaaaaaaaaaaaaa",
             physicalTableName: "s1_prev",
             connectionName: "duckdb",
          },
@@ -519,7 +521,7 @@ describe("deriveSelfInstructions", () => {
       ).deriveSelfInstructions(compiled, undefined, priorEntries);
 
       expect(instructions).toHaveLength(1);
-      expect(instructions[0].buildId).toBe("b2bbbbbbbbbbbbbb");
+      expect(instructions[0].sourceEntityId).toBe("b2bbbbbbbbbbbbbb");
       expect(instructions[0].physicalTableName).toBe("s2");
       expect(instructions[0].realization).toBe("COPY");
       expect(instructions[0].materializedTableId).toBe("local-b2bbbbbbbbbb");
@@ -531,8 +533,8 @@ describe("deriveSelfInstructions", () => {
    it("honors the sourceNames filter (excluded sources are neither built nor carried)", () => {
       const compiled = compiledWith(
          {
-            s1: fakeSource({ name: "s1", buildId: "b1aaaaaaaaaaaaaa" }),
-            s2: fakeSource({ name: "s2", buildId: "b2bbbbbbbbbbbbbb" }),
+            s1: fakeSource({ name: "s1", sourceEntityId: "b1aaaaaaaaaaaaaa" }),
+            s2: fakeSource({ name: "s2", sourceEntityId: "b2bbbbbbbbbbbbbb" }),
          },
          [["s1", "s2"]],
       );
@@ -547,7 +549,7 @@ describe("deriveSelfInstructions", () => {
       ).deriveSelfInstructions(compiled, ["s2"], {});
 
       expect(instructions).toHaveLength(1);
-      expect(instructions[0].buildId).toBe("b2bbbbbbbbbbbbbb");
+      expect(instructions[0].sourceEntityId).toBe("b2bbbbbbbbbbbbbb");
       expect(Object.keys(carried as Record<string, unknown>)).toHaveLength(0);
    });
 });
@@ -561,7 +563,7 @@ describe("getMostRecentManifestEntries (skip-if-unchanged)", () => {
    it("returns entries from the most recent successful run, excluding the in-flight one", async () => {
       const entries = {
          b1: {
-            buildId: "b1",
+            sourceEntityId: "b1",
             physicalTableName: "orders_v1",
             connectionName: "duckdb",
          },
@@ -599,7 +601,9 @@ describe("getMostRecentManifestEntries (skip-if-unchanged)", () => {
             manifest: {
                builtAt: "t",
                strict: false,
-               entries: { b1: { buildId: "b1", physicalTableName: "t1" } },
+               entries: {
+                  b1: { sourceEntityId: "b1", physicalTableName: "t1" },
+               },
             },
          }),
       ]);
@@ -679,8 +683,8 @@ describe("executeInstructedBuild", () => {
    it("builds instructed sources in dependency order and seeds carried entries", async () => {
       const runSQL = sinon.stub().resolves();
       const connection = { runSQL } as unknown as MalloyConnection;
-      const s1 = fakeSource({ name: "s1", buildId: "b1aaaaaaaaaaaaaa" });
-      const s2 = fakeSource({ name: "s2", buildId: "b2bbbbbbbbbbbbbb" });
+      const s1 = fakeSource({ name: "s1", sourceEntityId: "b1aaaaaaaaaaaaaa" });
+      const s2 = fakeSource({ name: "s2", sourceEntityId: "b2bbbbbbbbbbbbbb" });
       const compiled = compiledWith(
          { s1, s2 },
          [["s1"], ["s2"]],
@@ -691,13 +695,13 @@ describe("executeInstructedBuild", () => {
          compiled,
          [
             {
-               buildId: "b1aaaaaaaaaaaaaa",
+               sourceEntityId: "b1aaaaaaaaaaaaaa",
                materializedTableId: "mt-1",
                physicalTableName: "s1_v1",
                realization: "COPY",
             },
             {
-               buildId: "b2bbbbbbbbbbbbbb",
+               sourceEntityId: "b2bbbbbbbbbbbbbb",
                materializedTableId: "mt-2",
                physicalTableName: "s2_v1",
                realization: "COPY",
@@ -705,7 +709,7 @@ describe("executeInstructedBuild", () => {
          ],
          {
             carried0: {
-               buildId: "carried0",
+               sourceEntityId: "carried0",
                physicalTableName: "carried_tbl",
                connectionName: "duckdb",
             },
@@ -725,8 +729,14 @@ describe("executeInstructedBuild", () => {
       // though the caller instructed it. Both must now build, `mid` first.
       const runSQL = sinon.stub().resolves();
       const connection = { runSQL } as unknown as MalloyConnection;
-      const root = fakeSource({ name: "root", buildId: "brootaaaaaaaaaa" });
-      const mid = fakeSource({ name: "mid", buildId: "bmidbbbbbbbbbbb" });
+      const root = fakeSource({
+         name: "root",
+         sourceEntityId: "brootaaaaaaaaaa",
+      });
+      const mid = fakeSource({
+         name: "mid",
+         sourceEntityId: "bmidbbbbbbbbbbb",
+      });
       const compiled = {
          graphs: [
             {
@@ -750,13 +760,13 @@ describe("executeInstructedBuild", () => {
          compiled,
          [
             {
-               buildId: "brootaaaaaaaaaa",
+               sourceEntityId: "brootaaaaaaaaaa",
                materializedTableId: "mt-r",
                physicalTableName: "root_v1",
                realization: "COPY",
             },
             {
-               buildId: "bmidbbbbbbbbbbb",
+               sourceEntityId: "bmidbbbbbbbbbbb",
                materializedTableId: "mt-m",
                physicalTableName: "mid_v1",
                realization: "COPY",
@@ -779,7 +789,7 @@ describe("executeInstructedBuild", () => {
    });
 
    it("throws when an instructed graph's connection is missing", async () => {
-      const s1 = fakeSource({ name: "s1", buildId: "b1aaaaaaaaaaaaaa" });
+      const s1 = fakeSource({ name: "s1", sourceEntityId: "b1aaaaaaaaaaaaaa" });
       const compiled = compiledWith({ s1 }, [["s1"]], new Map());
 
       await expect(
@@ -787,7 +797,7 @@ describe("executeInstructedBuild", () => {
             compiled,
             [
                {
-                  buildId: "b1aaaaaaaaaaaaaa",
+                  sourceEntityId: "b1aaaaaaaaaaaaaa",
                   materializedTableId: "mt-1",
                   physicalTableName: "s1_v1",
                   realization: "COPY",
@@ -809,15 +819,15 @@ describe("buildOneSource", () => {
       connection: { runSQL: sinon.SinonStub },
       physicalTableName: string,
       dialectName?: string,
-   ): Promise<{ buildId: string; physicalTableName: string }> {
+   ): Promise<{ sourceEntityId: string; physicalTableName: string }> {
       const source = fakeSource({
          name: "orders",
-         buildId: "abcdef1234567890",
+         sourceEntityId: "abcdef1234567890",
          sql: "SELECT * FROM t",
          dialectName,
       });
       const instruction: BuildInstruction = {
-         buildId: "abcdef1234567890",
+         sourceEntityId: "abcdef1234567890",
          materializedTableId: "mt-1",
          physicalTableName,
          realization: "COPY",
@@ -830,7 +840,7 @@ describe("buildOneSource", () => {
                c: unknown,
                d: Record<string, string>,
                m: Manifest,
-            ) => Promise<{ buildId: string; physicalTableName: string }>;
+            ) => Promise<{ sourceEntityId: string; physicalTableName: string }>;
          }
       ).buildOneSource(
          source,
@@ -853,7 +863,7 @@ describe("buildOneSource", () => {
          'ALTER TABLE "orders_v1_abcdef123456" RENAME TO "orders_v1"',
       ]);
       expect(entry.physicalTableName).toBe("orders_v1");
-      expect(entry.buildId).toBe("abcdef1234567890");
+      expect(entry.sourceEntityId).toBe("abcdef1234567890");
    });
 
    it("drops the staging table and rethrows when the build SQL fails", async () => {
@@ -919,7 +929,7 @@ describe("runBuild (branch behavior)", () => {
    function stubEngine(): RunBuildInternals {
       const entries = {
          "build-orders": {
-            buildId: "build-orders",
+            sourceEntityId: "build-orders",
             physicalTableName: '"orders_v1"',
             connectionName: "duckdb",
          },
@@ -995,11 +1005,11 @@ describe("autoLoadManifest", () => {
       const reloadAllModelsForPackage = sinon.stub().resolves();
       const entries = {
          b1: {
-            buildId: "b1",
+            sourceEntityId: "b1",
             physicalTableName: "orders_v1",
             connectionName: "duckdb",
          },
-         b2: { buildId: "b2", physicalTableName: undefined },
+         b2: { sourceEntityId: "b2", physicalTableName: undefined },
       };
 
       await (
@@ -1033,7 +1043,7 @@ describe("autoLoadManifest", () => {
                ) => Promise<void>;
             }
          ).autoLoadManifest({ reloadAllModelsForPackage }, "pkg", {
-            b1: { buildId: "b1", physicalTableName: "t" },
+            b1: { sourceEntityId: "b1", physicalTableName: "t" },
          }),
       ).resolves.toBeUndefined();
    });