@malloy-publisher/server 0.0.208 → 0.0.210

package/src/service/materialization_test_fixtures.ts

@@ -0,0 +1,119 @@
+import type { PersistSource } from "@malloydata/malloy";
+import {
+   BuildInstruction,
+   BuildPlan,
+   Materialization,
+} from "../storage/DatabaseInterface";
+import { CompiledBuildPlan } from "./build_plan";
+
+/**
+ * Shared fixtures for the materialization unit specs (service, controller,
+ * build-plan). Centralizing the builders keeps the per-source stand-ins and
+ * record shapes consistent across files and avoids drift when the wire types
+ * change.
+ */
+
+/** A persisted materialization record with sensible PENDING defaults. */
+export function makeMaterialization(
+   overrides: Partial<Materialization> = {},
+): Materialization {
+   return {
+      id: "mat-1",
+      environmentId: "env-1",
+      packageName: "pkg",
+      status: "PENDING",
+      manifest: null,
+      startedAt: null,
+      completedAt: null,
+      error: null,
+      metadata: null,
+      createdAt: new Date("2026-01-01"),
+      updatedAt: new Date("2026-01-01"),
+      ...overrides,
+   };
+}
+
+/** A single-source wire BuildPlan (the `Package.buildPlan` artifact). */
+export function makeBuildPlan(overrides: Partial<BuildPlan> = {}): BuildPlan {
+   return {
+      graphs: [
+         {
+            connectionName: "duckdb",
+            nodes: [[{ sourceID: "orders@m.malloy", dependsOn: [] }]],
+         },
+      ],
+      sources: {
+         "orders@m.malloy": {
+            name: "orders",
+            sourceID: "orders@m.malloy",
+            connectionName: "duckdb",
+            dialect: "duckdb",
+            buildId: "build-orders",
+            sql: "SELECT 1",
+            columns: [],
+         },
+      },
+      ...overrides,
+   };
+}
+
+/** A caller-supplied build instruction matching {@link makeBuildPlan}. */
+export function makeInstruction(
+   overrides: Partial<BuildInstruction> = {},
+): BuildInstruction {
+   return {
+      buildId: "build-orders",
+      materializedTableId: "mt-1",
+      physicalTableName: '"orders_v1"',
+      realization: "COPY",
+      ...overrides,
+   };
+}
+
+/**
+ * A minimal stand-in for a Malloy {@link PersistSource} exposing only what the
+ * build internals touch (name/id, deterministic buildId, SQL, and the
+ * `#@ persist name=` annotation reader, defaulted to "unset").
+ */
+export function fakeSource(opts: {
+   name: string;
+   buildId: string;
+   sql?: string;
+   connectionName?: string;
+}): PersistSource {
+   return {
+      name: opts.name,
+      sourceID: opts.name,
+      connectionName: opts.connectionName ?? "duckdb",
+      makeBuildId: () => opts.buildId,
+      getSQL: () => opts.sql ?? "SELECT 1",
+      annotations: {
+         parseAsTag: () => ({ tag: { text: () => undefined } }),
+      },
+   } as unknown as PersistSource;
+}
+
+/**
+ * Assemble a {@link CompiledBuildPlan} from a sources map and dependency
+ * levels (one connection, "duckdb"). `connections` is supplied by the caller
+ * because build vs. plan-derivation tests need different connection mocks.
+ */
+export function compiledWith(
+   sources: Record<string, PersistSource>,
+   levels: string[][],
+   connections: CompiledBuildPlan["connections"] = new Map(),
+): CompiledBuildPlan {
+   return {
+      graphs: [
+         {
+            connectionName: "duckdb",
+            nodes: levels.map((level) =>
+               level.map((sourceID) => ({ sourceID, dependsOn: [] })),
+            ),
+         },
+      ] as unknown as CompiledBuildPlan["graphs"],
+      sources,
+      connectionDigests: { duckdb: "dig" },
+      connections,
+   };
+}

package/src/service/model.ts

@@ -25,11 +25,6 @@ import * as fs from "fs/promises";
 import { createRequire } from "module";
 import * as path from "path";
 import { components } from "../api";
-import { deserializeError } from "../package_load/package_load_pool";
-import type {
-   SerializedModel,
-   SerializedNotebookCell,
-} from "../package_load/protocol";
 import {
    getDefaultQueryRowLimit,
    getMaxQueryRows,
@@ -46,8 +41,19 @@ import {
    PayloadTooLargeError,
 } from "../errors";
 import { logger } from "../logger";
+import { deserializeError } from "../package_load/package_load_pool";
+import type {
+   SerializedModel,
+   SerializedNotebookCell,
+} from "../package_load/protocol";
 import { BuildManifest } from "../storage/DatabaseInterface";
 import { URL_READER } from "../utils";
+import { modelAnnotations } from "./annotations";
+import {
+   collectAuthorizeExprs,
+   evaluateAuthorize,
+   validateAuthorizeProbes,
+} from "./authorize";
 import {
    buildFilterClause,
    FilterValidationError,
@@ -55,21 +61,15 @@ import {
    type FilterDefinition,
    type FilterParams,
 } from "./filter";
-import {
-   collectAuthorizeExprs,
-   evaluateAuthorize,
-   validateAuthorizeProbes,
-} from "./authorize";
-import { modelAnnotations } from "./annotations";
 import { malloyGivenToApi, type MalloyGiven } from "./given";
-import {
-   extractQueriesFromModelDef,
-   extractSourcesFromModelDef,
-} from "./source_extraction";
 import {
    assertWithinModelResponseLimits,
    resolveModelQueryRowLimit,
 } from "./model_limits";
+import {
+   extractQueriesFromModelDef,
+   extractSourcesFromModelDef,
+} from "./source_extraction";
 
 type ApiCompiledModel = components["schemas"]["CompiledModel"];
 type ApiNotebookCell = components["schemas"]["NotebookCell"];
@@ -980,13 +980,13 @@ export class Model {
     * annotated source view (`run: <source> -> <view>`) compile-only -- no
     * execution -- to get a stable result schema, then runs the renderer's
     * headless `validateRenderTags`. Targets with no annotations carry no render
-    * tags, so they are skipped without compiling. Any
-    * error-severity finding throws a `ModelCompilationError` (HTTP 424) so a
-    * misconfigured tag (e.g. a child-only `# big_value { sparkline=... }` placed
-    * on a view with no activating big_value) fails the package load with a clear
-    * message instead of rendering as "[object Object]" at query time. Warnings
-    * (e.g. unread tags) are left for the query-time `renderLogs` surface so a
-    * benign render lint never blocks a load.
+    * tags, so they are skipped without compiling. Any error-severity finding
+    * (e.g. a child-only `# big_value { sparkline=... }` placed on a view with no
+    * activating big_value) is logged as a warning naming the offending target;
+    * it does not fail the package load. Such a tag still renders as
+    * "[object Object]" at query time, so the warning is the operator-facing
+    * signal. Lower-severity findings are left for the query-time `renderLogs`
+    * surface.
     */
    public async validateRenderTags(): Promise<void> {
       const mm = this.modelMaterializer;
@@ -1053,11 +1053,11 @@ export class Model {
             (log) => log.severity === "error",
          );
          if (errors.length > 0) {
-            throw new ModelCompilationError({
-               message: `Invalid renderer configuration on '${target.label}': ${errors
+            logger.warn(
+               `Invalid renderer configuration on '${target.label}': ${errors
                   .map((e) => e.message)
                   .join("; ")}`,
-            });
+            );
          }
       }
    }

package/src/service/package.ts

@@ -28,9 +28,11 @@ import {
    ServiceUnavailableError,
 } from "../errors";
 import { formatDuration, logger } from "../logger";
+import { recordBuildPlanComputeDuration } from "../materialization_metrics";
 import { assertSafeEnvironmentPath, safeJoinUnderRoot } from "../path_safety";
-import { BuildManifest } from "../storage/DatabaseInterface";
+import { BuildManifest, BuildPlan } from "../storage/DatabaseInterface";
 import { ignoreDotfiles } from "../utils";
+import { computePackageBuildPlan } from "./build_plan";
 import { Model } from "./model";
 
 type ApiDatabase = components["schemas"]["Database"];
@@ -67,6 +69,13 @@ export class Package {
       "unbound";
    private manifestEntryCount = 0;
    private boundManifestUri: string | null = null;
+   // The package's persist build plan: a deterministic property of the compiled
+   // package (per-source buildId, columns, build SQL, dependency graphs),
+   // computed once at load from the live (unbound) models so it is stable for a
+   // given (package version, connection config). Null when the package declares
+   // no persist source. Surfaced read-only on getPackageMetadata() so a caller
+   // can derive build instructions without a separate plan round-trip.
+   private buildPlan: BuildPlan | null = null;
    private static meter = metrics.getMeter("publisher");
    private static packageLoadHistogram = this.meter.createHistogram(
       "malloy_package_load_duration",
@@ -350,8 +359,7 @@ export class Package {
          );
          // Validate renderer tags on the main thread (the renderer is too heavy
          // to load inside the pure-CPU package-load worker). A misconfigured tag
-         // throws a ModelCompilationError (424), aborting the whole load like any
-         // other per-model compile error above.
+         // is logged as a warning naming the target; it does not fail the load.
          await model.validateRenderTags();
          models.set(sm.modelPath, model);
       }
@@ -377,6 +385,26 @@ export class Package {
          malloyConfig,
       );
 
+      // Compute the persist build plan off the live (unbound) models, before the
+      // caller binds any configured manifest, so the surfaced plan reflects the
+      // canonical build (not the manifest-rewritten SQL). Best-effort: a plan
+      // failure is logged, not fatal — the package still serves; the plan is
+      // just absent. Recompiles the models (duplicate schema RPCs vs the worker
+      // compile); accepted for now.
+      try {
+         const buildPlanStart = Date.now();
+         pkg.buildPlan = await computePackageBuildPlan(pkg);
+         recordBuildPlanComputeDuration(Date.now() - buildPlanStart);
+      } catch (err) {
+         logger.warn(
+            `Failed to compute build plan for package ${packageName}`,
+            {
+               packageName,
+               error: err instanceof Error ? err.message : String(err),
+            },
+         );
+      }
+
       // Fail-safe at load: a bad explores entry doesn't fail the package
       // (its models still load and listModels hides the unmatched entry — it
       // never falls back to listing everything). Warn so the misconfig is
@@ -397,6 +425,16 @@ export class Package {
       return this.packageName;
    }
 
+   /**
+    * The package's persist build plan (per-source buildId, columns, build SQL,
+    * dependency graphs), or null when the package declares no persist source.
+    * A deterministic property of the compiled package; callers derive build
+    * instructions from it for an orchestrated materialization.
+    */
+   public getBuildPlan(): BuildPlan | null {
+      return this.buildPlan;
+   }
+
    public getPackageMetadata(): ApiPackage {
       // Overlay the server-computed fields onto the stored metadata: the
       // explores misconfig warnings (loading is fail-safe — the package still
@@ -418,6 +456,7 @@ export class Package {
          manifestBindingStatus: this.manifestBindingStatus,
          manifestEntryCount: this.manifestEntryCount,
          boundManifestUri: this.boundManifestUri,
+         buildPlan: this.buildPlan,
       };
       const warnings = this.exploreWarnings();
       if (warnings.length > 0) {
@@ -669,9 +708,10 @@ export class Package {
                { buildManifest },
             );
             // Validate renderer tags here too (loadViaWorker does it for the
-            // create path). Reload keeps per-model placeholders rather than
-            // aborting the whole package, so a render-tag error is recorded as
-            // this model's compilationError instead of thrown.
+            // create path). Render-tag findings are logged as warnings inside
+            // validateRenderTags and never throw. The catch is defensive: an
+            // unexpected internal failure is recorded as this model's
+            // compilationError rather than aborting the whole reload.
             try {
                await model.validateRenderTags();
                nextModels.set(sm.modelPath, model);

package/src/service/package_worker_path.spec.ts

@@ -28,10 +28,12 @@ import {
    describe,
    expect,
    it,
+   spyOn,
 } from "bun:test";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+import { logger } from "../logger";
 import {
    PackageLoadPool,
    __setPackageLoadPoolForTests,
@@ -280,14 +282,13 @@ source: gated is duckdb.sql("select 1 as id")`,
       }
    });
 
-   it("rejects a package whose view carries an invalid renderer tag", async () => {
+   it("logs a warning for a package whose view carries an invalid renderer tag", async () => {
       writeManifest();
       // `# big_value { sparkline=... }` is a child-only renderer config placed on
       // the view itself, with no activating big_value. The renderer declines to
-      // match it; without compile-time validation it renders as "[object Object]"
-      // at query time. Render-tag validation runs on the main thread after the
-      // worker hydrates the model, so the load must reject with a 424
-      // ModelCompilationError naming the offending view.
+      // match it. Render-tag validation runs on the main thread after the worker
+      // hydrates the model. The misconfiguration is logged as a warning naming
+      // the offending view; it does not fail the package load.
       fs.writeFileSync(
          path.join(tempDir, "bad_render.malloy"),
          `source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
@@ -302,21 +303,21 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("nums -> card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["bad_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("nums -> card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
@@ -341,7 +342,7 @@ source: gated is duckdb.sql("select 1 as id")`,
       }
    });
 
-   it("rejects a package whose backtick-quoted (hyphenated) source has a bad view render tag", async () => {
+   it("logs a warning for a backtick-quoted (hyphenated) source with a bad view render tag", async () => {
       writeManifest();
       // A source whose name needs Malloy backtick-quoting (here, a hyphen). The
       // validation target must quote the identifier; otherwise `run: bad-source
@@ -363,26 +364,26 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("bad-source -> card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["hyphen_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("bad-source -> card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("rejects a package whose source name contains an escaped backtick with a bad view render tag", async () => {
+   it("logs a warning for a source name containing an escaped backtick with a bad view render tag", async () => {
       writeManifest();
       // Source name with a literal backtick (written escaped in Malloy as
       // `wei\`rd`). The validation target must re-escape it; a bare wrap would
@@ -403,26 +404,26 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["backtick_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("rejects a .malloynb notebook whose source view carries an invalid renderer tag", async () => {
+   it("logs a warning for a .malloynb notebook whose source view carries an invalid renderer tag", async () => {
       writeManifest();
       fs.writeFileSync(
          path.join(tempDir, "bad_render.malloynb"),
@@ -439,18 +440,22 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         await expect(
-            Package.create("env", "pkg", tempDir, malloyConfig),
-         ).rejects.toBeInstanceOf(ModelCompilationError);
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["bad_render.malloynb"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some((m) => m.includes("Invalid renderer configuration")),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("re-validates renderer tags on reload, recording a model that develops a bad tag as a per-model error", async () => {
+   it("re-validates renderer tags on reload, logging a warning for a model that develops a bad tag", async () => {
       writeManifest();
       // Start valid so Package.create succeeds.
       fs.writeFileSync(
@@ -463,13 +468,15 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
       );
 
       const { malloyConfig, duckdb } = await makeMalloyConfig();
+      const warnSpy = spyOn(logger, "warn");
       try {
          const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
          expect(pkg.getModel("m.malloy")).toBeDefined();
+         warnSpy.mockClear();
 
-         // The model now develops a misconfigured render tag. Reload must catch
-         // it (not just Package.create) and surface it as the model's error,
-         // without aborting the whole reload.
+         // The model now develops a misconfigured render tag. Reload re-validates
+         // (not just Package.create) and logs a warning for it, without aborting
+         // the reload or failing the model.
          fs.writeFileSync(
             path.join(tempDir, "m.malloy"),
             `source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
@@ -487,10 +494,13 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
 
          const reloaded = pkg.getModel("m.malloy");
          expect(reloaded).toBeDefined();
-         await expect(reloaded!.getModel()).rejects.toThrow(
-            "Invalid renderer configuration",
-         );
+         await expect(reloaded!.getModel()).resolves.toBeDefined();
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some((m) => m.includes("Invalid renderer configuration")),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });

package/src/storage/DatabaseInterface.ts

@@ -108,8 +108,8 @@ export interface Connection {
    updatedAt: Date;
 }
 
-// Wire types for the two-round build protocol, kept in sync with the OpenAPI
-// spec via the generated `api.ts`.
+// Wire types for the build protocol, kept in sync with the OpenAPI spec via
+// the generated `api.ts`.
 export type MaterializationStatus =
    components["schemas"]["MaterializationStatus"];
 export type BuildPlan = components["schemas"]["BuildPlan"];
@@ -122,15 +122,8 @@ export interface Materialization {
    id: string;
    environmentId: string;
    packageName: string;
-   /**
-    * Echoes the create-time flag (read from metadata). False (default) =
-    * auto-run all phases; true = pause at BUILD_PLAN_READY for Round 2.
-    */
-   pauseBetweenPhases: boolean;
    status: MaterializationStatus;
-   /** Round 1 output. Null until status >= BUILD_PLAN_READY. */
-   buildPlan: BuildPlan | null;
-   /** Round 2 output. Null until status = MANIFEST_FILE_READY. */
+   /** Build output. Null until status = MANIFEST_FILE_READY. */
    manifest: BuildManifestResult | null;
    startedAt: Date | null;
    completedAt: Date | null;
@@ -142,7 +135,6 @@ export interface Materialization {
 
 export interface MaterializationUpdate {
    status?: MaterializationStatus;
-   buildPlan?: BuildPlan | null;
    manifest?: BuildManifestResult | null;
    startedAt?: Date;
    completedAt?: Date;
@@ -154,8 +146,8 @@ export interface MaterializationUpdate {
  * Malloy-facing build manifest: maps a buildId to the physical table backing
  * that persist source. This is the shape the Malloy runtime consumes when
  * (re)loading models so persist references resolve to materialized tables.
- * Distinct from {@link BuildManifestResult} (the wire/Round 2 output, which
- * also carries CP bookkeeping like materializedTableId and rowCount).
+ * Distinct from {@link BuildManifestResult} (the wire build output, which also
+ * carries caller bookkeeping like materializedTableId and rowCount).
  */
 export interface BuildManifestEntry {
    tableName: string;

package/src/storage/duckdb/MaterializationRepository.ts

@@ -1,6 +1,5 @@
 import {
    BuildManifestResult,
-   BuildPlan,
    Materialization,
    MaterializationStatus,
    MaterializationUpdate,
@@ -16,7 +15,6 @@ const TERMINAL_STATUSES: ReadonlySet<MaterializationStatus> = new Set([
 /** Non-terminal statuses count as "active" for the single-active guard. */
 const ACTIVE_STATUSES: readonly MaterializationStatus[] = [
    "PENDING",
-   "BUILD_PLAN_READY",
    "MANIFEST_ROWS_READY",
 ];
 
@@ -40,8 +38,9 @@ export class DuplicateActiveMaterializationError extends Error {
 /**
  * DuckDB-backed repository for package materializations.
  *
- * A Materialization tracks a single build run for an (environment, package) pair
- * through its lifecycle: PENDING -> RUNNING -> SUCCESS | FAILED | CANCELLED.
+ * A Materialization tracks a single build run for an (environment, package)
+ * pair through its lifecycle: PENDING -> MANIFEST_ROWS_READY ->
+ * MANIFEST_FILE_READY, or -> FAILED | CANCELLED.
  */
 export class MaterializationRepository {
    constructor(private db: DuckDBConnection) {}
@@ -114,8 +113,8 @@ export class MaterializationRepository {
 
       try {
          const rows = await this.db.all<Record<string, unknown>>(
-            `INSERT INTO materializations (id, environment_id, package_name, status, active_key, metadata, build_plan, manifest, created_at, updated_at)
-            VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?)
+            `INSERT INTO materializations (id, environment_id, package_name, status, active_key, metadata, manifest, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)
             RETURNING *`,
             [
                id,
@@ -181,12 +180,6 @@ export class MaterializationRepository {
             updates.metadata ? JSON.stringify(updates.metadata) : null,
          );
       }
-      if (updates.buildPlan !== undefined) {
-         setClauses.push(`build_plan = ?`);
-         params.push(
-            updates.buildPlan ? JSON.stringify(updates.buildPlan) : null,
-         );
-      }
       if (updates.manifest !== undefined) {
          setClauses.push(`manifest = ?`);
          params.push(
@@ -237,9 +230,7 @@ export class MaterializationRepository {
          id: row.id as string,
          environmentId: row.environment_id as string,
          packageName: row.package_name as string,
-         pauseBetweenPhases: metadata?.pauseBetweenPhases === true,
          status: row.status as MaterializationStatus,
-         buildPlan: parseJsonColumn<BuildPlan>(row.build_plan),
          manifest: parseJsonColumn<BuildManifestResult>(row.manifest),
          metadata,
          startedAt: row.started_at ? new Date(row.started_at as string) : null,

package/src/storage/duckdb/schema.ts

@@ -75,15 +75,15 @@ export async function initializeSchema(
 
    // Materializations table.
    //
-   // `active_key` enforces at-most-one active (PENDING or RUNNING)
-   // materialization per (environment, package) at the DB layer. It is set to
+   // `active_key` enforces at-most-one active (non-terminal) materialization
+   // per (environment, package) at the DB layer. It is set to
    // `{environment_id}|{package_name}` while the row is active and cleared
    // to NULL on transition to any terminal state. A unique index on
    // `active_key` (see below) makes the insert-then-check race impossible —
    // a second concurrent create fails with a constraint violation, which the
    // service layer translates to `MaterializationConflictError`.
-   // `build_plan` (Round 1) and `manifest` (Round 2) are JSON blobs holding
-   // the two-round protocol payloads returned inline on the resource.
+   // `manifest` is a JSON blob holding the build output returned inline on the
+   // resource.
    await db.run(`
     CREATE TABLE IF NOT EXISTS materializations (
       id VARCHAR PRIMARY KEY,
@@ -95,7 +95,6 @@ export async function initializeSchema(
       completed_at TIMESTAMP,
       error TEXT,
       metadata JSON,
-      build_plan JSON,
       manifest JSON,
       created_at TIMESTAMP NOT NULL,
       updated_at TIMESTAMP NOT NULL,