@malloy-publisher/server 0.0.205 → 0.0.207

package/dist/server.mjs

@@ -147316,6 +147316,9 @@ var require_dist4 = __commonJS((exports) => {
 
 // src/constants.ts
 import os from "os";
+function normalizeModelPath(p) {
+  return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}
 var API_PREFIX = "/api/v0", README_NAME = "README.md", PUBLISHER_CONFIG_NAME = "publisher.config.json", PACKAGE_MANIFEST_NAME = "publisher.json", MODEL_FILE_SUFFIX = ".malloy", NOTEBOOK_FILE_SUFFIX = ".malloynb", DEFAULT_QUERY_ROW_LIMIT = 1000, DEFAULT_MAX_QUERY_ROWS = 1e5, DEFAULT_MAX_RESPONSE_BYTES = 50000000, DEFAULT_QUERY_TIMEOUT_MS = 300000, DEFAULT_MAX_CONCURRENT_QUERIES = 32, TEMP_DIR_PATH, PUBLISHER_DATA_DIR = "publisher_data";
 var init_constants = __esm(() => {
   TEMP_DIR_PATH = os.tmpdir();
@@ -147336,6 +147339,8 @@ function internalErrorToHttpError(error) {
     return httpError(404, error.message);
   } else if (error instanceof ModelNotFoundError) {
     return httpError(404, error.message);
+  } else if (error instanceof NotQueryableError) {
+    return httpError(404, error.message);
   } else if (error instanceof MalloyError) {
     return httpError(400, error.message);
   } else if (error instanceof ConnectionNotFoundError) {
@@ -147371,7 +147376,7 @@ function httpError(code, message) {
     }
   };
 }
-var NotImplementedError, BadRequestError, EnvironmentNotFoundError, PackageNotFoundError, ModelNotFoundError, ConnectionNotFoundError, ConnectionError, ConnectionAuthError, ModelCompilationError, FrozenConfigError, AccessDeniedError, MaterializationNotFoundError, MaterializationConflictError, InvalidStateTransitionError, ServiceUnavailableError, PayloadTooLargeError, QueryTimeoutError;
+var NotImplementedError, BadRequestError, EnvironmentNotFoundError, PackageNotFoundError, ModelNotFoundError, ConnectionNotFoundError, ConnectionError, ConnectionAuthError, ModelCompilationError, FrozenConfigError, AccessDeniedError, NotQueryableError, MaterializationNotFoundError, MaterializationConflictError, InvalidStateTransitionError, ServiceUnavailableError, PayloadTooLargeError, QueryTimeoutError;
 var init_errors = __esm(() => {
   init_constants();
   NotImplementedError = class NotImplementedError extends Error {
@@ -147430,6 +147435,12 @@ var init_errors = __esm(() => {
       this.name = "AccessDeniedError";
     }
   };
+  NotQueryableError = class NotQueryableError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "NotQueryableError";
+    }
+  };
   MaterializationNotFoundError = class MaterializationNotFoundError extends Error {
     constructor(message) {
       super(message);
@@ -200036,7 +200047,7 @@ globstar while`, file, fr, pattern, pr, swallowee);
 
 // ../../node_modules/recursive-readdir/index.js
 var require_recursive_readdir = __commonJS((exports, module) => {
-  var fs4 = __require("fs");
+  var fs5 = __require("fs");
   var p = __require("path");
   var minimatch = require_minimatch();
   function patternMatcher(pattern) {
@@ -200070,7 +200081,7 @@ var require_recursive_readdir = __commonJS((exports, module) => {
     }
     ignores = ignores.map(toMatcherFunction);
     var list = [];
-    fs4.readdir(path6, function(err, files) {
+    fs5.readdir(path6, function(err, files) {
       if (err) {
         return callback(err);
       }
@@ -200080,7 +200091,7 @@ var require_recursive_readdir = __commonJS((exports, module) => {
       }
       files.forEach(function(file) {
         var filePath = p.join(path6, file);
-        fs4.stat(filePath, function(_err, stats) {
+        fs5.stat(filePath, function(_err, stats) {
           if (_err) {
             return callback(_err);
           }
@@ -211788,8 +211799,8 @@ var require_lib8 = __commonJS((exports, module) => {
   handlebars.print = printer.print;
   module.exports = handlebars;
   function extension(module2, filename) {
-    var fs8 = __require("fs");
-    var templateString = fs8.readFileSync(filename, "utf8");
+    var fs9 = __require("fs");
+    var templateString = fs9.readFileSync(filename, "utf8");
     module2.exports = handlebars.compile(templateString);
   }
   if (__require.extensions) {
@@ -211893,8 +211904,15 @@ var httpRequestDuration = meter.createHistogram("http_server_request_duration_ms
 var httpRequestCount = meter.createCounter("http_server_requests_total", {
   description: "Total number of HTTP requests"
 });
-var eventLoopHistogram = monitorEventLoopDelay({ resolution: 20 });
-eventLoopHistogram.enable();
+var eventLoopHistogram = (() => {
+  try {
+    const histogram = monitorEventLoopDelay({ resolution: 20 });
+    histogram.enable();
+    return histogram;
+  } catch {
+    return null;
+  }
+})();
 var eventLoopLagP50 = meter.createObservableGauge("publisher_event_loop_lag_p50_ms", {
   description: "Event loop delay p50 since the last scrape, in milliseconds",
   unit: "ms"
@@ -211907,12 +211925,15 @@ var eventLoopLagMax = meter.createObservableGauge("publisher_event_loop_lag_max_
   description: "Event loop delay max since the last scrape, in milliseconds",
   unit: "ms"
 });
-meter.addBatchObservableCallback((observableResult) => {
-  observableResult.observe(eventLoopLagP50, eventLoopHistogram.percentile(50) / 1e6);
-  observableResult.observe(eventLoopLagP99, eventLoopHistogram.percentile(99) / 1e6);
-  observableResult.observe(eventLoopLagMax, eventLoopHistogram.max / 1e6);
-  eventLoopHistogram.reset();
-}, [eventLoopLagP50, eventLoopLagP99, eventLoopLagMax]);
+if (eventLoopHistogram) {
+  const histogram = eventLoopHistogram;
+  meter.addBatchObservableCallback((observableResult) => {
+    observableResult.observe(eventLoopLagP50, histogram.percentile(50) / 1e6);
+    observableResult.observe(eventLoopLagP99, histogram.percentile(99) / 1e6);
+    observableResult.observe(eventLoopLagMax, histogram.max / 1e6);
+    histogram.reset();
+  }, [eventLoopLagP50, eventLoopLagP99, eventLoopLagMax]);
+}
 var IGNORED_PATHS = new Set([
   "/health",
   "/health/liveness",
@@ -216954,7 +216975,7 @@ var import_express = __toESM(require_express(), 1);
 var import_http_proxy_middleware = __toESM(require_dist4(), 1);
 import * as http2 from "http";
 import * as path11 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/controller/compile.controller.ts
 class CompileController {
@@ -220673,61 +220694,9 @@ import fs2 from "fs/promises";
 
 // src/pg_helpers.ts
 init_errors();
-function pgConnectTimeoutSeconds() {
-  const raw = process.env.PG_CONNECT_TIMEOUT_SECONDS;
-  if (!raw)
-    return 5;
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 5;
-}
-var URI_FORM_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
-var HAS_CONNECT_TIMEOUT_RE = /[?&\s]connect_timeout=|^connect_timeout=/;
-function withPgConnectTimeout(connectionString, timeout) {
-  if (HAS_CONNECT_TIMEOUT_RE.test(connectionString)) {
-    return connectionString;
-  }
-  if (URI_FORM_RE.test(connectionString)) {
-    if (!connectionString.includes("?")) {
-      return `${connectionString}?connect_timeout=${timeout}`;
-    }
-    if (connectionString.endsWith("?")) {
-      return `${connectionString}connect_timeout=${timeout}`;
-    }
-    return `${connectionString}&connect_timeout=${timeout}`;
-  }
-  return `${connectionString} connect_timeout=${timeout}`;
-}
 function redactPgSecrets(s) {
   return s.replace(/password=('[^']*'|"[^"]*"|\S+)/gi, "password=***");
 }
-function classifyPgError(error, context) {
-  if (!(error instanceof Error))
-    return;
-  const msg = error.message;
-  const patterns = [
-    /password authentication failed/i,
-    /pg_hba\.conf/i,
-    /role ".*" does not exist/i,
-    /database ".*" does not exist/i,
-    /permission denied/i
-  ];
-  if (!patterns.some((p) => p.test(msg)))
-    return;
-  return new ConnectionAuthError(`${context}: ${redactPgSecrets(msg)}`);
-}
-function handlePgAttachError(error, context) {
-  if (error instanceof Error && (error.message.includes("already exists") || error.message.includes("already attached"))) {
-    return { action: "swallow" };
-  }
-  const authErr = classifyPgError(error, context);
-  if (authErr) {
-    return { action: "throw", error: authErr };
-  }
-  if (error instanceof Error) {
-    return { action: "throw", error };
-  }
-  return { action: "throw", error: new Error(String(error)) };
-}
 
 // src/path_safety.ts
 init_errors();
@@ -223618,15 +223587,13 @@ class ModelController {
 }
 
 // src/controller/package.controller.ts
+init_constants();
 init_errors();
-init_logger();
 
 class PackageController {
   environmentStore;
-  manifestService;
-  constructor(environmentStore, manifestService) {
+  constructor(environmentStore) {
     this.environmentStore = environmentStore;
-    this.manifestService = manifestService;
   }
   async listPackages(environmentName) {
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
@@ -223650,7 +223617,7 @@ class PackageController {
     const _package = await environment.getPackage(packageName, false);
     return _package.getPackageMetadata();
   }
-  async addPackage(environmentName, body, options) {
+  async addPackage(environmentName, body) {
     if (this.environmentStore.publisherConfigIsFrozen) {
       throw new FrozenConfigError;
     }
@@ -223662,38 +223629,22 @@ class PackageController {
     let result;
     if (body.location) {
       const bodyLocation = body.location;
-      result = await environment.installPackage(packageName, (stagingPath) => this.downloadInto(environmentName, packageName, bodyLocation, stagingPath));
+      result = await environment.installPackage(packageName, (stagingPath) => this.downloadInto(environmentName, packageName, bodyLocation, stagingPath), (pkg) => pkg.formatInvalidExplores());
     } else {
       result = await environment.addPackage(packageName);
     }
-    await this.environmentStore.addPackageToDatabase(environmentName, packageName);
-    if (options?.autoLoadManifest === true) {
-      await this.tryLoadExistingManifest(environmentName, packageName);
+    if (!result) {
+      throw new Error(`Failed to create package ${packageName}`);
     }
-    return result;
-  }
-  async tryLoadExistingManifest(environmentName, packageName) {
-    try {
-      const repository = this.environmentStore.storageManager.getRepository();
-      const dbEnvironment = await repository.getEnvironmentByName(environmentName);
-      if (!dbEnvironment)
-        return;
-      const manifest = await this.manifestService.getManifest(dbEnvironment.id, packageName);
-      if (Object.keys(manifest.entries).length === 0)
-        return;
-      await this.manifestService.reloadManifest(dbEnvironment.id, packageName, environmentName);
-      logger.info("Auto-loaded existing manifest for added package", {
-        environmentName,
-        packageName,
-        entryCount: Object.keys(manifest.entries).length
-      });
-    } catch (error) {
-      logger.warn("Failed to auto-load manifest for package", {
-        environmentName,
-        packageName,
-        error
-      });
+    if (!body.location) {
+      const invalidMsg = result.formatInvalidExplores();
+      if (invalidMsg) {
+        await environment.unloadPackage(packageName).catch(() => {});
+        throw new BadRequestError(invalidMsg);
+      }
     }
+    await this.environmentStore.addPackageToDatabase(environmentName, packageName);
+    return result;
   }
   async deletePackage(environmentName, packageName) {
     if (this.environmentStore.publisherConfigIsFrozen) {
@@ -223711,7 +223662,7 @@ class PackageController {
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
     if (body.location) {
       const bodyLocation = body.location;
-      await environment.installPackage(packageName, (stagingPath) => this.downloadInto(environmentName, packageName, bodyLocation, stagingPath));
+      await environment.installPackage(packageName, (stagingPath) => this.downloadInto(environmentName, packageName, bodyLocation, stagingPath), (pkg) => pkg.formatInvalidExplores(body.explores?.map(normalizeModelPath)));
     }
     const result = await environment.updatePackage(packageName, body);
     await this.environmentStore.addPackageToDatabase(environmentName, packageName);
@@ -225345,8 +225296,8 @@ import { EventEmitter as EventEmitter4 } from "events";
 import path10 from "path";
 
 // src/service/environment_store.ts
-var import_client_s32 = __toESM(require_dist_cjs75(), 1);
-import { Storage } from "@google-cloud/storage";
+var import_client_s33 = __toESM(require_dist_cjs75(), 1);
+import { Storage as Storage2 } from "@google-cloud/storage";
 
 // ../../node_modules/async-mutex/index.mjs
 var E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
@@ -225558,8 +225509,8 @@ class Mutex {
 
 // src/service/environment_store.ts
 var import_extract_zip = __toESM(require_extract_zip(), 1);
-import crypto5 from "crypto";
-import * as fs7 from "fs";
+import crypto4 from "crypto";
+import * as fs8 from "fs";
 import * as path9 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
@@ -229654,21 +229605,6 @@ function registerHealthEndpoints(app) {
 init_logger();
 
 // src/storage/StorageManager.ts
-import * as crypto3 from "crypto";
-
-// src/ducklake_version.ts
-var SUPPORTED_CATALOG_VERSIONS = [
-  "0.1",
-  "0.2",
-  "0.3-dev1",
-  "0.3"
-];
-function isCatalogVersionSupported(version) {
-  return SUPPORTED_CATALOG_VERSIONS.includes(version);
-}
-
-// src/storage/StorageManager.ts
-init_errors();
 init_logger();
 
 // src/storage/duckdb/DuckDBConnection.ts
@@ -229759,41 +229695,6 @@ Query: ${query}`);
   }
 }
 
-// src/storage/duckdb/DuckDBManifestStore.ts
-class DuckDBManifestStore {
-  repository;
-  constructor(repository) {
-    this.repository = repository;
-  }
-  async getManifest(environmentId, packageName) {
-    const entries = await this.repository.listManifestEntries(environmentId, packageName);
-    const manifest = {
-      entries: {},
-      strict: false
-    };
-    for (const entry of entries) {
-      manifest.entries[entry.buildId] = { tableName: entry.tableName };
-    }
-    return manifest;
-  }
-  async writeEntry(environmentId, packageName, buildId, tableName, sourceName, connectionName) {
-    await this.repository.upsertManifestEntry({
-      environmentId,
-      packageName,
-      buildId,
-      tableName,
-      sourceName,
-      connectionName
-    });
-  }
-  async deleteEntry(id) {
-    await this.repository.deleteManifestEntry(id);
-  }
-  async listEntries(environmentId, packageName) {
-    return this.repository.listManifestEntries(environmentId, packageName);
-  }
-}
-
 // src/storage/duckdb/ConnectionRepository.ts
 class ConnectionRepository {
   db;
@@ -230001,77 +229902,17 @@ class EnvironmentRepository {
   }
 }
 
-// src/storage/duckdb/ManifestRepository.ts
-class ManifestRepository {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  generateId() {
-    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-  }
-  async listEntries(environmentId, packageName) {
-    const rows = await this.db.all("SELECT * FROM build_manifests WHERE environment_id = ? AND package_name = ? ORDER BY created_at DESC", [environmentId, packageName]);
-    return rows.map(this.mapToEntry);
-  }
-  async getEntryByBuildId(environmentId, packageName, buildId) {
-    const row = await this.db.get("SELECT * FROM build_manifests WHERE environment_id = ? AND package_name = ? AND build_id = ?", [environmentId, packageName, buildId]);
-    return row ? this.mapToEntry(row) : null;
-  }
-  async upsertEntry(entry) {
-    const id = this.generateId();
-    const now = new Date;
-    const iso = now.toISOString();
-    const rows = await this.db.all(`INSERT INTO build_manifests (id, environment_id, package_name, build_id, table_name, source_name, connection_name, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT (environment_id, package_name, build_id)
-         DO UPDATE SET table_name = EXCLUDED.table_name,
-                       source_name = EXCLUDED.source_name,
-                       connection_name = EXCLUDED.connection_name,
-                       updated_at = EXCLUDED.updated_at
-         RETURNING *`, [
-      id,
-      entry.environmentId,
-      entry.packageName,
-      entry.buildId,
-      entry.tableName,
-      entry.sourceName,
-      entry.connectionName,
-      iso,
-      iso
-    ]);
-    return this.mapToEntry(rows[0]);
-  }
-  async deleteEntry(id) {
-    await this.db.run("DELETE FROM build_manifests WHERE id = ?", [id]);
-  }
-  async deleteEntriesByEnvironmentId(environmentId) {
-    await this.db.run("DELETE FROM build_manifests WHERE environment_id = ?", [environmentId]);
-  }
-  async deleteEntriesByPackage(environmentId, packageName) {
-    await this.db.run("DELETE FROM build_manifests WHERE environment_id = ? AND package_name = ?", [environmentId, packageName]);
-  }
-  mapToEntry(row) {
-    return {
-      id: row.id,
-      environmentId: row.environment_id,
-      packageName: row.package_name,
-      buildId: row.build_id,
-      tableName: row.table_name,
-      sourceName: row.source_name,
-      connectionName: row.connection_name,
-      createdAt: new Date(row.created_at),
-      updatedAt: new Date(row.updated_at)
-    };
-  }
-}
-
 // src/storage/duckdb/MaterializationRepository.ts
 var TERMINAL_STATUSES = new Set([
-  "SUCCESS",
+  "MANIFEST_FILE_READY",
   "FAILED",
   "CANCELLED"
 ]);
+var ACTIVE_STATUSES = [
+  "PENDING",
+  "BUILD_PLAN_READY",
+  "MANIFEST_ROWS_READY"
+];
 function activeKeyFor(environmentId, packageName) {
   return `${environmentId}|${packageName}`;
 }
@@ -230112,7 +229953,8 @@ class MaterializationRepository {
     return row ? this.mapRow(row) : null;
   }
   async getActive(environmentId, packageName) {
-    const row = await this.db.get("SELECT * FROM materializations WHERE environment_id = ? AND package_name = ? AND status IN ('PENDING', 'RUNNING')", [environmentId, packageName]);
+    const placeholders = ACTIVE_STATUSES.map(() => "?").join(", ");
+    const row = await this.db.get(`SELECT * FROM materializations WHERE environment_id = ? AND package_name = ? AND status IN (${placeholders})`, [environmentId, packageName, ...ACTIVE_STATUSES]);
     return row ? this.mapRow(row) : null;
   }
   async create(environmentId, packageName, status = "PENDING", metadata = null) {
@@ -230122,8 +229964,8 @@ class MaterializationRepository {
     const activeKey = TERMINAL_STATUSES.has(status) ? null : activeKeyFor(environmentId, packageName);
     const metadataJson = metadata ? JSON.stringify(metadata) : null;
     try {
-      const rows = await this.db.all(`INSERT INTO materializations (id, environment_id, package_name, status, active_key, metadata, created_at, updated_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      const rows = await this.db.all(`INSERT INTO materializations (id, environment_id, package_name, status, active_key, metadata, build_plan, manifest, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?)
             RETURNING *`, [
         id,
         environmentId,
@@ -230171,6 +230013,14 @@ class MaterializationRepository {
       setClauses.push(`metadata = ?`);
       params.push(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(updates.manifest ? JSON.stringify(updates.manifest) : null);
+    }
     setClauses.push(`updated_at = ?`);
     params.push(now.toISOString());
     params.push(id);
@@ -230181,38 +230031,43 @@ class MaterializationRepository {
     }
     return updated;
   }
-  async deleteByEnvironmentId(environmentId) {
-    await this.db.run("DELETE FROM materializations WHERE environment_id = ?", [environmentId]);
-  }
   async deleteById(id) {
     await this.db.run("DELETE FROM materializations WHERE id = ?", [id]);
   }
+  async deleteByEnvironmentId(environmentId) {
+    await this.db.run("DELETE FROM materializations WHERE environment_id = ?", [environmentId]);
+  }
   async deleteByPackage(environmentId, packageName) {
     await this.db.run("DELETE FROM materializations WHERE environment_id = ? AND package_name = ?", [environmentId, packageName]);
   }
   mapRow(row) {
-    let metadata = null;
-    if (row.metadata) {
-      try {
-        metadata = JSON.parse(row.metadata);
-      } catch {
-        metadata = null;
-      }
-    }
+    const metadata = parseJsonColumn(row.metadata);
     return {
       id: row.id,
       environmentId: row.environment_id,
       packageName: row.package_name,
+      pauseBetweenPhases: metadata?.pauseBetweenPhases === true,
       status: row.status,
+      buildPlan: parseJsonColumn(row.build_plan),
+      manifest: parseJsonColumn(row.manifest),
+      metadata,
       startedAt: row.started_at ? new Date(row.started_at) : null,
       completedAt: row.completed_at ? new Date(row.completed_at) : null,
       error: row.error != null ? row.error : null,
-      metadata,
       createdAt: new Date(row.created_at),
       updatedAt: new Date(row.updated_at)
     };
   }
 }
+function parseJsonColumn(value) {
+  if (value == null)
+    return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
 function isUniqueViolation(err, indexName) {
   if (!(err instanceof Error))
     return false;
@@ -230322,14 +230177,12 @@ class DuckDBRepository {
   packageRepo;
   connectionRepo;
   materializationRepo;
-  manifestRepo;
   constructor(db) {
     this.db = db;
     this.environmentRepo = new EnvironmentRepository(db);
     this.packageRepo = new PackageRepository(db);
     this.connectionRepo = new ConnectionRepository(db);
     this.materializationRepo = new MaterializationRepository(db);
-    this.manifestRepo = new ManifestRepository(db);
   }
   async listEnvironments() {
     return this.environmentRepo.listEnvironments();
@@ -230347,7 +230200,6 @@ class DuckDBRepository {
     return this.environmentRepo.updateEnvironment(id, updates);
   }
   async deleteEnvironment(id) {
-    await this.manifestRepo.deleteEntriesByEnvironmentId(id);
     await this.materializationRepo.deleteByEnvironmentId(id);
     await this.connectionRepo.deleteConnectionsByEnvironmentId(id);
     await this.packageRepo.deletePackagesByEnvironmentId(id);
@@ -230371,7 +230223,6 @@ class DuckDBRepository {
   async deletePackage(id) {
     const pkg = await this.packageRepo.getPackageById(id);
     if (pkg) {
-      await this.manifestRepo.deleteEntriesByPackage(pkg.environmentId, pkg.name);
       await this.materializationRepo.deleteByPackage(pkg.environmentId, pkg.name);
     }
     await this.packageRepo.deletePackage(id);
@@ -230418,15 +230269,6 @@ class DuckDBRepository {
   async deleteMaterialization(id) {
     return this.materializationRepo.deleteById(id);
   }
-  async listManifestEntries(environmentId, packageName) {
-    return this.manifestRepo.listEntries(environmentId, packageName);
-  }
-  async upsertManifestEntry(entry) {
-    return this.manifestRepo.upsertEntry(entry);
-  }
-  async deleteManifestEntry(id) {
-    return this.manifestRepo.deleteEntry(id);
-  }
 }
 
 // src/storage/duckdb/schema.ts
@@ -230492,31 +230334,17 @@ async function initializeSchema(db, force = false) {
       completed_at TIMESTAMP,
       error TEXT,
       metadata JSON,
+      build_plan JSON,
+      manifest JSON,
       created_at TIMESTAMP NOT NULL,
       updated_at TIMESTAMP NOT NULL,
       FOREIGN KEY (environment_id) REFERENCES environments(id)
     )
   `);
-  await db.run(`
-    CREATE TABLE IF NOT EXISTS build_manifests (
-      id VARCHAR PRIMARY KEY,
-      environment_id VARCHAR NOT NULL,
-      package_name VARCHAR NOT NULL,
-      build_id VARCHAR NOT NULL,
-      table_name VARCHAR NOT NULL,
-      source_name VARCHAR NOT NULL,
-      connection_name VARCHAR NOT NULL,
-      created_at TIMESTAMP NOT NULL,
-      updated_at TIMESTAMP NOT NULL,
-      FOREIGN KEY (environment_id) REFERENCES environments(id),
-      UNIQUE (environment_id, package_name, build_id)
-    )
-  `);
   await db.run("CREATE INDEX IF NOT EXISTS idx_packages_environment_id ON packages(environment_id)");
   await db.run("CREATE INDEX IF NOT EXISTS idx_connections_environment_id ON connections(environment_id)");
   await db.run("CREATE INDEX IF NOT EXISTS idx_materializations_environment_package ON materializations(environment_id, package_name)");
   await db.run("CREATE UNIQUE INDEX IF NOT EXISTS idx_materializations_active_key ON materializations(active_key)");
-  await db.run("CREATE INDEX IF NOT EXISTS idx_build_manifests_environment_package ON build_manifests(environment_id, package_name)");
 }
 var LEGACY_TABLES_DROP_ORDER = [
   "build_manifests",
@@ -230558,129 +230386,10 @@ async function dropAllTables(db) {
   }
 }
 
-// src/storage/ducklake/DuckLakeManifestStore.ts
-init_logger();
-
-class DuckLakeManifestStore {
-  db;
-  table;
-  environmentName;
-  constructor(db, catalogName, environmentName) {
-    this.db = db;
-    this.table = `${catalogName}.build_manifests`;
-    this.environmentName = environmentName;
-  }
-  async bootstrapSchema() {
-    await this.db.run(`
-         CREATE TABLE IF NOT EXISTS ${this.table} (
-            id VARCHAR,
-            environment_name VARCHAR NOT NULL,
-            package_name VARCHAR NOT NULL,
-            build_id VARCHAR NOT NULL,
-            table_name VARCHAR NOT NULL,
-            source_name VARCHAR NOT NULL,
-            connection_name VARCHAR NOT NULL,
-            created_at TIMESTAMP NOT NULL,
-            updated_at TIMESTAMP NOT NULL
-         )
-      `);
-    logger.info(`DuckLake manifest table bootstrapped: ${this.table}`);
-  }
-  async getManifest(_environmentId, packageName) {
-    const rows = await this.db.all(`SELECT * FROM ${this.table} WHERE environment_name = ? AND package_name = ? ORDER BY created_at DESC`, [this.environmentName, packageName]);
-    const manifest = { entries: {}, strict: false };
-    for (const row of rows) {
-      const buildId = row.build_id;
-      if (!manifest.entries[buildId]) {
-        manifest.entries[buildId] = {
-          tableName: row.table_name
-        };
-      }
-    }
-    return manifest;
-  }
-  async writeEntry(_environmentId, packageName, buildId, tableName, sourceName, connectionName) {
-    const now = new Date().toISOString();
-    const id = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-    await this.db.run(`INSERT INTO ${this.table} (id, environment_name, package_name, build_id, table_name, source_name, connection_name, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
-      id,
-      this.environmentName,
-      packageName,
-      buildId,
-      tableName,
-      sourceName,
-      connectionName,
-      now,
-      now
-    ]);
-  }
-  async deleteEntry(id) {
-    await this.db.run(`DELETE FROM ${this.table} WHERE id = ?`, [id]);
-  }
-  async listEntries(_environmentId, packageName) {
-    const rows = await this.db.all(`SELECT * FROM ${this.table} WHERE environment_name = ? AND package_name = ? ORDER BY created_at DESC`, [this.environmentName, packageName]);
-    return rows.map(this.mapToEntry);
-  }
-  mapToEntry(row) {
-    return {
-      id: row.id,
-      environmentId: row.environment_name,
-      packageName: row.package_name,
-      buildId: row.build_id,
-      tableName: row.table_name,
-      sourceName: row.source_name,
-      connectionName: row.connection_name,
-      createdAt: new Date(row.created_at),
-      updatedAt: new Date(row.updated_at)
-    };
-  }
-}
-
 // src/storage/StorageManager.ts
-function escapeSQL2(value) {
-  return value.replace(/'/g, "''");
-}
-function configKey(c) {
-  return `${c.catalogUrl}|${c.dataPath}`;
-}
-function catalogNameForConfig(c) {
-  const hash = crypto3.createHash("sha256").update(configKey(c)).digest("hex").slice(0, 8);
-  return `manifest_lake_${hash}`;
-}
-async function readDuckLakeCatalogVersion(connection, catalogUrl, catalogName) {
-  if (!catalogUrl.startsWith("postgres:")) {
-    return;
-  }
-  const pgConnString = catalogUrl.slice("postgres:".length);
-  const tempDb = `${catalogName}_preflight`;
-  const escaped = escapeSQL2(pgConnString);
-  try {
-    await connection.run(`ATTACH '${escaped}' AS ${tempDb} (TYPE postgres, READ_ONLY);`);
-    const rows = await connection.all(`SELECT value FROM ${tempDb}.ducklake_metadata WHERE key = 'version' LIMIT 1;`);
-    const value = rows[0]?.value;
-    return typeof value === "string" ? value : undefined;
-  } catch (error) {
-    logger.warn("DuckLake catalog version preflight failed; falling back to ATTACH", {
-      catalogName,
-      error: redactPgSecrets(error instanceof Error ? error.message : String(error))
-    });
-    return;
-  } finally {
-    try {
-      await connection.run(`DETACH ${tempDb};`);
-    } catch {}
-  }
-}
-
 class StorageManager {
   connection = null;
-  duckDbConnection = null;
   repository = null;
-  defaultManifestStore = null;
-  environmentManifestStores = new Map;
-  attachedCatalogs = new Map;
-  duckLakeAttachMutex = new Mutex;
   config;
   constructor(config) {
     this.config = config;
@@ -230704,84 +230413,11 @@ class StorageManager {
     }
   }
   async initializeDuckDB(reinit) {
-    const dbPath = this.config.duckdb?.path;
-    const connection = new DuckDBConnection2(dbPath);
+    const connection = new DuckDBConnection2(this.config.duckdb?.path);
     await connection.initialize();
     await initializeSchema(connection, reinit);
     this.connection = connection;
-    this.duckDbConnection = connection;
     this.repository = new DuckDBRepository(connection);
-    this.defaultManifestStore = new DuckDBManifestStore(this.repository);
-  }
-  async initializeDuckLakeForEnvironment(environmentId, environmentName, config) {
-    if (!this.duckDbConnection) {
-      throw new Error("Storage not initialized. Call initialize() first.");
-    }
-    const key = configKey(config);
-    const catalogName = await this.duckLakeAttachMutex.runExclusive(async () => {
-      const existing = this.attachedCatalogs.get(key);
-      if (existing)
-        return existing;
-      const name = catalogNameForConfig(config);
-      await this.attachDuckLakeCatalog(config, name);
-      this.attachedCatalogs.set(key, name);
-      return name;
-    });
-    const store = new DuckLakeManifestStore(this.duckDbConnection, catalogName, environmentName);
-    await store.bootstrapSchema();
-    this.environmentManifestStores.set(environmentId, store);
-    logger.info("DuckLake manifest store initialized for environment", {
-      environmentId,
-      environmentName,
-      catalogName
-    });
-  }
-  async attachDuckLakeCatalog(config, catalogName) {
-    const connection = this.duckDbConnection;
-    await connection.run("INSTALL ducklake; LOAD ducklake;");
-    const isPostgres = config.catalogUrl.startsWith("postgres:");
-    if (isPostgres) {
-      await connection.run("INSTALL postgres; LOAD postgres;");
-    }
-    const catalogUrl = isPostgres ? withPgConnectTimeout(config.catalogUrl, pgConnectTimeoutSeconds()) : config.catalogUrl;
-    const escapedCatalogUrl = escapeSQL2(catalogUrl);
-    const escapedDataPath = escapeSQL2(config.dataPath);
-    const isCloudStorage = config.dataPath.startsWith("gs://") || config.dataPath.startsWith("s3://");
-    if (isCloudStorage) {
-      await connection.run("INSTALL httpfs; LOAD httpfs;");
-    }
-    if (isPostgres) {
-      const catalogVersion = await readDuckLakeCatalogVersion(connection, catalogUrl, catalogName);
-      if (catalogVersion && !isCatalogVersionSupported(catalogVersion)) {
-        const supportedMax = SUPPORTED_CATALOG_VERSIONS[SUPPORTED_CATALOG_VERSIONS.length - 1];
-        throw new ConnectionAuthError(`DuckLake catalog version ${catalogVersion} is newer than this Publisher's extension supports (max ${supportedMax}). Upgrade the Publisher image or downgrade the catalog.`);
-      }
-    }
-    let attachCmd = `ATTACH 'ducklake:${escapedCatalogUrl}' AS ${catalogName}`;
-    const attachOpts = [
-      `DATA_PATH '${escapedDataPath}'`,
-      "DATA_INLINING_ROW_LIMIT 100000"
-    ];
-    if (isCloudStorage) {
-      attachOpts.push("OVERRIDE_DATA_PATH true");
-    }
-    attachCmd += ` (${attachOpts.join(", ")});`;
-    logger.info(`Attaching DuckLake manifest catalog: ${redactPgSecrets(attachCmd)}`);
-    try {
-      await connection.run(attachCmd);
-    } catch (error) {
-      const outcome = handlePgAttachError(error, `DuckLake catalog credentials rejected for ${catalogName}`);
-      if (outcome.action === "swallow") {
-        logger.info(`DuckLake catalog ${catalogName} is already attached, skipping`);
-        return;
-      }
-      if (outcome.error instanceof ConnectionAuthError) {
-        logger.warn("DuckLake catalog credentials rejected", {
-          catalogName
-        });
-      }
-      throw outcome.error;
-    }
   }
   getRepository() {
     if (!this.repository) {
@@ -230789,27 +230425,11 @@ class StorageManager {
     }
     return this.repository;
   }
-  getManifestStore(environmentId) {
-    if (environmentId) {
-      const environmentStore = this.environmentManifestStores.get(environmentId);
-      if (environmentStore) {
-        return environmentStore;
-      }
-    }
-    if (!this.defaultManifestStore) {
-      throw new Error("Storage not initialized. Call initialize() first.");
-    }
-    return this.defaultManifestStore;
-  }
   async close() {
     if (this.connection) {
       await this.connection.close();
       this.connection = null;
-      this.duckDbConnection = null;
       this.repository = null;
-      this.defaultManifestStore = null;
-      this.environmentManifestStores.clear();
-      this.attachedCatalogs.clear();
     }
   }
   isInitialized() {
@@ -230818,16 +230438,72 @@ class StorageManager {
 }
 
 // src/service/environment.ts
-var import_api6 = __toESM(require_src(), 1);
+var import_api7 = __toESM(require_src(), 1);
 import { MalloyError as MalloyError4, Runtime as Runtime2 } from "@malloydata/malloy";
 init_constants();
 init_errors();
 init_logger();
-import crypto4 from "crypto";
-import * as fs6 from "fs";
+import crypto3 from "crypto";
+import * as fs7 from "fs";
 import * as path8 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
+// src/materialization_metrics.ts
+var import_api4 = __toESM(require_src(), 1);
+var roundCounter = null;
+var roundDuration = null;
+var manifestBindCounter = null;
+var sourceBuildDuration = null;
+var dropTablesCounter = null;
+function ensureTelemetry() {
+  if (roundCounter && roundDuration) {
+    return { counter: roundCounter, duration: roundDuration };
+  }
+  const meter2 = import_api4.metrics.getMeter("publisher");
+  if (!roundCounter) {
+    roundCounter = meter2.createCounter("publisher_materialization_rounds_total", {
+      description: "Materialization rounds completed. Labels: round ('round1'|'round2'|'auto'), outcome ('success'|'failed'|'cancelled')."
+    });
+  }
+  if (!roundDuration) {
+    roundDuration = meter2.createHistogram("publisher_materialization_round_duration_ms", {
+      description: "Wall-clock duration of a materialization round. Label: round ('round1'|'round2'|'auto').",
+      unit: "ms"
+    });
+  }
+  return { counter: roundCounter, duration: roundDuration };
+}
+function recordMaterializationRound(round, outcome, durationMs) {
+  const { counter, duration } = ensureTelemetry();
+  counter.add(1, { round, outcome });
+  duration.record(durationMs, { round });
+}
+function recordManifestBind(outcome) {
+  if (!manifestBindCounter) {
+    manifestBindCounter = import_api4.metrics.getMeter("publisher").createCounter("publisher_materialization_manifest_bind_total", {
+      description: "Manifest bind attempts. Label: outcome ('success'|'failure'|'timeout')."
+    });
+  }
+  manifestBindCounter.add(1, { outcome });
+}
+function recordSourceBuildDuration(durationMs) {
+  if (!sourceBuildDuration) {
+    sourceBuildDuration = import_api4.metrics.getMeter("publisher").createHistogram("publisher_materialization_source_build_duration_ms", {
+      description: "Wall-clock duration of building a single persist source.",
+      unit: "ms"
+    });
+  }
+  sourceBuildDuration.record(durationMs);
+}
+function recordDropTables(outcome) {
+  if (!dropTablesCounter) {
+    dropTablesCounter = import_api4.metrics.getMeter("publisher").createCounter("publisher_materialization_drop_tables_total", {
+      description: "Physical tables dropped on delete. Label: outcome ('success'|'failure')."
+    });
+  }
+  dropTablesCounter.add(1, { outcome });
+}
+
 // src/utils.ts
 import * as fs3 from "fs";
 import * as path5 from "path";
@@ -230845,14 +230521,74 @@ function ignoreDotfiles(file) {
   return path5.basename(file).startsWith(".");
 }
 
+// src/service/manifest_loader.ts
+init_logger();
+var import_client_s32 = __toESM(require_dist_cjs75(), 1);
+import { Storage } from "@google-cloud/storage";
+import * as fs4 from "fs/promises";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var gcsClient;
+var s3Client;
+function parseBucketUri(uri, scheme) {
+  const rest = uri.slice(scheme.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0 || slash === rest.length - 1) {
+    throw new Error(`Malformed manifest URI: ${uri}`);
+  }
+  return { bucket: rest.slice(0, slash), key: rest.slice(slash + 1) };
+}
+async function readManifestBytes(uri) {
+  if (uri.startsWith("gs://")) {
+    const { bucket, key } = parseBucketUri(uri, "gs://");
+    gcsClient ??= new Storage;
+    const [contents] = await gcsClient.bucket(bucket).file(key).download();
+    return contents.toString("utf8");
+  }
+  if (uri.startsWith("s3://")) {
+    const { bucket, key } = parseBucketUri(uri, "s3://");
+    s3Client ??= new import_client_s32.S3({ followRegionRedirects: true });
+    const res = await s3Client.send(new import_client_s32.GetObjectCommand({ Bucket: bucket, Key: key }));
+    if (!res.Body) {
+      throw new Error(`Empty S3 response for manifest URI: ${uri}`);
+    }
+    return res.Body.transformToString();
+  }
+  if (uri.startsWith("file://")) {
+    return fs4.readFile(fileURLToPath4(uri), "utf8");
+  }
+  return fs4.readFile(uri, "utf8");
+}
+async function fetchManifestEntries(uri) {
+  const raw = await readManifestBytes(uri);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse build manifest at ${uri}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const entries = {};
+  for (const [buildId, entry] of Object.entries(parsed.entries ?? {})) {
+    const physicalTableName = entry?.physicalTableName;
+    if (!physicalTableName) {
+      logger.warn("Manifest entry has no physicalTableName; skipping", {
+        uri,
+        buildId
+      });
+      continue;
+    }
+    entries[buildId] = { tableName: physicalTableName };
+  }
+  return entries;
+}
+
 // src/service/package.ts
 init_package_load_pool();
 init_constants();
 init_errors();
 init_logger();
-var import_api5 = __toESM(require_src(), 1);
+var import_api6 = __toESM(require_src(), 1);
 var import_recursive_readdir = __toESM(require_recursive_readdir(), 1);
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 import * as path7 from "path";
 import"@malloydata/db-duckdb/native";
 import {
@@ -230866,7 +230602,7 @@ import {
 
 // src/service/model.ts
 init_package_load_pool();
-var import_api4 = __toESM(require_src(), 1);
+var import_api5 = __toESM(require_src(), 1);
 import {
   Annotations as Annotations2,
   API,
@@ -230880,7 +230616,7 @@ import {
   MalloySQLParser,
   MalloySQLStatementType
 } from "@malloydata/malloy-sql";
-import * as fs4 from "fs/promises";
+import * as fs5 from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import * as path6 from "path";
 init_constants();
@@ -231382,6 +231118,9 @@ function assertWithinModelResponseLimits(rowCount, serializedBytes, { maxRows, m
 
 // src/service/model.ts
 var MALLOY_VERSION = createRequire2(import.meta.url)("@malloydata/malloy/package.json").version;
+function quoteMalloyIdentifier(name) {
+  return "`" + (name ?? "").replace(/\\/g, "\\\\").replace(/`/g, "\\`") + "`";
+}
 
 class Model {
   packageName;
@@ -231399,7 +231138,9 @@ class Model {
   filterMap;
   givens;
   fileLevelAuthorize = [];
-  meter = import_api4.metrics.getMeter("publisher");
+  discoveryCurationEnabled = false;
+  queryBoundary = { mode: "all", exploresDeclared: false, isQueryEntryPoint: true };
+  meter = import_api5.metrics.getMeter("publisher");
   queryExecutionHistogram = this.meter.createHistogram("malloy_model_query_duration", {
     description: "How long it takes to execute a Malloy model query",
     unit: "ms"
@@ -231501,12 +231242,7 @@ class Model {
     const target = this.extractSourceName(query);
     if (!target || !query)
       return;
-    const aliasOf = new Map;
-    const declRe = /source\s*:\s*(\w+)\s+is\s+(\w+)/g;
-    let match;
-    while ((match = declRe.exec(query)) !== null) {
-      aliasOf.set(match[1], match[2]);
-    }
+    const aliasOf = Model.buildAliasMap(query);
     let current = target;
     const seen = new Set;
     while (current && !seen.has(current)) {
@@ -231582,7 +231318,7 @@ class Model {
       return new Model(packageName, modelPath, dataStyles, modelType, undefined, undefined, undefined, undefined, undefined, undefined, computedError);
     }
   }
-  static fromSerialized(packageName, _packagePath, malloyConfig, data) {
+  static fromSerialized(packageName, _packagePath, malloyConfig, data, options) {
     const modelDef = data.modelDef;
     const modelInfo = data.modelInfo;
     const dataStyles = data.dataStyles ?? {};
@@ -231594,7 +231330,7 @@ class Model {
     if (!modelDef) {
       return new Model(packageName, data.modelPath, dataStyles, data.modelType, undefined, undefined, sources, queries, sourceInfos, data.modelType === "notebook" ? hydrateMarkdownOnlyCells(data.notebookCells) : undefined, undefined, filterMap, givens, modelInfo);
     }
-    const runtime = makeHydrationRuntime(malloyConfig);
+    const runtime = makeHydrationRuntime(malloyConfig, options?.buildManifest);
     const modelMaterializer = runtime._loadModelFromModelDef(modelDef);
     const runnableNotebookCells = data.modelType === "notebook" ? hydrateNotebookCells(runtime, data.notebookCells) : undefined;
     return new Model(packageName, data.modelPath, dataStyles, data.modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, undefined, filterMap, givens, modelInfo);
@@ -231609,14 +231345,163 @@ class Model {
   getType() {
     return this.modelType;
   }
+  curateForDiscovery(items) {
+    if (!items)
+      return items;
+    if (!this.discoveryCurationEnabled)
+      return items;
+    const exports = this.modelDef?.exports;
+    if (!Array.isArray(exports))
+      return items;
+    const exported = new Set(exports);
+    return items.filter((item) => item.name !== undefined && exported.has(item.name));
+  }
+  setDiscoveryCuration(enabled) {
+    this.discoveryCurationEnabled = enabled;
+  }
   getSources() {
-    return this.sources;
+    return this.curateForDiscovery(this.sources);
   }
   getSourceInfos() {
-    return this.sourceInfos;
+    return this.curateForDiscovery(this.sourceInfos);
   }
   getQueries() {
-    return this.queries;
+    return this.curateForDiscovery(this.queries);
+  }
+  hasEmptyDiscoverySurface() {
+    if (!this.discoveryCurationEnabled)
+      return false;
+    if (this.modelType !== "model" || !this.modelDef)
+      return false;
+    const exports = this.modelDef.exports;
+    if (!Array.isArray(exports) || exports.length > 0)
+      return false;
+    return (this.modelDef.imports?.length ?? 0) > 0;
+  }
+  setQueryBoundary(policy) {
+    this.queryBoundary = policy;
+  }
+  assertQueryBoundaryEarly(sourceName, queryName, query) {
+    if (this.modelPath.endsWith(NOTEBOOK_FILE_SUFFIX))
+      return "cleared";
+    const { mode, exploresDeclared, isQueryEntryPoint } = this.queryBoundary;
+    if (mode === "all" || !exploresDeclared)
+      return "cleared";
+    if (!isQueryEntryPoint) {
+      throw new NotQueryableError(`No queryable model "${this.modelPath}".`);
+    }
+    const curatedSources = this.curatedSourceNames();
+    const curatedQueries = new Set((this.getQueries() ?? []).map((q) => q.name).filter(Boolean));
+    if (queryName && !query) {
+      if (!sourceName && curatedQueries.has(queryName))
+        return "cleared";
+      if (sourceName && curatedSources.has(sourceName))
+        return "cleared";
+      throw new NotQueryableError(`No queryable query "${queryName}".`);
+    }
+    if (sourceName) {
+      if (curatedSources.has(sourceName))
+        return "cleared";
+      throw new NotQueryableError(`No queryable source "${sourceName}".`);
+    }
+    if (query) {
+      const target = this.extractSourceName(query);
+      if (target && !curatedSources.has(target) && !this.derivesFromCurated(target, query) && this.sources?.some((s) => s.name === target)) {
+        throw new NotQueryableError(`No queryable source "${target}".`);
+      }
+    }
+    return "deferred";
+  }
+  assertQueryBoundaryCompiled(compiledSource, query) {
+    if (this.modelPath.endsWith(NOTEBOOK_FILE_SUFFIX))
+      return;
+    const { mode, exploresDeclared, isQueryEntryPoint } = this.queryBoundary;
+    if (mode === "all" || !exploresDeclared)
+      return;
+    if (!isQueryEntryPoint) {
+      throw new NotQueryableError(`No queryable model "${this.modelPath}".`);
+    }
+    if (compiledSource) {
+      if (this.curatedSourceNames().has(compiledSource))
+        return;
+      if (query && this.derivesFromCurated(compiledSource, query))
+        return;
+    }
+    throw new NotQueryableError("Query target is not queryable.");
+  }
+  async assertQueryBoundaryForRunnable(runnable, query) {
+    const { mode, exploresDeclared } = this.queryBoundary;
+    if (mode === "all" || !exploresDeclared)
+      return;
+    this.assertQueryBoundaryCompiled(await this.resolveAuthorizeSourceFromRunnable(runnable), query);
+  }
+  curatedSourceNames() {
+    return new Set((this.getSources() ?? []).map((s) => s.name).filter((n) => n !== undefined));
+  }
+  derivesFromCurated(name, query) {
+    const curated = this.curatedSourceNames();
+    const aliasOf = Model.buildAliasMap(query);
+    let current = name;
+    const seen = new Set;
+    while (current && !seen.has(current)) {
+      if (curated.has(current))
+        return true;
+      seen.add(current);
+      current = aliasOf.get(current);
+    }
+    return false;
+  }
+  static buildAliasMap(query) {
+    const aliasOf = new Map;
+    const declRe = /source\s*:\s*(?:`([^`]+)`|(\w+))\s+is\s+(?:`([^`]+)`|(\w+))/g;
+    let match;
+    while ((match = declRe.exec(query)) !== null) {
+      aliasOf.set(match[1] ?? match[2], match[3] ?? match[4]);
+    }
+    return aliasOf;
+  }
+  async validateRenderTags() {
+    const mm = this.modelMaterializer;
+    if (!mm) {
+      return;
+    }
+    const { validateRenderTags: validateRenderTags2 } = await Promise.resolve().then(() => __toESM(require_dist10(), 1));
+    const targets = [];
+    for (const query of this.queries ?? []) {
+      if (!query.name || !query.annotations?.length) {
+        continue;
+      }
+      targets.push({
+        label: query.name,
+        queryString: `run: ${quoteMalloyIdentifier(query.name)}`
+      });
+    }
+    for (const source of this.sources ?? []) {
+      for (const view of source.views ?? []) {
+        if (!view.annotations?.length) {
+          continue;
+        }
+        targets.push({
+          label: `${source.name} -> ${view.name}`,
+          queryString: `run: ${quoteMalloyIdentifier(source.name)} -> ${quoteMalloyIdentifier(view.name)}`
+        });
+      }
+    }
+    for (const target of targets) {
+      let result;
+      try {
+        const prepared = await mm.loadQuery(target.queryString).getPreparedResult();
+        result = prepared.toStableResult();
+      } catch {
+        continue;
+      }
+      const errors2 = validateRenderTags2(result).filter((log) => log.severity === "error");
+      if (errors2.length > 0) {
+        throw new ModelCompilationError({
+          message: `Invalid renderer configuration on '${target.label}': ${errors2.map((e) => e.message).join("; ")}`
+        });
+      }
+    }
   }
   async getModel() {
     if (this.compilationError) {
@@ -231652,6 +231537,7 @@ class Model {
     let runnable;
     if (!this.modelMaterializer || !this.modelDef || !this.modelInfo)
       throw new BadRequestError("Model has no queryable entities.");
+    const boundary = this.assertQueryBoundaryEarly(sourceName, queryName, query);
     const earlySource = sourceName || (queryName ? this.queries?.find((q) => q.name === queryName)?.sourceName : undefined) || this.extractSourceName(query);
     if (earlySource) {
       await this.assertAuthorized(earlySource, givens ?? {});
@@ -231711,6 +231597,9 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       throw new BadRequestError(`Invalid query: ${errorMessage}`);
     }
     const compiledSource = await this.resolveAuthorizeSourceFromRunnable(runnable);
+    if (boundary === "deferred") {
+      this.assertQueryBoundaryCompiled(compiledSource, query);
+    }
     if (!(compiledSource && compiledSource === earlySource)) {
       await this.assertAuthorized(compiledSource, givens ?? {});
     }
@@ -231777,8 +231666,8 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       modelDef: JSON.stringify(this.modelDef),
       modelInfo: JSON.stringify(this.modelInfo ?? {}),
       sourceInfos: this.getSourceInfos()?.map((sourceInfo) => JSON.stringify(sourceInfo)),
-      sources: this.sources,
-      queries: this.queries,
+      sources: this.getSources(),
+      queries: this.getQueries(),
       givens: this.givens
     };
   }
@@ -231896,7 +231785,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
   static async getModelRuntime(packagePath, modelPath, malloyConfig, options) {
     const fullModelPath = path6.join(packagePath, modelPath);
     try {
-      if (!(await fs4.stat(fullModelPath)).isFile()) {
+      if (!(await fs5.stat(fullModelPath)).isFile()) {
         throw new ModelNotFoundError(`${modelPath} is not a file.`);
       }
     } catch {
@@ -231965,7 +231854,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
     let fileContents = undefined;
     let parse = undefined;
     try {
-      fileContents = await fs4.readFile(modelURL, "utf8");
+      fileContents = await fs5.readFile(modelURL, "utf8");
     } catch {
       throw new ModelNotFoundError("Model not found: " + modelPath);
     }
@@ -232058,20 +231947,24 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
   async getFileText(packagePath) {
     const fullPath = path6.join(packagePath, this.modelPath);
     try {
-      return await fs4.readFile(fullPath, "utf8");
+      return await fs5.readFile(fullPath, "utf8");
     } catch {
       throw new ModelNotFoundError(`Model file not found: ${this.modelPath}`);
     }
   }
 }
-function makeHydrationRuntime(malloyConfig) {
+function makeHydrationRuntime(malloyConfig, buildManifest) {
   const urlReader = new HackyDataStylesAccumulator(URL_READER);
   const config = malloyConfig instanceof MalloyConfig2 ? malloyConfig : (() => {
     const c = new MalloyConfig2({ connections: {} });
     c.wrapConnections(() => new FixedConnectionMap(malloyConfig, "duckdb"));
     return c;
   })();
-  return new Runtime({ urlReader, config });
+  return new Runtime({
+    urlReader,
+    config,
+    buildManifest: buildManifest ? { entries: buildManifest, strict: false } : undefined
+  });
 }
 function hydrateNotebookCells(runtime, notebookCells) {
   if (!notebookCells)
@@ -232116,8 +232009,6 @@ function hydrateMarkdownOnlyCells(notebookCells) {
 }
 
 // src/service/package.ts
-var ENABLE_LIST_MODEL_COMPILATION = true;
-
 class Package {
   environmentName;
   packageName;
@@ -232126,7 +232017,11 @@ class Package {
   models = new Map;
   packagePath;
   malloyConfig;
-  static meter = import_api5.metrics.getMeter("publisher");
+  buildManifestEntries;
+  manifestBindingStatus = "unbound";
+  manifestEntryCount = 0;
+  boundManifestUri = null;
+  static meter = import_api6.metrics.getMeter("publisher");
   static packageLoadHistogram = this.meter.createHistogram("malloy_package_load_duration", {
     description: "Time taken to load a Malloy package",
     unit: "ms"
@@ -232139,6 +232034,34 @@ class Package {
     this.databases = databases;
     this.models = models;
     this.malloyConfig = malloyConfig;
+    this.applyDiscoveryPolicyToModels();
+    this.applyQueryBoundaryToModels();
+  }
+  exploresDeclared() {
+    const explores = this.packageMetadata.explores;
+    return !!(explores && explores.length > 0);
+  }
+  exploreSet() {
+    const explores = this.packageMetadata.explores;
+    return explores && explores.length > 0 ? new Set(explores) : null;
+  }
+  applyDiscoveryPolicyToModels() {
+    const curationEnabled = this.exploresDeclared();
+    for (const model of this.models.values()) {
+      model.setDiscoveryCuration(curationEnabled);
+    }
+  }
+  applyQueryBoundaryToModels() {
+    const exploresDeclared = this.exploresDeclared();
+    const exploreSet = this.exploreSet();
+    const mode = this.packageMetadata.queryableSources === "all" ? "all" : "declared";
+    for (const [modelPath, model] of this.models) {
+      model.setQueryBoundary({
+        mode,
+        exploresDeclared,
+        isQueryEntryPoint: exploreSet ? exploreSet.has(modelPath) : true
+      });
+    }
   }
   static async create(environmentName, packageName, packagePath, environmentMalloyConfig) {
     assertSafeEnvironmentPath(packagePath);
@@ -232163,11 +232086,11 @@ class Package {
         status
       });
       try {
-        const stat6 = await fs5.lstat(packagePath).catch(() => null);
+        const stat6 = await fs6.lstat(packagePath).catch(() => null);
         if (stat6?.isSymbolicLink()) {
           logger.info(`Skipping cleanup of symlinked package path on failure: ${packagePath}`);
         } else {
-          await fs5.rm(packagePath, { recursive: true, force: true });
+          await fs6.rm(packagePath, { recursive: true, force: true });
           logger.info(`Cleaned up failed package directory: ${packagePath}`);
         }
       } catch (cleanupError) {
@@ -232209,7 +232132,10 @@ class Package {
     const packageConfig = {
       name: outcome.packageMetadata.name,
       description: outcome.packageMetadata.description,
-      resource: `${API_PREFIX}/environments/${environmentName}/packages/${packageName}`
+      resource: `${API_PREFIX}/environments/${environmentName}/packages/${packageName}`,
+      explores: outcome.packageMetadata.explores,
+      queryableSources: outcome.packageMetadata.queryableSources,
+      manifestLocation: outcome.packageMetadata.manifestLocation ?? null
     };
     const models = new Map;
     for (const sm of outcome.models) {
@@ -232222,7 +232148,9 @@ class Package {
         });
         throw err;
       }
-      models.set(sm.modelPath, Model.fromSerialized(packageName, packagePath, malloyConfig, sm));
+      const model = Model.fromSerialized(packageName, packagePath, malloyConfig, sm);
+      await model.validateRenderTags();
+      models.set(sm.modelPath, model);
     }
     const endTime = performance.now();
     const executionTime = endTime - startTime;
@@ -232234,13 +232162,101 @@ class Package {
       packageName,
       duration: formatDuration(executionTime)
     });
-    return new Package(environmentName, packageName, packagePath, packageConfig, databases, models, malloyConfig);
+    const pkg = new Package(environmentName, packageName, packagePath, packageConfig, databases, models, malloyConfig);
+    const invalidMsg = pkg.formatInvalidExplores();
+    if (invalidMsg) {
+      logger.warn(`Package ${packageName} has invalid explores`, {
+        packageName,
+        detail: invalidMsg
+      });
+    }
+    pkg.logEmptyDiscoveryWarnings();
+    return pkg;
   }
   getPackageName() {
     return this.packageName;
   }
   getPackageMetadata() {
-    return this.packageMetadata;
+    const metadata = {
+      ...this.packageMetadata,
+      name: this.packageName,
+      manifestBindingStatus: this.manifestBindingStatus,
+      manifestEntryCount: this.manifestEntryCount,
+      boundManifestUri: this.boundManifestUri
+    };
+    const warnings = this.exploreWarnings();
+    if (warnings.length > 0) {
+      metadata.exploresWarnings = warnings;
+    }
+    return metadata;
+  }
+  getBuildManifestEntries() {
+    return this.buildManifestEntries;
+  }
+  setBoundManifestUri(uri) {
+    this.boundManifestUri = uri;
+  }
+  markManifestBindFailed() {
+    this.manifestBindingStatus = "live_fallback";
+  }
+  recordManifestBinding(buildManifest) {
+    const count = Object.keys(buildManifest).length;
+    this.buildManifestEntries = count > 0 ? buildManifest : undefined;
+    this.manifestEntryCount = count;
+    this.manifestBindingStatus = count > 0 ? "bound" : "unbound";
+    if (count === 0) {
+      this.boundManifestUri = null;
+    }
+  }
+  getInvalidExplores(exploresOverride) {
+    const declared = exploresOverride ?? this.packageMetadata.explores;
+    if (!declared || declared.length === 0)
+      return [];
+    const malloyModels = new Set(Array.from(this.models.keys()).filter((p) => p.endsWith(MODEL_FILE_SUFFIX)));
+    const problems = [];
+    for (const entry of declared) {
+      if (entry.endsWith(NOTEBOOK_FILE_SUFFIX)) {
+        problems.push({
+          entry,
+          reason: `notebooks are always public and cannot be explores. ` + `Fix: remove it, and list a ${MODEL_FILE_SUFFIX} model file instead.`
+        });
+      } else if (!malloyModels.has(entry)) {
+        problems.push({
+          entry,
+          reason: `file not found in the package. Fix: list a ${MODEL_FILE_SUFFIX} ` + `file relative to the package root (e.g. "index.malloy").`
+        });
+      }
+    }
+    return problems;
+  }
+  exploreWarnings(exploresOverride) {
+    return this.getInvalidExplores(exploresOverride).map((p) => `Invalid explores entry '${p.entry}' in ${PACKAGE_MANIFEST_NAME}: ${p.reason}`);
+  }
+  formatInvalidExplores(exploresOverride) {
+    return this.exploreWarnings(exploresOverride).join(`
+`);
+  }
+  emptyDiscoveryWarnings() {
+    const exploreSet = this.exploreSet();
+    const warnings = [];
+    for (const [modelPath, model] of this.models) {
+      if (!modelPath.endsWith(MODEL_FILE_SUFFIX))
+        continue;
+      if (exploreSet && !exploreSet.has(modelPath))
+        continue;
+      if (model.hasEmptyDiscoverySurface()) {
+        warnings.push(`Model "${modelPath}" is listed but exposes nothing: it only ` + `imports other files and re-exports none of their sources. ` + `Add e.g. 'export { source_name }' to surface sources on ` + `this model.`);
+      }
+    }
+    return warnings;
+  }
+  logEmptyDiscoveryWarnings() {
+    for (const warning of this.emptyDiscoveryWarnings()) {
+      logger.warn(`Package ${this.packageName} has a blank-looking model`, {
+        packageName: this.packageName,
+        detail: warning
+      });
+    }
   }
   listDatabases() {
     return this.databases;
@@ -232295,10 +232311,36 @@ class Package {
         });
         nextModels.set(sm.modelPath, Model.fromCompilationError(this.packageName, sm.modelPath, sm.modelType, err));
       } else {
-        nextModels.set(sm.modelPath, Model.fromSerialized(this.packageName, this.packagePath, this.malloyConfig, sm));
+        const model = Model.fromSerialized(this.packageName, this.packagePath, this.malloyConfig, sm, { buildManifest });
+        try {
+          await model.validateRenderTags();
+          nextModels.set(sm.modelPath, model);
+        } catch (renderErr) {
+          const err = renderErr instanceof Error ? renderErr : new Error(String(renderErr));
+          logger.warn("Render-tag validation failed during reload", {
+            packageName: this.packageName,
+            modelPath: sm.modelPath,
+            error: err.message
+          });
+          nextModels.set(sm.modelPath, Model.fromCompilationError(this.packageName, sm.modelPath, sm.modelType, err));
+        }
       }
     }
     this.models = nextModels;
+    this.packageMetadata.explores = outcome.packageMetadata.explores;
+    this.packageMetadata.queryableSources = outcome.packageMetadata.queryableSources;
+    this.packageMetadata.manifestLocation = outcome.packageMetadata.manifestLocation ?? null;
+    this.applyDiscoveryPolicyToModels();
+    this.applyQueryBoundaryToModels();
+    this.recordManifestBinding(buildManifest);
+    const invalidMsg = this.formatInvalidExplores();
+    if (invalidMsg) {
+      logger.warn(`Package ${this.packageName} has invalid explores`, {
+        packageName: this.packageName,
+        detail: invalidMsg
+      });
+    }
+    this.logEmptyDiscoveryWarnings();
   }
   async getModelFileText(modelPath) {
     const model = this.getModel(modelPath);
@@ -232308,16 +232350,17 @@ class Package {
     return await model.getFileText(this.packagePath);
   }
   async listModels() {
+    const exploreSet = this.exploreSet();
     const values = await Promise.all(Array.from(this.models.keys()).filter((modelPath) => {
-      return modelPath.endsWith(MODEL_FILE_SUFFIX);
+      if (!modelPath.endsWith(MODEL_FILE_SUFFIX))
+        return false;
+      return exploreSet ? exploreSet.has(modelPath) : true;
     }).map(async (modelPath) => {
       let error;
-      if (ENABLE_LIST_MODEL_COMPILATION) {
-        try {
-          await this.models.get(modelPath)?.getModel();
-        } catch (modelError) {
-          error = modelError instanceof Error ? modelError.message : undefined;
-        }
+      try {
+        await this.models.get(modelPath)?.getModel();
+      } catch (modelError) {
+        error = modelError instanceof Error ? modelError.message : undefined;
       }
       return {
         environmentName: this.environmentName,
@@ -232332,10 +232375,7 @@ class Package {
     return await Promise.all(Array.from(this.models.keys()).filter((modelPath) => {
       return modelPath.endsWith(NOTEBOOK_FILE_SUFFIX);
     }).map(async (modelPath) => {
-      let error;
-      if (ENABLE_LIST_MODEL_COMPILATION) {
-        error = this.models.get(modelPath)?.getNotebookError();
-      }
+      const error = this.models.get(modelPath)?.getNotebookError();
       return {
         environmentName: this.environmentName,
         packageName: this.packageName,
@@ -232376,7 +232416,7 @@ class Package {
   static async validatePackageManifestExistsOrThrowError(packagePath) {
     const packageConfigPath = safeJoinUnderRoot(packagePath, PACKAGE_MANIFEST_NAME);
     try {
-      await fs5.stat(packageConfigPath);
+      await fs6.stat(packageConfigPath);
     } catch {
       logger.error(`Can't find ${packageConfigPath}`);
       throw new PackageNotFoundError(`Package manifest for ${packagePath} does not exist.`);
@@ -232426,19 +232466,22 @@ class Package {
   }
   setPackageMetadata(packageMetadata) {
     this.packageMetadata = packageMetadata;
+    this.applyDiscoveryPolicyToModels();
+    this.applyQueryBoundaryToModels();
   }
 }
 
 // src/service/environment.ts
 var STAGING_DIR_NAME = ".staging";
 var RETIRED_DIR_NAME = ".retired";
+var MANIFEST_FETCH_TIMEOUT_MS = 15000;
 var RETIRED_CONNECTION_DRAIN_MS = 30000;
 var queryAdmissionRejectionsCounter = null;
 var packageAdmissionRejectionsCounter = null;
 function getQueryAdmissionRejectionsCounter() {
   if (queryAdmissionRejectionsCounter)
     return queryAdmissionRejectionsCounter;
-  queryAdmissionRejectionsCounter = import_api6.metrics.getMeter("publisher").createCounter("publisher_query_admission_rejections_total", {
+  queryAdmissionRejectionsCounter = import_api7.metrics.getMeter("publisher").createCounter("publisher_query_admission_rejections_total", {
     description: "Queries rejected with 503 because Environment.assertCanAdmitQuery() observed memory back-pressure"
   });
   return queryAdmissionRejectionsCounter;
@@ -232447,7 +232490,7 @@ function getPackageAdmissionRejectionsCounter() {
   if (packageAdmissionRejectionsCounter) {
     return packageAdmissionRejectionsCounter;
   }
-  packageAdmissionRejectionsCounter = import_api6.metrics.getMeter("publisher").createCounter("publisher_package_admission_rejections_total", {
+  packageAdmissionRejectionsCounter = import_api7.metrics.getMeter("publisher").createCounter("publisher_package_admission_rejections_total", {
     description: "Package loads rejected with 503 because Environment.assertCanAdmitNewPackage() observed memory back-pressure"
   });
   return packageAdmissionRejectionsCounter;
@@ -232485,7 +232528,7 @@ class Environment {
       return;
     const readmePath = path8.join(this.environmentPath, "README.md");
     try {
-      await fs6.promises.writeFile(readmePath, readme, "utf-8");
+      await fs7.promises.writeFile(readmePath, readme, "utf-8");
       logger.info(`Updated README.md for environment ${this.environmentName}`);
     } catch (err) {
       logger.error(`Failed to write README.md`, { error: err });
@@ -232497,9 +232540,6 @@ class Environment {
       this.metadata.readme = payload.readme;
       await this.writeEnvironmentReadme(payload.readme);
     }
-    if (payload.materializationStorage !== undefined) {
-      this.metadata.materializationStorage = payload.materializationStorage;
-    }
     if (payload.connections) {
       const payloadConnections = payload.connections;
       await this.runConnectionUpdateExclusive(async () => {
@@ -232517,7 +232557,7 @@ class Environment {
   }
   static async create(environmentName, environmentPath, connections) {
     assertSafeEnvironmentPath(environmentPath);
-    if (!(await fs6.promises.stat(environmentPath))?.isDirectory()) {
+    if (!(await fs7.promises.stat(environmentPath))?.isDirectory()) {
       throw new EnvironmentNotFoundError(`Environment path ${environmentPath} not found`);
     }
     logger.info(`Creating environment with connection configuration`);
@@ -232535,7 +232575,7 @@ class Environment {
   async reloadEnvironmentMetadata() {
     let readme = "";
     try {
-      readme = (await fs6.promises.readFile(safeJoinUnderRoot(this.environmentPath, README_NAME))).toString();
+      readme = (await fs7.promises.readFile(safeJoinUnderRoot(this.environmentPath, README_NAME))).toString();
     } catch {}
     this.metadata = {
       ...this.metadata,
@@ -232548,6 +232588,9 @@ class Environment {
   async compileSource(packageName, modelName, source, includeSql = false, givens) {
     assertSafePackageName(packageName);
     assertSafeRelativeModelPath(modelName);
+    if (modelName.endsWith(NOTEBOOK_FILE_SUFFIX)) {
+      throw new BadRequestError(`Cannot compile against a notebook ("${modelName}"). ` + `/compile takes a .malloy model path for namespace context.`);
+    }
     return this.withPackageLock(packageName, async () => {
       const modelPath = safeJoinUnderRoot(this.environmentPath, packageName, modelName);
       const modelDir = path8.dirname(modelPath);
@@ -232555,7 +232598,7 @@ class Environment {
       const virtualUri = virtualUrl.toString();
       let modelContent = "";
       try {
-        modelContent = await fs6.promises.readFile(modelPath, "utf8");
+        modelContent = await fs7.promises.readFile(modelPath, "utf8");
       } catch {}
       const fullSource = modelContent ? `${modelContent}
 ${source}` : source;
@@ -232570,11 +232613,14 @@ ${source}` : source;
       const pkg = await this._loadOrGetPackageLocked(packageName);
       const gateModel = pkg.getModel(modelName);
       if (gateModel) {
+        gateModel.assertQueryBoundaryEarly(undefined, undefined, source);
         await gateModel.assertAuthorizedForText(source, givens ?? {});
       }
+      const boundManifestEntries = pkg.getBuildManifestEntries();
       const runtime = new Runtime2({
         urlReader: interceptingReader,
-        config: pkg.getMalloyConfig()
+        config: pkg.getMalloyConfig(),
+        buildManifest: boundManifestEntries ? { entries: boundManifestEntries, strict: false } : undefined
       });
       try {
         const modelMaterializer = runtime.loadModel(virtualUrl);
@@ -232583,6 +232629,9 @@ ${source}` : source;
         try {
           queryMaterializer = modelMaterializer.loadFinalQuery();
         } catch {}
+        if (queryMaterializer && gateModel) {
+          await gateModel.assertQueryBoundaryForRunnable(queryMaterializer, source);
+        }
         if (queryMaterializer && gateModel?.hasAuthorize()) {
           await gateModel.assertAuthorizedForRunnable(queryMaterializer, givens ?? {});
         }
@@ -232688,10 +232737,10 @@ ${source}` : source;
     return this.getOrCreatePackageMutex(packageName).runExclusive(fn);
   }
   allocateStagingPath(packageName) {
-    return safeJoinUnderRoot(this.environmentPath, STAGING_DIR_NAME, `${packageName}-${crypto4.randomUUID()}`);
+    return safeJoinUnderRoot(this.environmentPath, STAGING_DIR_NAME, `${packageName}-${crypto3.randomUUID()}`);
   }
   allocateRetiredPath(packageName) {
-    return safeJoinUnderRoot(this.environmentPath, RETIRED_DIR_NAME, `${packageName}-${crypto4.randomUUID()}`);
+    return safeJoinUnderRoot(this.environmentPath, RETIRED_DIR_NAME, `${packageName}-${crypto3.randomUUID()}`);
   }
   static async sweepStaleInstallDirs(environmentPath) {
     assertSafeEnvironmentPath(environmentPath);
@@ -232702,7 +232751,7 @@ ${source}` : source;
       if (path8.basename(dir) !== dirName)
         continue;
       try {
-        await fs6.promises.rm(dir, { recursive: true, force: true });
+        await fs7.promises.rm(dir, { recursive: true, force: true });
       } catch (err) {
         logger.warn(`Failed to sweep stale ${dirName} dir at ${dir}`, {
           error: err
@@ -232751,6 +232800,7 @@ ${source}` : source;
       logger.debug(`Loading package ${packageName}...`);
       const packagePath = safeJoinUnderRoot(this.environmentPath, packageName);
       const _package = await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig);
+      await this.bindManifestIfConfigured(_package);
       if (existingPackage !== undefined && reload) {
         this.retireConnectionGeneration(`package ${packageName}`, () => existingPackage.getMalloyConfig().shutdown("close"));
       }
@@ -232768,7 +232818,7 @@ ${source}` : source;
   async addPackage(packageName, options = {}) {
     assertSafePackageName(packageName);
     const packagePath = safeJoinUnderRoot(this.environmentPath, packageName);
-    if (!await fs6.promises.access(packagePath).then(() => true).catch(() => false) || !(await fs6.promises.stat(packagePath))?.isDirectory()) {
+    if (!await fs7.promises.access(packagePath).then(() => true).catch(() => false) || !(await fs7.promises.stat(packagePath))?.isDirectory()) {
       throw new PackageNotFoundError(`Package ${packageName} not found`);
     }
     this.assertCanAdmitNewPackage(packageName, "add a new package", options.allowAdmission === true);
@@ -232794,10 +232844,10 @@ ${source}` : source;
     this.setPackageStatus(packageName, "serving" /* SERVING */);
     return this.packages.get(packageName);
   }
-  async installPackage(packageName, downloader) {
+  async installPackage(packageName, downloader, validate) {
     assertSafePackageName(packageName);
     const stagingPath = this.allocateStagingPath(packageName);
-    await fs6.promises.mkdir(path8.dirname(stagingPath), { recursive: true });
+    await fs7.promises.mkdir(path8.dirname(stagingPath), { recursive: true });
     logger.debug("install.phase1.download.started", {
       environmentName: this.environmentName,
       packageName,
@@ -232807,7 +232857,7 @@ ${source}` : source;
     try {
       await downloader(stagingPath);
     } catch (err) {
-      await fs6.promises.rm(stagingPath, { recursive: true, force: true }).catch(() => {});
+      await fs7.promises.rm(stagingPath, { recursive: true, force: true }).catch(() => {});
       throw err;
     }
     logger.debug("install.phase1.download.completed", {
@@ -232823,13 +232873,13 @@ ${source}` : source;
       const canonicalPath = safeJoinUnderRoot(this.environmentPath, packageName);
       let retiredPath;
       const oldPackage = this.packages.get(packageName);
-      const oldExistsOnDisk = await fs6.promises.access(canonicalPath).then(() => true).catch(() => false);
+      const oldExistsOnDisk = await fs7.promises.access(canonicalPath).then(() => true).catch(() => false);
       if (oldExistsOnDisk) {
         retiredPath = this.allocateRetiredPath(packageName);
-        await fs6.promises.mkdir(path8.dirname(retiredPath), {
+        await fs7.promises.mkdir(path8.dirname(retiredPath), {
           recursive: true
         });
-        await fs6.promises.rename(canonicalPath, retiredPath);
+        await fs7.promises.rename(canonicalPath, retiredPath);
         logger.debug("install.phase2.retired_old", {
           environmentName: this.environmentName,
           packageName,
@@ -232838,20 +232888,24 @@ ${source}` : source;
       }
       let newPackage;
       try {
-        await fs6.promises.rename(stagingPath, canonicalPath);
+        await fs7.promises.rename(stagingPath, canonicalPath);
         this.setPackageStatus(packageName, "loading" /* LOADING */);
         newPackage = await Package.create(this.environmentName, packageName, canonicalPath, () => this.malloyConfig.malloyConfig);
+        const validationMsg = validate?.(newPackage);
+        if (validationMsg) {
+          throw new BadRequestError(validationMsg);
+        }
         logger.debug("install.phase2.committed", {
           environmentName: this.environmentName,
           packageName,
           canonicalPath
         });
       } catch (err) {
-        await fs6.promises.rm(canonicalPath, { recursive: true, force: true }).catch(() => {});
+        await fs7.promises.rm(canonicalPath, { recursive: true, force: true }).catch(() => {});
         let restored = false;
         if (retiredPath) {
           try {
-            await fs6.promises.rename(retiredPath, canonicalPath);
+            await fs7.promises.rename(retiredPath, canonicalPath);
             restored = true;
           } catch (restoreErr) {
             logger.error("Failed to restore retired package after install rollback", {
@@ -232861,7 +232915,7 @@ ${source}` : source;
             });
           }
         }
-        await fs6.promises.rm(stagingPath, { recursive: true, force: true }).catch(() => {});
+        await fs7.promises.rm(stagingPath, { recursive: true, force: true }).catch(() => {});
         this.deletePackageStatus(packageName);
         logger.debug("install.phase2.rollback", {
           environmentName: this.environmentName,
@@ -232871,6 +232925,7 @@ ${source}` : source;
         });
         throw err;
       }
+      await this.bindManifestIfConfigured(newPackage);
       this.packages.set(packageName, newPackage);
       this.setPackageStatus(packageName, "serving" /* SERVING */);
       if (oldPackage) {
@@ -232884,7 +232939,7 @@ ${source}` : source;
             packageName,
             retiredPath: pathToClean
           });
-          fs6.promises.rm(pathToClean, { recursive: true, force: true }).catch((err) => {
+          fs7.promises.rm(pathToClean, { recursive: true, force: true }).catch((err) => {
             logger.warn(`Failed to clean up retired package directory ${pathToClean}`, { error: err });
           });
         });
@@ -232902,6 +232957,55 @@ ${source}` : source;
       await pkg.reloadAllModels(manifest);
     });
   }
+  async bindManifestIfConfigured(pkg) {
+    const manifestLocation = pkg.getPackageMetadata().manifestLocation;
+    if (!manifestLocation) {
+      return;
+    }
+    await this.bindManifest(pkg, manifestLocation);
+  }
+  async bindManifest(pkg, manifestLocation) {
+    const packageName = pkg.getPackageName();
+    try {
+      const entries = await this.fetchManifestEntriesWithTimeout(manifestLocation);
+      await pkg.reloadAllModels(entries);
+      pkg.setBoundManifestUri(manifestLocation);
+      recordManifestBind("success");
+      logger.info("Bound build manifest to package", {
+        environmentName: this.environmentName,
+        packageName,
+        manifestLocation,
+        entryCount: Object.keys(entries).length
+      });
+    } catch (err) {
+      pkg.markManifestBindFailed();
+      const timedOut = err instanceof Error && err.message.includes("Timed out after");
+      recordManifestBind(timedOut ? "timeout" : "failure");
+      logger.warn("Failed to bind build manifest; serving live", {
+        environmentName: this.environmentName,
+        packageName,
+        manifestLocation,
+        timedOut,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  async fetchManifestEntriesWithTimeout(manifestLocation) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`Timed out after ${MANIFEST_FETCH_TIMEOUT_MS}ms fetching manifest ${manifestLocation}`)), MANIFEST_FETCH_TIMEOUT_MS);
+    });
+    try {
+      return await Promise.race([
+        fetchManifestEntries(manifestLocation),
+        timeout
+      ]);
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
+  }
   async getModelFileText(packageName, modelPath) {
     assertSafePackageName(packageName);
     assertSafeRelativeModelPath(modelPath);
@@ -232919,7 +233023,7 @@ ${source}` : source;
     try {
       let existingManifest = {};
       try {
-        const content = await fs6.promises.readFile(manifestPath, "utf-8");
+        const content = await fs7.promises.readFile(manifestPath, "utf-8");
         existingManifest = JSON.parse(content);
       } catch (_err) {
         logger.warn(`Could not read manifest for ${packageName}`);
@@ -232927,9 +233031,12 @@ ${source}` : source;
       const updatedManifest = {
         ...existingManifest,
         name: metadata.name,
-        description: metadata.description
+        description: metadata.description,
+        ...metadata.explores !== undefined ? { explores: metadata.explores } : {},
+        ...metadata.queryableSources !== undefined ? { queryableSources: metadata.queryableSources } : {},
+        ...metadata.manifestLocation !== undefined ? { manifestLocation: metadata.manifestLocation } : {}
       };
-      await fs6.promises.writeFile(manifestPath, JSON.stringify(updatedManifest, null, 2), "utf-8");
+      await fs7.promises.writeFile(manifestPath, JSON.stringify(updatedManifest, null, 2), "utf-8");
       logger.info(`Updated publisher.json for ${packageName}`);
     } catch (error) {
       logger.error(`Failed to update publisher.json`, { error });
@@ -232946,16 +233053,39 @@ ${source}` : source;
       if (body.name) {
         _package.setName(body.name);
       }
+      const existing = _package.getPackageMetadata();
+      const normalizedExplores = body.explores?.map(normalizeModelPath);
+      const explores = normalizedExplores !== undefined ? normalizedExplores : existing.explores;
+      const queryableSources = body.queryableSources !== undefined ? body.queryableSources : existing.queryableSources;
+      const manifestLocation = body.manifestLocation !== undefined ? body.manifestLocation : existing.manifestLocation;
       _package.setPackageMetadata({
         name: body.name,
         description: body.description,
         resource: body.resource,
-        location: body.location
+        location: body.location,
+        explores,
+        queryableSources,
+        manifestLocation
       });
+      const invalidMsg = _package.formatInvalidExplores();
+      if (invalidMsg) {
+        _package.setPackageMetadata(existing);
+        throw new BadRequestError(invalidMsg);
+      }
       await this.writePackageManifest(packageName, {
         name: packageName,
-        description: body.description
+        description: body.description,
+        explores: normalizedExplores,
+        queryableSources: body.queryableSources,
+        manifestLocation: body.manifestLocation
       });
+      if (body.manifestLocation !== undefined) {
+        if (body.manifestLocation) {
+          await this.bindManifest(_package, body.manifestLocation);
+        } else {
+          await _package.reloadAllModels({});
+        }
+      }
       return _package.getPackageMetadata();
     });
   }
@@ -232995,10 +233125,10 @@ ${source}` : source;
       const retiredPath = this.allocateRetiredPath(packageName);
       let renamed = false;
       try {
-        await fs6.promises.mkdir(path8.dirname(retiredPath), {
+        await fs7.promises.mkdir(path8.dirname(retiredPath), {
           recursive: true
         });
-        await fs6.promises.rename(canonicalPath, retiredPath);
+        await fs7.promises.rename(canonicalPath, retiredPath);
         renamed = true;
       } catch (err) {
         logger.error("Error renaming package directory to retired during unload", {
@@ -233011,13 +233141,28 @@ ${source}` : source;
       this.packageStatuses.delete(packageName);
       if (renamed) {
         setImmediate(() => {
-          fs6.promises.rm(retiredPath, { recursive: true, force: true }).catch((err) => {
+          fs7.promises.rm(retiredPath, { recursive: true, force: true }).catch((err) => {
             logger.warn(`Failed to clean up retired package directory ${retiredPath}`, { error: err });
           });
         });
       }
     });
   }
+  async unloadPackage(packageName) {
+    assertSafePackageName(packageName);
+    return this.withPackageLock(packageName, async () => {
+      const _package = this.packages.get(packageName);
+      if (!_package) {
+        return;
+      }
+      if (this.packageStatuses.get(packageName)?.status === "serving" /* SERVING */) {
+        this.setPackageStatus(packageName, "unloading" /* UNLOADING */);
+      }
+      this.retireConnectionGeneration(`package ${packageName}`, () => _package.getMalloyConfig().shutdown("close"));
+      this.packages.delete(packageName);
+      this.packageStatuses.delete(packageName);
+    });
+  }
   updateConnections(malloyConfig, _apiConnections, afterPreviousRelease) {
     const previousMalloyConfig = this.malloyConfig;
     this.malloyConfig = malloyConfig;
@@ -233070,7 +233215,7 @@ ${source}` : source;
   async deleteDuckDBConnection(connectionName) {
     const duckdbPath = path8.join(this.environmentPath, `${connectionName}.duckdb`);
     try {
-      await fs6.promises.rm(duckdbPath, { force: true });
+      await fs7.promises.rm(duckdbPath, { force: true });
       logger.info(`Removed DuckDB connection file ${connectionName} from environment ${this.environmentName}`);
     } catch (error) {
       logger.error(`Failed to remove DuckDB connection file ${connectionName} from environment ${this.environmentName}`, { error });
@@ -233131,11 +233276,11 @@ function validateEnvironmentAzureUrls(environment) {
 }
 async function clearMountTarget(targetPath) {
   try {
-    const stats = await fs7.promises.lstat(targetPath);
+    const stats = await fs8.promises.lstat(targetPath);
     if (stats.isDirectory() && !stats.isSymbolicLink()) {
-      await fs7.promises.rm(targetPath, { recursive: true, force: true });
+      await fs8.promises.rm(targetPath, { recursive: true, force: true });
     } else {
-      await fs7.promises.unlink(targetPath);
+      await fs8.promises.unlink(targetPath);
     }
   } catch {}
 }
@@ -233148,7 +233293,7 @@ class EnvironmentStore {
   finishedInitialization;
   isInitialized = false;
   storageManager;
-  s3Client = new import_client_s32.S3({
+  s3Client = new import_client_s33.S3({
     followRegionRedirects: true
   });
   gcsClient;
@@ -233156,7 +233301,7 @@ class EnvironmentStore {
   inPlaceEnvs = new Set;
   constructor(serverRootPath) {
     this.serverRootPath = serverRootPath;
-    this.gcsClient = new Storage;
+    this.gcsClient = new Storage2;
     const watchEnvList = (process.env.PUBLISHER_WATCH || "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
     for (const envName of watchEnvList)
       this.inPlaceEnvs.add(envName);
@@ -233215,7 +233360,7 @@ class EnvironmentStore {
         if (existingEnvironments.length > 0) {
           await Promise.all(existingEnvironments.map(async (dbEnvironment) => {
             try {
-              const environmentExists = await fs7.promises.access(dbEnvironment.path).then(() => true).catch(() => false);
+              const environmentExists = await fs8.promises.access(dbEnvironment.path).then(() => true).catch(() => false);
               if (!environmentExists) {
                 const environmentConfig = environmentManifest.environments.find((p) => p.name === dbEnvironment.name);
                 if (environmentConfig) {
@@ -233318,13 +233463,6 @@ class EnvironmentStore {
     } else {
       dbEnvironment = await repository.createEnvironment(environmentData);
     }
-    const materializationStorage = environment.metadata?.materializationStorage;
-    if (materializationStorage?.catalogUrl && materializationStorage?.dataPath) {
-      await this.storageManager.initializeDuckLakeForEnvironment(dbEnvironment.id, dbEnvironment.name, {
-        catalogUrl: materializationStorage.catalogUrl,
-        dataPath: materializationStorage.dataPath
-      });
-    }
     return dbEnvironment;
   }
   async addPackages(environment, environmentId, repository) {
@@ -233461,12 +233599,12 @@ class EnvironmentStore {
   }
   async cleanupAndCreatePublisherPath() {
     const reInit = process.env.INITIALIZE_STORAGE === "true";
-    await fs7.promises.mkdir(this.serverRootPath, { recursive: true });
+    await fs8.promises.mkdir(this.serverRootPath, { recursive: true });
     if (reInit) {
       const uploadDocsPath2 = path9.join(this.serverRootPath, PUBLISHER_DATA_DIR);
       logger.info(`Reinitialization mode: Cleaning up upload documents path ${uploadDocsPath2}`);
       try {
-        await fs7.promises.rm(uploadDocsPath2, {
+        await fs8.promises.rm(uploadDocsPath2, {
           recursive: true,
           force: true
         });
@@ -233481,7 +233619,7 @@ class EnvironmentStore {
       logger.info(`Using existing publisher path`);
     }
     const uploadDocsPath = path9.join(this.serverRootPath, PUBLISHER_DATA_DIR);
-    await fs7.promises.mkdir(uploadDocsPath, { recursive: true });
+    await fs8.promises.mkdir(uploadDocsPath, { recursive: true });
   }
   async listEnvironments(skipInitializationCheck = false) {
     if (!skipInitializationCheck) {
@@ -233601,9 +233739,6 @@ class EnvironmentStore {
     if (!newEnvironment.metadata)
       newEnvironment.metadata = {};
     newEnvironment.metadata.location = absoluteEnvironmentPath;
-    if (environment.materializationStorage !== undefined) {
-      newEnvironment.metadata.materializationStorage = environment.materializationStorage;
-    }
     this.environments.set(environmentName, newEnvironment);
     environment?.packages?.forEach((_package) => {
       if (_package.name) {
@@ -233618,11 +233753,11 @@ class EnvironmentStore {
     const startedAt = Date.now();
     logger.info(`Detected zip file at "${absoluteEnvironmentPath}". Unzipping...`);
     const unzippedEnvironmentPath = absoluteEnvironmentPath.replace(".zip", "");
-    await fs7.promises.rm(unzippedEnvironmentPath, {
+    await fs8.promises.rm(unzippedEnvironmentPath, {
       recursive: true,
       force: true
     });
-    await fs7.promises.mkdir(unzippedEnvironmentPath, { recursive: true });
+    await fs8.promises.mkdir(unzippedEnvironmentPath, { recursive: true });
     let entryCount = 0;
     let totalUncompressedBytes = 0;
     await import_extract_zip.default(absoluteEnvironmentPath, {
@@ -233672,7 +233807,7 @@ class EnvironmentStore {
     await this.deleteEnvironmentFromDatabase(environmentName);
     if (environmentPath) {
       try {
-        await fs7.promises.rm(environmentPath, {
+        await fs8.promises.rm(environmentPath, {
           recursive: true,
           force: true
         });
@@ -233694,7 +233829,7 @@ class EnvironmentStore {
         return { frozenConfig: false, environments: [] };
       } else {
         try {
-          const entries = await fs7.promises.readdir(serverRootPath, {
+          const entries = await fs8.promises.readdir(serverRootPath, {
             withFileTypes: true
           });
           const environments = [];
@@ -233726,9 +233861,9 @@ class EnvironmentStore {
     assertSafePackageName(environment.name);
     const environmentName = environment.name;
     const absoluteEnvironmentPath = safeJoinUnderRoot(this.serverRootPath, PUBLISHER_DATA_DIR, environmentName);
-    await fs7.promises.mkdir(absoluteEnvironmentPath, { recursive: true });
+    await fs8.promises.mkdir(absoluteEnvironmentPath, { recursive: true });
     if (environment.readme) {
-      await fs7.promises.writeFile(safeJoinUnderRoot(absoluteEnvironmentPath, "README.md"), environment.readme);
+      await fs8.promises.writeFile(safeJoinUnderRoot(absoluteEnvironmentPath, "README.md"), environment.readme);
     }
     return absoluteEnvironmentPath;
   }
@@ -233747,7 +233882,7 @@ class EnvironmentStore {
   async loadEnvironmentIntoDisk(environmentName, packages) {
     assertSafePackageName(environmentName);
     const absoluteTargetPath = safeJoinUnderRoot(this.serverRootPath, PUBLISHER_DATA_DIR, environmentName);
-    await fs7.promises.mkdir(absoluteTargetPath, { recursive: true });
+    await fs8.promises.mkdir(absoluteTargetPath, { recursive: true });
     if (!packages || packages.length === 0) {
       throw new PackageNotFoundError(`No packages found for environment ${environmentName}`);
     }
@@ -233775,9 +233910,9 @@ class EnvironmentStore {
       });
     }
     for (const [groupedLocation, packagesForLocation] of locationGroups) {
-      const locationHash = crypto5.createHash("sha256").update(groupedLocation).digest("hex").substring(0, 16);
+      const locationHash = crypto4.createHash("sha256").update(groupedLocation).digest("hex").substring(0, 16);
       const tempDownloadPath = safeJoinUnderRoot(absoluteTargetPath, `.temp_${locationHash}`);
-      await fs7.promises.mkdir(tempDownloadPath, { recursive: true });
+      await fs8.promises.mkdir(tempDownloadPath, { recursive: true });
       logger.info(`Created temporary directory: ${tempDownloadPath}`);
       try {
         await this.downloadOrMountLocation(groupedLocation, tempDownloadPath, environmentName, "shared");
@@ -233805,7 +233940,7 @@ class EnvironmentStore {
               sourcePath = safeJoinUnderRoot(tempDownloadPath, groupedLocation);
             }
           }
-          const sourceExists = await fs7.promises.access(sourcePath).then(() => true).catch(() => false);
+          const sourceExists = await fs8.promises.access(sourcePath).then(() => true).catch(() => false);
           if (sourceExists) {
             const isInPlace = this.inPlaceEnvs.has(environmentName) && this.isLocalPath(_package.location);
             if (isInPlace) {
@@ -233813,16 +233948,16 @@ class EnvironmentStore {
               const absoluteSourcePath = path9.resolve(sourcePath);
               const linkType = process.platform === "win32" ? "junction" : "dir";
               try {
-                await fs7.promises.symlink(absoluteSourcePath, absolutePackagePath, linkType);
+                await fs8.promises.symlink(absoluteSourcePath, absolutePackagePath, linkType);
                 logger.info(`In-place mount (watch mode): linked package "${packageDir}" -> "${absoluteSourcePath}"`);
               } catch (linkError) {
                 const code = linkError?.code ?? String(linkError);
                 logger.warn(`In-place mount failed for package "${packageDir}" (${code}); falling back to a copy. Source-edit live reload is disabled for this package.`);
                 await clearMountTarget(absolutePackagePath);
-                await fs7.promises.mkdir(absolutePackagePath, {
+                await fs8.promises.mkdir(absolutePackagePath, {
                   recursive: true
                 });
-                await fs7.promises.cp(sourcePath, absolutePackagePath, {
+                await fs8.promises.cp(sourcePath, absolutePackagePath, {
                   recursive: true
                 });
               }
@@ -233831,20 +233966,20 @@ class EnvironmentStore {
                 logger.warn(`Watch mode: package "${packageDir}" has remote location "${_package.location}" — falling back to copy. Source-edit live reload won't work for this package; clone the source locally and use a local-dir location to enable it.`);
               }
               await clearMountTarget(absolutePackagePath);
-              await fs7.promises.mkdir(absolutePackagePath, {
+              await fs8.promises.mkdir(absolutePackagePath, {
                 recursive: true
               });
-              await fs7.promises.cp(sourcePath, absolutePackagePath, {
+              await fs8.promises.cp(sourcePath, absolutePackagePath, {
                 recursive: true
               });
               logger.info(`Extracted package "${packageDir}" from ${groupedLocation.startsWith("https://github.com/") && _package.location.includes("/tree/") ? "GitHub subdirectory" : "shared download"}`);
             }
           } else {
             await clearMountTarget(absolutePackagePath);
-            await fs7.promises.mkdir(absolutePackagePath, {
+            await fs8.promises.mkdir(absolutePackagePath, {
               recursive: true
             });
-            await fs7.promises.cp(tempDownloadPath, absolutePackagePath, {
+            await fs8.promises.cp(tempDownloadPath, absolutePackagePath, {
               recursive: true
             });
             logger.info(`Copied entire download as package "${packageDir}"`);
@@ -233856,7 +233991,7 @@ class EnvironmentStore {
         throw new PackageNotFoundError(`Failed to download or mount location: ${groupedLocation}`);
       }
       try {
-        await fs7.promises.rm(tempDownloadPath, {
+        await fs8.promises.rm(tempDownloadPath, {
           recursive: true,
           force: true
         });
@@ -233924,14 +234059,14 @@ class EnvironmentStore {
     if (environmentPath.endsWith(".zip")) {
       environmentPath = await this.unzipEnvironment(environmentPath);
     }
-    const environmentDirExists = (await fs7.promises.stat(environmentPath))?.isDirectory() ?? false;
+    const environmentDirExists = (await fs8.promises.stat(environmentPath))?.isDirectory() ?? false;
     if (environmentDirExists) {
-      await fs7.promises.rm(absoluteTargetPath, {
+      await fs8.promises.rm(absoluteTargetPath, {
         recursive: true,
         force: true
       });
-      await fs7.promises.mkdir(absoluteTargetPath, { recursive: true });
-      await fs7.promises.cp(environmentPath, absoluteTargetPath, {
+      await fs8.promises.mkdir(absoluteTargetPath, { recursive: true });
+      await fs8.promises.cp(environmentPath, absoluteTargetPath, {
         recursive: true
       });
     } else {
@@ -233950,11 +234085,11 @@ class EnvironmentStore {
       throw new EnvironmentNotFoundError(`Environment ${environmentName} not found in ${gcsPath}`);
     }
     if (!isCompressedFile) {
-      await fs7.promises.rm(absoluteDirPath, {
+      await fs8.promises.rm(absoluteDirPath, {
         recursive: true,
         force: true
       });
-      await fs7.promises.mkdir(absoluteDirPath, { recursive: true });
+      await fs8.promises.mkdir(absoluteDirPath, { recursive: true });
     } else {
       absoluteDirPath = `${absoluteDirPath}.zip`;
     }
@@ -233964,10 +234099,10 @@ class EnvironmentStore {
       if (file.name.endsWith("/")) {
         return;
       }
-      await fs7.promises.mkdir(path9.dirname(absoluteFilePath), {
+      await fs8.promises.mkdir(path9.dirname(absoluteFilePath), {
         recursive: true
       });
-      return fs7.promises.writeFile(absoluteFilePath, await file.download());
+      return fs8.promises.writeFile(absoluteFilePath, await file.download());
     }));
     if (isCompressedFile) {
       await this.unzipEnvironment(absoluteDirPath);
@@ -233981,10 +234116,10 @@ class EnvironmentStore {
     const prefix = prefixParts.join("/");
     if (isCompressedFile) {
       const zipFilePath = `${absoluteDirPath}.zip`;
-      await fs7.promises.mkdir(path9.dirname(zipFilePath), {
+      await fs8.promises.mkdir(path9.dirname(zipFilePath), {
         recursive: true
       });
-      const command = new import_client_s32.GetObjectCommand({
+      const command = new import_client_s33.GetObjectCommand({
         Bucket: bucketName,
         Key: prefix
       });
@@ -233992,7 +234127,7 @@ class EnvironmentStore {
       if (!item.Body) {
         throw new EnvironmentNotFoundError(`Environment ${environmentName} not found in ${s3Path}`);
       }
-      const file = fs7.createWriteStream(zipFilePath);
+      const file = fs8.createWriteStream(zipFilePath);
       item.Body.transformToWebStream().pipeTo(Writable.toWeb(file));
       await new Promise((resolve5, reject) => {
         file.on("error", reject);
@@ -234006,8 +234141,8 @@ class EnvironmentStore {
       Bucket: bucketName,
       Prefix: prefix
     });
-    await fs7.promises.rm(absoluteDirPath, { recursive: true, force: true });
-    await fs7.promises.mkdir(absoluteDirPath, { recursive: true });
+    await fs8.promises.rm(absoluteDirPath, { recursive: true, force: true });
+    await fs8.promises.mkdir(absoluteDirPath, { recursive: true });
     if (!objects.Contents || objects.Contents.length === 0) {
       throw new EnvironmentNotFoundError(`Environment ${environmentName} not found in ${s3Path}`);
     }
@@ -234021,10 +234156,10 @@ class EnvironmentStore {
         return;
       }
       const absoluteFilePath = safeJoinUnderRoot(absoluteDirPath, relativeFilePath);
-      await fs7.promises.mkdir(path9.dirname(absoluteFilePath), {
+      await fs8.promises.mkdir(path9.dirname(absoluteFilePath), {
         recursive: true
       });
-      const command = new import_client_s32.GetObjectCommand({
+      const command = new import_client_s33.GetObjectCommand({
         Bucket: bucketName,
         Key: key
       });
@@ -234032,7 +234167,7 @@ class EnvironmentStore {
       if (!item.Body) {
         return;
       }
-      const file = fs7.createWriteStream(absoluteFilePath);
+      const file = fs8.createWriteStream(absoluteFilePath);
       item.Body.transformToWebStream().pipeTo(Writable.toWeb(file));
       await new Promise((resolve5, reject) => {
         file.on("error", reject);
@@ -234064,11 +234199,11 @@ class EnvironmentStore {
     }
     const { owner, repoName, packagePath } = githubInfo;
     const cleanPackagePath = (packagePath?.replace("/tree/main", "") || "").replace(/^\/+/, "");
-    await fs7.promises.rm(absoluteDirPath, {
+    await fs8.promises.rm(absoluteDirPath, {
       recursive: true,
       force: true
     });
-    await fs7.promises.mkdir(absoluteDirPath, { recursive: true });
+    await fs8.promises.mkdir(absoluteDirPath, { recursive: true });
     const repoUrl = `https://github.com/${owner}/${repoName}`;
     await new Promise((resolve5, reject) => {
       esm_default2().clone(repoUrl, absoluteDirPath, {}, (err) => {
@@ -234085,24 +234220,24 @@ class EnvironmentStore {
       return;
     }
     const packageFullPath = safeJoinUnderRoot(absoluteDirPath, cleanPackagePath);
-    const packageExists = await fs7.promises.access(packageFullPath).then(() => true).catch(() => false);
+    const packageExists = await fs8.promises.access(packageFullPath).then(() => true).catch(() => false);
     if (!packageExists) {
       throw new Error(`Package path "${cleanPackagePath}" does not exist in the cloned repository.`);
     }
-    const dirContents = await fs7.promises.readdir(absoluteDirPath);
+    const dirContents = await fs8.promises.readdir(absoluteDirPath);
     for (const entry of dirContents) {
       if (entry !== cleanPackagePath.replace(/^\/+/, "").split("/")[0]) {
-        await fs7.promises.rm(safeJoinUnderRoot(absoluteDirPath, entry), {
+        await fs8.promises.rm(safeJoinUnderRoot(absoluteDirPath, entry), {
           recursive: true,
           force: true
         });
       }
     }
-    const packageContents = await fs7.promises.readdir(packageFullPath);
+    const packageContents = await fs8.promises.readdir(packageFullPath);
     for (const entry of packageContents) {
-      await fs7.promises.rename(safeJoinUnderRoot(packageFullPath, entry), safeJoinUnderRoot(absoluteDirPath, entry));
+      await fs8.promises.rename(safeJoinUnderRoot(packageFullPath, entry), safeJoinUnderRoot(absoluteDirPath, entry));
     }
-    await fs7.promises.rm(packageFullPath, { recursive: true, force: true });
+    await fs8.promises.rm(packageFullPath, { recursive: true, force: true });
   }
   extractErrorDataFromError(error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -234280,14 +234415,14 @@ var setFilterDeprecationHeaders = (res, options) => {
 
 // src/heap_check.ts
 init_logger();
-var import_api7 = __toESM(require_src(), 1);
+var import_api8 = __toESM(require_src(), 1);
 import * as v8 from "v8";
 var heapGaugesInstalled = false;
 function installHeapGauges() {
   if (heapGaugesInstalled)
     return;
   heapGaugesInstalled = true;
-  const meter2 = import_api7.metrics.getMeter("publisher");
+  const meter2 = import_api8.metrics.getMeter("publisher");
   meter2.createObservableGauge("publisher_heap_size_limit_bytes", {
     description: "V8 heap_size_limit (--max-old-space-size). Compare with PUBLISHER_MAX_MEMORY_BYTES.",
     unit: "By"
@@ -234322,7 +234457,7 @@ function checkHeapConfiguration(options = {}) {
 }
 
 // src/query_concurrency.ts
-var import_api8 = __toESM(require_src(), 1);
+var import_api9 = __toESM(require_src(), 1);
 init_errors();
 init_logger();
 var active = 0;
@@ -234332,7 +234467,7 @@ function ensureConcurrencyTelemetry() {
   if (queryConcurrencyRejectionsCounter && concurrencyTelemetryInitialized) {
     return queryConcurrencyRejectionsCounter;
   }
-  const meter2 = import_api8.metrics.getMeter("publisher");
+  const meter2 = import_api9.metrics.getMeter("publisher");
   queryConcurrencyRejectionsCounter = meter2.createCounter("publisher_query_concurrency_rejections_total", {
     description: "Queries rejected with 503 because the per-pod PUBLISHER_MAX_CONCURRENT_QUERIES cap was reached"
   });
@@ -234396,38 +234531,6 @@ function queryConcurrency() {
   return queryConcurrencyMiddleware;
 }
 
-// src/service/resolve_environment.ts
-init_errors();
-async function resolveEnvironmentId(repository, environmentName) {
-  const dbEnvironment = await repository.getEnvironmentByName(environmentName);
-  if (!dbEnvironment) {
-    throw new EnvironmentNotFoundError(`Environment '${environmentName}' not found`);
-  }
-  return dbEnvironment.id;
-}
-
-// src/controller/manifest.controller.ts
-class ManifestController {
-  environmentStore;
-  manifestService;
-  constructor(environmentStore, manifestService) {
-    this.environmentStore = environmentStore;
-    this.manifestService = manifestService;
-  }
-  async getManifest(environmentName, packageName) {
-    const repository = this.environmentStore.storageManager.getRepository();
-    const environmentId = await resolveEnvironmentId(repository, environmentName);
-    const environment = await this.environmentStore.getEnvironment(environmentName, false);
-    await environment.getPackage(packageName, false);
-    return this.manifestService.getManifest(environmentId, packageName);
-  }
-  async reloadManifest(environmentName, packageName) {
-    const repository = this.environmentStore.storageManager.getRepository();
-    const environmentId = await resolveEnvironmentId(repository, environmentName);
-    return this.manifestService.reloadManifest(environmentId, packageName, environmentName);
-  }
-}
-
 // src/controller/materialization.controller.ts
 init_errors();
 
@@ -234437,27 +234540,66 @@ class MaterializationController {
     this.materializationService = materializationService;
   }
   async createMaterialization(environmentName, packageName, body) {
-    const options = this.validateCreateBody(body);
-    return this.materializationService.createMaterialization(environmentName, packageName, options);
+    return this.materializationService.createMaterialization(environmentName, packageName, this.validateCreateBody(body));
   }
   validateCreateBody(body) {
     const result = {};
+    if (body.pauseBetweenPhases !== undefined) {
+      if (typeof body.pauseBetweenPhases !== "boolean") {
+        throw new BadRequestError("pauseBetweenPhases must be a boolean");
+      }
+      result.pauseBetweenPhases = body.pauseBetweenPhases;
+    }
     if (body.forceRefresh !== undefined) {
       if (typeof body.forceRefresh !== "boolean") {
         throw new BadRequestError("forceRefresh must be a boolean");
       }
       result.forceRefresh = body.forceRefresh;
     }
-    if (body.autoLoadManifest !== undefined) {
-      if (typeof body.autoLoadManifest !== "boolean") {
-        throw new BadRequestError("autoLoadManifest must be a boolean");
+    if (body.sourceNames !== undefined) {
+      if (!Array.isArray(body.sourceNames) || body.sourceNames.some((n) => typeof n !== "string")) {
+        throw new BadRequestError("sourceNames must be an array of strings");
       }
-      result.autoLoadManifest = body.autoLoadManifest;
+      result.sourceNames = body.sourceNames;
     }
     return result;
   }
-  async startMaterialization(environmentName, packageName, materializationId) {
-    return this.materializationService.startMaterialization(environmentName, packageName, materializationId);
+  async buildMaterialization(environmentName, packageName, materializationId, body) {
+    return this.materializationService.buildMaterialization(environmentName, packageName, materializationId, this.validateBuildBody(body));
+  }
+  validateBuildBody(body) {
+    const sources = body.sources;
+    if (!Array.isArray(sources) || sources.length === 0) {
+      throw new BadRequestError("build requires a non-empty 'sources' array of BuildInstruction");
+    }
+    return sources.map((raw) => this.validateInstruction(raw));
+  }
+  validateInstruction(raw) {
+    if (typeof raw !== "object" || raw === null) {
+      throw new BadRequestError("Each build instruction must be an object");
+    }
+    const instruction = raw;
+    const required = [
+      "buildId",
+      "materializedTableId",
+      "physicalTableName",
+      "realization"
+    ];
+    for (const field of required) {
+      if (typeof instruction[field] !== "string") {
+        throw new BadRequestError(`Build instruction is missing required string field '${field}'`);
+      }
+    }
+    if (instruction.realization !== "COPY" && instruction.realization !== "SNAPSHOT") {
+      throw new BadRequestError("Build instruction 'realization' must be COPY or SNAPSHOT");
+    }
+    return {
+      buildId: instruction.buildId,
+      sourceID: typeof instruction.sourceID === "string" ? instruction.sourceID : undefined,
+      materializedTableId: instruction.materializedTableId,
+      physicalTableName: instruction.physicalTableName,
+      realization: instruction.realization
+    };
   }
   async stopMaterialization(environmentName, packageName, materializationId) {
     return this.materializationService.stopMaterialization(environmentName, packageName, materializationId);
@@ -234468,22 +234610,8 @@ class MaterializationController {
   async getMaterialization(environmentName, packageName, materializationId) {
     return this.materializationService.getMaterialization(environmentName, packageName, materializationId);
   }
-  async deleteMaterialization(environmentName, packageName, materializationId) {
-    return this.materializationService.deleteMaterialization(environmentName, packageName, materializationId);
-  }
-  async teardownPackage(environmentName, packageName, body) {
-    const options = this.validateTeardownBody(body);
-    return this.materializationService.teardownPackage(environmentName, packageName, options);
-  }
-  validateTeardownBody(body) {
-    const options = {};
-    if (body.dryRun !== undefined) {
-      if (typeof body.dryRun !== "boolean") {
-        throw new BadRequestError("dryRun must be a boolean");
-      }
-      options.dryRun = body.dryRun;
-    }
-    return options;
+  async deleteMaterialization(environmentName, packageName, materializationId, options = {}) {
+    return this.materializationService.deleteMaterialization(environmentName, packageName, materializationId, options);
   }
 }
 
@@ -238481,8 +238609,7 @@ function registerLegacyRoutes(app, controllers) {
     databaseController,
     queryController,
     compileController,
-    materializationController,
-    manifestController
+    materializationController
   } = controllers;
   app.get(`${LEGACY_API_PREFIX}/projects`, async (_req, res) => {
     try {
@@ -238638,15 +238765,6 @@ function registerLegacyRoutes(app, controllers) {
       res.status(status).json(json);
     }
   });
-  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/sqlSource`, async (req, res) => {
-    try {
-      res.status(200).json(await connectionController.getConnectionSqlSource(req.params.projectName, req.params.connectionName, req.query.sqlStatement));
-    } catch (error) {
-      logger.error(error);
-      const { json, status } = internalErrorToHttpError(error);
-      res.status(status).json(json);
-    }
-  });
   app.post(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/sqlSource`, async (req, res) => {
     try {
       res.status(200).json(await connectionController.getConnectionSqlSource(req.params.projectName, req.params.connectionName, req.body.sqlStatement));
@@ -238656,15 +238774,6 @@ function registerLegacyRoutes(app, controllers) {
       res.status(status).json(json);
     }
   });
-  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/connections/:connectionName/sqlSource`, async (req, res) => {
-    try {
-      res.status(200).json(await connectionController.getConnectionSqlSource(req.params.projectName, req.params.connectionName, req.query.sqlStatement, req.params.packageName));
-    } catch (error) {
-      logger.error(error);
-      const { json, status } = internalErrorToHttpError(error);
-      res.status(status).json(json);
-    }
-  });
   app.post(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/connections/:connectionName/sqlSource`, async (req, res) => {
     try {
       res.status(200).json(await connectionController.getConnectionSqlSource(req.params.projectName, req.params.connectionName, req.body.sqlStatement, req.params.packageName));
@@ -238722,24 +238831,6 @@ function registerLegacyRoutes(app, controllers) {
       res.status(status).json(json);
     }
   });
-  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/temporaryTable`, queryConcurrency(), async (req, res) => {
-    try {
-      res.status(200).json(await connectionController.getConnectionTemporaryTable(req.params.projectName, req.params.connectionName, req.query.sqlStatement));
-    } catch (error) {
-      logger.error(error);
-      const { json, status } = internalErrorToHttpError(error);
-      res.status(status).json(json);
-    }
-  });
-  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/connections/:connectionName/temporaryTable`, queryConcurrency(), async (req, res) => {
-    try {
-      res.status(200).json(await connectionController.getConnectionTemporaryTable(req.params.projectName, req.params.connectionName, req.query.sqlStatement, req.params.packageName));
-    } catch (error) {
-      logger.error(error);
-      const { json, status } = internalErrorToHttpError(error);
-      res.status(status).json(json);
-    }
-  });
   app.post(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/sqlTemporaryTable`, queryConcurrency(), async (req, res) => {
     try {
       res.status(200).json(await connectionController.getConnectionTemporaryTable(req.params.projectName, req.params.connectionName, req.body.sqlStatement));
@@ -238773,8 +238864,7 @@ function registerLegacyRoutes(app, controllers) {
   });
   app.post(`${LEGACY_API_PREFIX}/projects/:projectName/packages`, async (req, res) => {
     try {
-      const autoLoadManifest = req.query.autoLoadManifest === "true";
-      const _package = await packageController.addPackage(req.params.projectName, req.body, { autoLoadManifest });
+      const _package = await packageController.addPackage(req.params.projectName, req.body);
       res.status(200).json(_package?.getPackageMetadata());
     } catch (error) {
       logger.error(error);
@@ -238964,26 +239054,17 @@ function registerLegacyRoutes(app, controllers) {
       res.status(status).json(json);
     }
   });
-  app.post(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/materializations/teardown`, async (req, res) => {
-    try {
-      const result = await materializationController.teardownPackage(req.params.projectName, req.params.packageName, req.body || {});
-      res.status(200).json(result);
-    } catch (error) {
-      const { json, status } = internalErrorToHttpError(error);
-      res.status(status).json(json);
-    }
-  });
   app.post(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/materializations/:materializationId`, async (req, res) => {
     try {
       const action = req.query.action;
-      if (action === "start") {
-        const build = await materializationController.startMaterialization(req.params.projectName, req.params.packageName, req.params.materializationId);
+      if (action === "build") {
+        const build = await materializationController.buildMaterialization(req.params.projectName, req.params.packageName, req.params.materializationId, req.body || {});
         res.status(202).json(remapMaterializationResponse(build));
       } else if (action === "stop") {
         const build = await materializationController.stopMaterialization(req.params.projectName, req.params.packageName, req.params.materializationId);
         res.status(200).json(remapMaterializationResponse(build));
       } else {
-        throw new BadRequestError(`Unsupported action '${String(action ?? "")}'. Expected 'start' or 'stop'.`);
+        throw new BadRequestError(`Unsupported action '${String(action ?? "")}'. Expected 'build' or 'stop'.`);
       }
     } catch (error) {
       const { json, status } = internalErrorToHttpError(error);
@@ -238992,209 +239073,21 @@ function registerLegacyRoutes(app, controllers) {
   });
   app.delete(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/materializations/:materializationId`, async (req, res) => {
     try {
-      await materializationController.deleteMaterialization(req.params.projectName, req.params.packageName, req.params.materializationId);
+      await materializationController.deleteMaterialization(req.params.projectName, req.params.packageName, req.params.materializationId, { dropTables: req.query.dropTables === "true" });
       res.status(204).send();
     } catch (error) {
       const { json, status } = internalErrorToHttpError(error);
       res.status(status).json(json);
     }
   });
-  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/manifest`, async (req, res) => {
-    try {
-      const manifest = await manifestController.getManifest(req.params.projectName, req.params.packageName);
-      res.status(200).json(manifest);
-    } catch (error) {
-      logger.error("Get manifest error", { error });
-      const { json, status } = internalErrorToHttpError(error);
-      res.status(status).json(json);
-    }
-  });
-  app.post(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/manifest`, async (req, res) => {
-    try {
-      const action = req.query.action;
-      if (action === "reload") {
-        const manifest = await manifestController.reloadManifest(req.params.projectName, req.params.packageName);
-        res.status(200).json(manifest);
-      } else {
-        throw new BadRequestError(`Unsupported action '${String(action ?? "")}'. Expected 'reload'.`);
-      }
-    } catch (error) {
-      logger.error("Manifest action error", { error });
-      const { json, status } = internalErrorToHttpError(error);
-      res.status(status).json(json);
-    }
-  });
   logger.info("Legacy /projects/* routes registered for backwards compatibility");
 }
 
-// src/service/manifest_service.ts
-init_logger();
-
-class ManifestService {
-  environmentStore;
-  constructor(environmentStore) {
-    this.environmentStore = environmentStore;
-  }
-  manifestStoreFor(environmentId) {
-    return this.environmentStore.storageManager.getManifestStore(environmentId);
-  }
-  async getManifest(environmentId, packageName) {
-    return this.manifestStoreFor(environmentId).getManifest(environmentId, packageName);
-  }
-  async writeEntry(environmentId, packageName, buildId, tableName, sourceName, connectionName) {
-    await this.manifestStoreFor(environmentId).writeEntry(environmentId, packageName, buildId, tableName, sourceName, connectionName);
-  }
-  async deleteEntry(environmentId, entryId) {
-    await this.manifestStoreFor(environmentId).deleteEntry(entryId);
-  }
-  async reloadManifest(environmentId, packageName, environmentName) {
-    const manifest = await this.getManifest(environmentId, packageName);
-    const environment = await this.environmentStore.getEnvironment(environmentName, false);
-    await environment.getPackage(packageName, false);
-    await environment.reloadAllModelsForPackage(packageName, manifest.entries);
-    logger.info("Reloaded manifest and recompiled models", {
-      environmentId,
-      packageName,
-      entryCount: Object.keys(manifest.entries).length
-    });
-    return manifest;
-  }
-  async listEntries(environmentId, packageName) {
-    return this.manifestStoreFor(environmentId).listEntries(environmentId, packageName);
-  }
-}
-
 // src/service/materialization_service.ts
 init_errors();
 init_logger();
 import { Manifest } from "@malloydata/malloy";
 
-// src/service/materialized_table_gc.ts
-init_logger();
-function liveTableKey(connectionName, tableName) {
-  return `${connectionName}::${tableName}`;
-}
-async function processOneEntry(entry, ctx, liveTables) {
-  const stagingTableName = `${entry.tableName}${stagingSuffix(entry.buildId)}`;
-  const targetIsLive = liveTables.has(liveTableKey(entry.connectionName, entry.tableName));
-  const connection = ctx.connections.get(entry.connectionName);
-  if (!connection) {
-    if (ctx.forceDeleteRowOnMissingConnection && !ctx.dryRun) {
-      try {
-        await ctx.manifestService.deleteEntry(ctx.environmentId, entry.id);
-        logger.warn("GC: deleted manifest row whose connection is gone; physical table (if any) is orphaned", {
-          manifestEntryId: entry.id,
-          tableName: entry.tableName,
-          connectionName: entry.connectionName
-        });
-        return {
-          dropped: {
-            buildId: entry.buildId,
-            tableName: entry.tableName,
-            connectionName: entry.connectionName,
-            stagingTableName,
-            targetDropSkipped: true
-          }
-        };
-      } catch (err) {
-        return {
-          error: {
-            buildId: entry.buildId,
-            tableName: entry.tableName,
-            connectionName: entry.connectionName,
-            error: err instanceof Error ? err.message : String(err)
-          }
-        };
-      }
-    }
-    return {
-      error: {
-        buildId: entry.buildId,
-        tableName: entry.tableName,
-        connectionName: entry.connectionName,
-        error: `Connection '${entry.connectionName}' is not available`
-      }
-    };
-  }
-  if (ctx.dryRun) {
-    return {
-      dropped: {
-        buildId: entry.buildId,
-        tableName: entry.tableName,
-        connectionName: entry.connectionName,
-        stagingTableName,
-        targetDropSkipped: targetIsLive || undefined
-      }
-    };
-  }
-  try {
-    await ctx.manifestService.deleteEntry(ctx.environmentId, entry.id);
-  } catch (err) {
-    const error = err instanceof Error ? err.message : String(err);
-    logger.warn("GC: failed to delete manifest row; skipping physical drop", {
-      manifestEntryId: entry.id,
-      tableName: entry.tableName,
-      error
-    });
-    return {
-      error: {
-        buildId: entry.buildId,
-        tableName: entry.tableName,
-        connectionName: entry.connectionName,
-        error
-      }
-    };
-  }
-  if (targetIsLive) {
-    logger.info("GC: skipping target DROP; another active manifest entry claims this (connection, tableName)", {
-      tableName: entry.tableName,
-      connectionName: entry.connectionName,
-      retiredBuildId: entry.buildId
-    });
-  } else {
-    try {
-      await connection.runSQL(`DROP TABLE IF EXISTS ${entry.tableName}`);
-    } catch (err) {
-      logger.warn("GC: deleted manifest row but failed to drop materialized table (orphaned)", {
-        tableName: entry.tableName,
-        connectionName: entry.connectionName,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  try {
-    await connection.runSQL(`DROP TABLE IF EXISTS ${stagingTableName}`);
-  } catch (err) {
-    logger.warn("GC: failed to drop staging table (best-effort)", {
-      stagingTableName,
-      connectionName: entry.connectionName,
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-  return {
-    dropped: {
-      buildId: entry.buildId,
-      tableName: entry.tableName,
-      connectionName: entry.connectionName,
-      stagingTableName,
-      targetDropSkipped: targetIsLive || undefined
-    }
-  };
-}
-async function dropManifestEntries(entries, ctx) {
-  const dropped = [];
-  const errors2 = [];
-  const liveTables = ctx.liveTables ?? new Set;
-  for (const entry of entries) {
-    const result = await processOneEntry(entry, ctx, liveTables);
-    if (result.dropped)
-      dropped.push(result.dropped);
-    if (result.error)
-      errors2.push(result.error);
-  }
-  return { dropped, errors: errors2 };
-}
-
 // src/service/quoting.ts
 function splitTablePath(tableName) {
   const lastDot = tableName.lastIndexOf(".");
@@ -239207,11 +239100,51 @@ function splitTablePath(tableName) {
   return { schemaPrefix: "", bareName: tableName };
 }
 
+// src/service/resolve_environment.ts
+init_errors();
+async function resolveEnvironmentId(repository, environmentName) {
+  const dbEnvironment = await repository.getEnvironmentByName(environmentName);
+  if (!dbEnvironment) {
+    throw new EnvironmentNotFoundError(`Environment '${environmentName}' not found`);
+  }
+  return dbEnvironment.id;
+}
+
 // src/service/materialization_service.ts
 var STAGING_BUILD_ID_LEN = 12;
 function stagingSuffix(buildId) {
   return `_${buildId.substring(0, STAGING_BUILD_ID_LEN)}`;
 }
+function deriveColumns(persistSource) {
+  try {
+    return persistSource._explore.intrinsicFields.filter((f) => f.isAtomicField()).map((f) => ({
+      name: f.name,
+      type: String(f.type)
+    }));
+  } catch (err) {
+    logger.warn("Failed to derive columns for persist source", {
+      sourceID: persistSource.sourceID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return [];
+  }
+}
+function flattenDependsOn(node) {
+  return node.dependsOn.map((d) => d.sourceID);
+}
+function computeBuildId(source, connectionDigests) {
+  return source.makeBuildId(connectionDigests[source.connectionName], source.getSQL());
+}
+function selfAssignTableName(persistSource) {
+  try {
+    return persistSource.annotations.parseAsTag("@").tag.text("name") || persistSource.name;
+  } catch {
+    return persistSource.name;
+  }
+}
+function outcomeFor(_err, signal) {
+  return signal?.aborted ? "cancelled" : "failed";
+}
 async function resolvePackageConnections(pkg, names) {
   const map2 = new Map;
   const seen = new Set;
@@ -239229,50 +239162,42 @@ async function resolvePackageConnections(pkg, names) {
   }
   return map2;
 }
-function manifestTableKey(connectionName, tableName) {
-  return `${connectionName}::${tableName}`;
-}
-async function tablePhysicallyExists(connection, tableName) {
-  try {
-    await connection.runSQL(`SELECT 1 FROM ${tableName} WHERE 1=0`);
-    return true;
-  } catch {
-    return false;
-  }
-}
 var VALID_TRANSITIONS = {
-  PENDING: ["RUNNING", "CANCELLED"],
-  RUNNING: ["SUCCESS", "FAILED", "CANCELLED"],
-  SUCCESS: [],
+  PENDING: ["BUILD_PLAN_READY", "FAILED", "CANCELLED"],
+  BUILD_PLAN_READY: ["MANIFEST_ROWS_READY", "FAILED", "CANCELLED"],
+  MANIFEST_ROWS_READY: ["MANIFEST_FILE_READY", "FAILED", "CANCELLED"],
+  MANIFEST_FILE_READY: [],
   FAILED: [],
   CANCELLED: []
 };
 
 class MaterializationService {
   environmentStore;
-  manifestService;
   runningAbortControllers = new Map;
-  constructor(environmentStore, manifestService) {
+  constructor(environmentStore) {
     this.environmentStore = environmentStore;
-    this.manifestService = manifestService;
   }
   get repository() {
     return this.environmentStore.storageManager.getRepository();
   }
   validateTransition(current, next) {
-    const allowed = VALID_TRANSITIONS[current];
-    if (!allowed.includes(next)) {
+    if (!VALID_TRANSITIONS[current].includes(next)) {
       throw new InvalidStateTransitionError(`Cannot transition from ${current} to ${next}`);
     }
   }
-  async transitionExecution(executionId, newStatus, extra) {
-    const execution = await this.repository.getMaterializationById(executionId);
-    if (!execution) {
-      throw new MaterializationNotFoundError(`Execution ${executionId} not found`);
+  async transition(id, next, extra) {
+    const current = await this.repository.getMaterializationById(id);
+    if (!current) {
+      throw new MaterializationNotFoundError(`Materialization ${id} not found`);
     }
-    this.validateTransition(execution.status, newStatus);
-    return this.repository.updateMaterialization(executionId, {
-      status: newStatus,
+    this.validateTransition(current.status, next);
+    logger.info("Materialization transition", {
+      materializationId: id,
+      from: current.status,
+      to: next
+    });
+    return this.repository.updateMaterialization(id, {
+      status: next,
       ...extra
     });
   }
@@ -239280,13 +239205,13 @@ class MaterializationService {
     const environmentId = await this.resolveEnvironmentId(environmentName);
     return this.repository.listMaterializations(environmentId, packageName, options);
   }
-  async getMaterialization(environmentName, packageName, buildId) {
+  async getMaterialization(environmentName, packageName, id) {
     const environmentId = await this.resolveEnvironmentId(environmentName);
-    const execution = await this.repository.getMaterializationById(buildId);
-    if (!execution || execution.environmentId !== environmentId || execution.packageName !== packageName) {
-      throw new MaterializationNotFoundError(`Materialization ${buildId} not found for package ${packageName}`);
+    const m = await this.repository.getMaterializationById(id);
+    if (!m || m.environmentId !== environmentId || m.packageName !== packageName) {
+      throw new MaterializationNotFoundError(`Materialization ${id} not found for package ${packageName}`);
     }
-    return execution;
+    return m;
   }
   async createMaterialization(environmentName, packageName, options = {}) {
     const environmentId = await this.resolveEnvironmentId(environmentName);
@@ -239296,12 +239221,16 @@ class MaterializationService {
     if (active2) {
       throw new MaterializationConflictError(`Package ${packageName} already has an active materialization (${active2.id})`);
     }
+    const pauseBetweenPhases = options.pauseBetweenPhases ?? false;
+    const forceRefresh = options.forceRefresh ?? false;
     const metadata = {
-      forceRefresh: options.forceRefresh ?? false,
-      autoLoadManifest: options.autoLoadManifest ?? false
+      forceRefresh,
+      sourceNames: options.sourceNames ?? null,
+      pauseBetweenPhases
     };
+    let created;
     try {
-      return await this.repository.createMaterialization(environmentId, packageName, "PENDING", metadata);
+      created = await this.repository.createMaterialization(environmentId, packageName, "PENDING", metadata);
     } catch (err) {
       if (err instanceof DuplicateActiveMaterializationError) {
         const winner = await this.repository.getActiveMaterialization(environmentId, packageName);
@@ -239309,136 +239238,209 @@ class MaterializationService {
       }
       throw err;
     }
+    this.runInBackground(created.id, (signal) => pauseBetweenPhases ? this.runRound1(created.id, environmentName, packageName, options.sourceNames, signal) : this.runAuto(created.id, environmentName, packageName, options.sourceNames, forceRefresh, signal));
+    return created;
   }
-  async startMaterialization(environmentName, packageName, buildId) {
-    const environmentId = await this.resolveEnvironmentId(environmentName);
-    const execution = await this.getMaterialization(environmentName, packageName, buildId);
-    if (execution.status !== "PENDING") {
-      throw new InvalidStateTransitionError(`Materialization ${buildId} is ${execution.status}, expected PENDING`);
-    }
-    const active2 = await this.repository.getActiveMaterialization(environmentId, packageName);
-    if (active2 && active2.id !== execution.id) {
-      throw new MaterializationConflictError(`Package ${packageName} already has an active materialization (${active2.id})`);
-    }
-    const running = await this.transitionExecution(execution.id, "RUNNING", {
-      startedAt: new Date
+  async runRound1(id, environmentName, packageName, sourceNames, signal) {
+    logger.info("Materialization Round 1: compile + plan", {
+      materializationId: id,
+      packageName
     });
-    const metadata = execution.metadata ?? {};
-    this.runMaterialization(execution.id, environmentName, environmentId, packageName, metadata).catch((err) => {
-      logger.error("Unhandled error in background build", {
-        executionId: execution.id,
-        error: err instanceof Error ? err.message : String(err)
+    const startedAt = Date.now();
+    try {
+      const environment = await this.environmentStore.getEnvironment(environmentName, false);
+      const pkg = await environment.getPackage(packageName, false);
+      const { graphs, sources, connectionDigests } = await environment.withPackageLock(packageName, () => this.compilePackageBuildPlan(pkg, signal));
+      const buildPlan = this.deriveBuildPlan(graphs, sources, connectionDigests, sourceNames);
+      await this.transition(id, "BUILD_PLAN_READY", { buildPlan });
+      this.recordRound("round1", "success", startedAt);
+      logger.info("Materialization Round 1 complete", {
+        materializationId: id,
+        packageName,
+        sourceCount: Object.keys(buildPlan.sources).length,
+        durationMs: Date.now() - startedAt
       });
-    });
-    return running;
+    } catch (err) {
+      this.recordRound("round1", outcomeFor(err, signal), startedAt);
+      throw err;
+    }
   }
-  async runMaterialization(executionId, environmentName, environmentId, packageName, metadata) {
-    const abortController = new AbortController;
-    this.runningAbortControllers.set(executionId, abortController);
+  async runAuto(id, environmentName, packageName, sourceNames, forceRefresh, signal) {
+    logger.info("Materialization auto-run: compile + build + load", {
+      materializationId: id,
+      packageName
+    });
+    const startedAt = Date.now();
     try {
-      const buildMetadata = await this.executeBuild(environmentName, environmentId, packageName, !!metadata.forceRefresh, abortController.signal);
-      if (metadata.autoLoadManifest) {
-        const updatedManifest = await this.manifestService.getManifest(environmentId, packageName);
-        const environment = await this.environmentStore.getEnvironment(environmentName, false);
-        await environment.getPackage(packageName, false);
-        await environment.reloadAllModelsForPackage(packageName, updatedManifest.entries);
-      }
-      await this.transitionExecution(executionId, "SUCCESS", {
-        completedAt: new Date,
-        metadata: { ...metadata, ...buildMetadata }
+      const environmentId = await this.resolveEnvironmentId(environmentName);
+      const environment = await this.environmentStore.getEnvironment(environmentName, false);
+      const pkg = await environment.getPackage(packageName, false);
+      const compiled = await environment.withPackageLock(packageName, () => this.compilePackageBuildPlan(pkg, signal));
+      const buildPlan = this.deriveBuildPlan(compiled.graphs, compiled.sources, compiled.connectionDigests, sourceNames);
+      await this.transition(id, "BUILD_PLAN_READY", { buildPlan });
+      const priorEntries = forceRefresh ? {} : await this.getMostRecentManifestEntries(environmentId, packageName, id);
+      const { instructions, carried } = this.deriveSelfInstructions(compiled, sourceNames, priorEntries);
+      const entries = await this.executeInstructedBuild(compiled, instructions, carried, signal);
+      const durationMs = Date.now() - startedAt;
+      await this.commitManifest(id, entries, {
+        forceRefresh,
+        sourceNames: sourceNames ?? null,
+        pauseBetweenPhases: false,
+        sourcesBuilt: instructions.length,
+        sourcesReused: Object.keys(carried).length,
+        durationMs
+      });
+      await this.autoLoadManifest(environment, packageName, entries);
+      this.recordRound("auto", "success", startedAt);
+      logger.info("Materialization auto-run complete", {
+        materializationId: id,
+        packageName,
+        sourcesBuilt: instructions.length,
+        sourcesReused: Object.keys(carried).length,
+        durationMs
       });
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      try {
-        if (abortController.signal.aborted) {
-          await this.transitionExecution(executionId, "CANCELLED", {
-            completedAt: new Date,
-            error: "Build cancelled"
-          });
-        } else {
-          await this.transitionExecution(executionId, "FAILED", {
-            completedAt: new Date,
-            error: errorMessage
+      this.recordRound("auto", outcomeFor(err, signal), startedAt);
+      throw err;
+    }
+  }
+  deriveSelfInstructions(compiled, sourceNames, priorEntries) {
+    const include = sourceNames ? new Set(sourceNames) : null;
+    const instructions = [];
+    const carried = {};
+    const seen = new Set;
+    for (const graph of compiled.graphs) {
+      for (const level of graph.nodes) {
+        for (const node of level) {
+          const persistSource = compiled.sources[node.sourceID];
+          if (!persistSource)
+            continue;
+          if (include && !include.has(persistSource.name))
+            continue;
+          const buildId = computeBuildId(persistSource, compiled.connectionDigests);
+          if (seen.has(buildId))
+            continue;
+          seen.add(buildId);
+          const prior = priorEntries[buildId];
+          if (prior && prior.physicalTableName) {
+            carried[buildId] = prior;
+            continue;
+          }
+          instructions.push({
+            buildId,
+            materializedTableId: `local-${buildId.substring(0, STAGING_BUILD_ID_LEN)}`,
+            physicalTableName: selfAssignTableName(persistSource),
+            realization: "COPY"
           });
         }
-      } catch (transitionErr) {
-        logger.error("Failed to transition execution after build error", {
-          executionId,
-          originalError: errorMessage,
-          transitionError: transitionErr instanceof Error ? transitionErr.message : String(transitionErr)
-        });
       }
-    } finally {
-      this.runningAbortControllers.delete(executionId);
     }
+    return { instructions, carried };
+  }
+  async getMostRecentManifestEntries(environmentId, packageName, excludeId) {
+    const list = await this.repository.listMaterializations(environmentId, packageName);
+    for (const m of list) {
+      if (m.id === excludeId)
+        continue;
+      if (m.status === "MANIFEST_FILE_READY" && m.manifest?.entries) {
+        return m.manifest.entries;
+      }
+    }
+    return {};
   }
-  async stopMaterialization(environmentName, packageName, buildId) {
-    const execution = await this.getMaterialization(environmentName, packageName, buildId);
-    if (execution.status !== "RUNNING" && execution.status !== "PENDING") {
-      throw new InvalidStateTransitionError(`Materialization ${buildId} is ${execution.status}, cannot stop`);
+  async autoLoadManifest(environment, packageName, entries) {
+    const manifestEntries = {};
+    for (const [buildId, entry] of Object.entries(entries)) {
+      if (entry.physicalTableName) {
+        manifestEntries[buildId] = { tableName: entry.physicalTableName };
+      }
     }
-    if (execution.status === "PENDING") {
-      return this.transitionExecution(execution.id, "CANCELLED", {
-        completedAt: new Date,
-        error: "Build cancelled before starting"
+    try {
+      await environment.reloadAllModelsForPackage(packageName, manifestEntries);
+      logger.info("Auto-run: loaded manifest into package models", {
+        packageName,
+        entryCount: Object.keys(manifestEntries).length
       });
-    }
-    const abortController = this.runningAbortControllers.get(execution.id);
-    if (abortController) {
-      abortController.abort();
-      return execution;
-    } else {
-      return this.transitionExecution(execution.id, "CANCELLED", {
-        completedAt: new Date,
-        error: "Force cancelled: execution was orphaned"
+    } catch (err) {
+      logger.warn("Auto-run: failed to load manifest into package models", {
+        packageName,
+        error: err instanceof Error ? err.message : String(err)
       });
     }
   }
-  async deleteMaterialization(environmentName, packageName, materializationId) {
-    const execution = await this.getMaterialization(environmentName, packageName, materializationId);
-    if (execution.status === "PENDING" || execution.status === "RUNNING") {
-      throw new InvalidStateTransitionError(`Cannot delete materialization ${materializationId} while it is ${execution.status}`);
+  async buildMaterialization(environmentName, packageName, id, instructions) {
+    const m = await this.getMaterialization(environmentName, packageName, id);
+    if (!m.pauseBetweenPhases) {
+      throw new InvalidStateTransitionError(`Materialization ${id} is an auto-run materialization; action=build does not apply (set pauseBetweenPhases=true for the two-round flow)`);
+    }
+    if (m.status !== "BUILD_PLAN_READY") {
+      throw new InvalidStateTransitionError(`Materialization ${id} is ${m.status}, expected BUILD_PLAN_READY`);
     }
-    await this.repository.deleteMaterialization(execution.id);
+    const plan = m.buildPlan;
+    if (!plan) {
+      throw new InvalidStateTransitionError(`Materialization ${id} has no build plan`);
+    }
+    this.validateInstructions(plan, instructions);
+    this.runInBackground(id, (signal) => this.runRound2(id, environmentName, packageName, instructions, signal));
+    return m;
   }
-  async teardownPackage(environmentName, packageName, options = {}) {
-    const environmentId = await this.resolveEnvironmentId(environmentName);
-    const active2 = await this.repository.getActiveMaterialization(environmentId, packageName);
-    if (active2) {
-      throw new MaterializationConflictError(`Package ${packageName} has an active materialization (${active2.id}); cannot tear down`);
+  validateInstructions(plan, instructions) {
+    const plannedBuildIds = new Set;
+    for (const source of Object.values(plan.sources)) {
+      plannedBuildIds.add(source.buildId);
+    }
+    for (const instruction of instructions) {
+      if (!plannedBuildIds.has(instruction.buildId)) {
+        throw new BadRequestError(`Instruction references unknown buildId '${instruction.buildId}'`);
+      }
+      if (instruction.realization === "SNAPSHOT") {
+        throw new BadRequestError("realization=SNAPSHOT is not supported in v0 (COPY only)");
+      }
     }
-    const environment = await this.environmentStore.getEnvironment(environmentName, false);
-    const pkg = await environment.getPackage(packageName, false);
-    const entries = await this.manifestService.listEntries(environmentId, packageName);
-    const connections = await resolvePackageConnections(pkg, entries.map((e) => e.connectionName));
-    return dropManifestEntries(entries, {
-      connections,
-      manifestService: this.manifestService,
-      environmentId,
-      dryRun: options.dryRun,
-      forceDeleteRowOnMissingConnection: true
-    });
   }
-  async executeBuild(environmentName, environmentId, packageName, forceRefresh, signal) {
-    logger.info("Starting materialization build", {
-      environmentName,
-      packageName
+  async runRound2(id, environmentName, packageName, instructions, signal) {
+    logger.info("Materialization Round 2: build", {
+      materializationId: id,
+      packageName,
+      sourceCount: instructions.length
     });
-    const environment = await this.environmentStore.getEnvironment(environmentName, false);
-    const pkg = await environment.getPackage(packageName, false);
+    const startedAt = Date.now();
+    try {
+      const environment = await this.environmentStore.getEnvironment(environmentName, false);
+      const pkg = await environment.getPackage(packageName, false);
+      const compiled = await environment.withPackageLock(packageName, () => this.compilePackageBuildPlan(pkg, signal));
+      const entries = await this.executeInstructedBuild(compiled, instructions, {}, signal);
+      const durationMs = Date.now() - startedAt;
+      await this.commitManifest(id, entries, {
+        sourcesBuilt: Object.keys(entries).length,
+        durationMs
+      });
+      this.recordRound("round2", "success", startedAt);
+      logger.info("Materialization Round 2 complete", {
+        materializationId: id,
+        packageName,
+        sourcesBuilt: Object.keys(entries).length,
+        durationMs
+      });
+    } catch (err) {
+      this.recordRound("round2", outcomeFor(err, signal), startedAt);
+      throw err;
+    }
+  }
+  async executeInstructedBuild(compiled, instructions, seedEntries, signal) {
+    const { graphs, sources, connectionDigests, connections } = compiled;
+    const byBuildId = new Map;
+    for (const instruction of instructions) {
+      byBuildId.set(instruction.buildId, instruction);
+    }
     const manifest = new Manifest;
-    const existingManifest = await this.manifestService.getManifest(environmentId, packageName);
-    manifest.loadText(JSON.stringify(existingManifest));
-    const existingEntries = await this.manifestService.listEntries(environmentId, packageName);
-    const knownMaterializedTables = new Set(existingEntries.map((e) => manifestTableKey(e.connectionName, e.tableName)));
-    const { graphs, sources, connectionDigests, connections } = await environment.withPackageLock(packageName, () => this.compilePackageBuildPlan(pkg, signal));
-    if (graphs.length === 0) {
-      logger.info("No persist sources to build");
-      return { sourcesBuilt: 0, sourcesSkipped: 0 };
-    }
-    let sourcesBuilt = 0;
-    let sourcesSkipped = 0;
-    const sourceResults = [];
+    const entries = {};
+    for (const [buildId, entry] of Object.entries(seedEntries)) {
+      if (entry.physicalTableName) {
+        manifest.update(buildId, { tableName: entry.physicalTableName });
+      }
+      entries[buildId] = entry;
+    }
     for (const graph of graphs) {
       const connection = connections.get(graph.connectionName);
       if (!connection) {
@@ -239449,83 +239451,176 @@ class MaterializationService {
           if (signal.aborted)
             throw new Error("Build cancelled");
           const persistSource = sources[node.sourceID];
-          if (!persistSource) {
-            logger.warn(`Source ${node.sourceID} not found in build plan, skipping`);
+          if (!persistSource)
             continue;
-          }
-          const result = await this.buildOneSource(persistSource, manifest, connection, connectionDigests, forceRefresh, environmentId, packageName, knownMaterializedTables);
-          sourceResults.push(result);
-          if (result.status === "built")
-            sourcesBuilt++;
-          else
-            sourcesSkipped++;
+          const buildId = computeBuildId(persistSource, connectionDigests);
+          const instruction = byBuildId.get(buildId);
+          if (!instruction)
+            continue;
+          const entry = await this.buildOneSource(persistSource, instruction, connection, connectionDigests, manifest);
+          entries[buildId] = entry;
         }
       }
     }
-    const gcResult = await this.runPostBuildGc(manifest, environmentId, packageName, connections);
-    logger.info("Materialization build complete", {
-      sourcesBuilt,
-      sourcesSkipped,
-      gcDropped: gcResult.dropped.length,
-      gcErrors: gcResult.errors.length
+    return entries;
+  }
+  async buildOneSource(persistSource, instruction, connection, connectionDigests, manifest) {
+    const buildId = instruction.buildId;
+    const physicalTableName = instruction.physicalTableName;
+    const buildSQL = persistSource.getSQL({
+      buildManifest: manifest.buildManifest,
+      connectionDigests
+    });
+    const { bareName } = splitTablePath(physicalTableName);
+    const stagingTableName = `${physicalTableName}${stagingSuffix(buildId)}`;
+    const startTime = performance.now();
+    await connection.runSQL(`DROP TABLE IF EXISTS ${stagingTableName}`);
+    try {
+      await connection.runSQL(`CREATE TABLE ${stagingTableName} AS (${buildSQL})`);
+      await connection.runSQL(`DROP TABLE IF EXISTS ${physicalTableName}`);
+      await connection.runSQL(`ALTER TABLE ${stagingTableName} RENAME TO ${bareName}`);
+    } catch (err) {
+      try {
+        await connection.runSQL(`DROP TABLE IF EXISTS ${stagingTableName}`);
+      } catch (cleanupErr) {
+        logger.warn("Round 2: failed to clean up staging table after a failed build; physical leak", {
+          stagingTableName,
+          connectionName: persistSource.connectionName,
+          cleanupError: cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)
+        });
+      }
+      throw err;
+    }
+    manifest.update(buildId, { tableName: physicalTableName });
+    const durationMs = Math.round(performance.now() - startTime);
+    recordSourceBuildDuration(durationMs);
+    logger.info(`Built materialized source ${persistSource.name}`, {
+      physicalTableName,
+      durationMs
     });
     return {
-      sourcesBuilt,
-      sourcesSkipped,
-      sources: sourceResults,
-      gcDropped: gcResult.dropped,
-      gcErrors: gcResult.errors
+      buildId,
+      sourceName: persistSource.name,
+      materializedTableId: instruction.materializedTableId,
+      physicalTableName,
+      connectionName: persistSource.connectionName,
+      realization: instruction.realization,
+      rowCount: null
+    };
+  }
+  async stopMaterialization(environmentName, packageName, id) {
+    const m = await this.getMaterialization(environmentName, packageName, id);
+    const cancellable = [
+      "PENDING",
+      "BUILD_PLAN_READY",
+      "MANIFEST_ROWS_READY"
+    ];
+    if (!cancellable.includes(m.status)) {
+      throw new InvalidStateTransitionError(`Materialization ${id} is ${m.status}, cannot stop`);
+    }
+    const abortController = this.runningAbortControllers.get(id);
+    if (abortController) {
+      abortController.abort();
+      return m;
+    }
+    return this.transition(id, "CANCELLED", {
+      completedAt: new Date,
+      error: "Cancelled"
+    });
+  }
+  async deleteMaterialization(environmentName, packageName, id, options = {}) {
+    const m = await this.getMaterialization(environmentName, packageName, id);
+    const terminal = [
+      "MANIFEST_FILE_READY",
+      "FAILED",
+      "CANCELLED"
+    ];
+    if (!terminal.includes(m.status)) {
+      throw new InvalidStateTransitionError(`Cannot delete materialization ${id} while it is ${m.status}`);
+    }
+    if (options.dropTables) {
+      await this.dropMaterializedTables(environmentName, packageName, m);
+    }
+    await this.repository.deleteMaterialization(id);
+  }
+  async dropMaterializedTables(environmentName, packageName, m) {
+    const entries = m.manifest?.entries;
+    if (!entries || Object.keys(entries).length === 0) {
+      return;
+    }
+    const environment = await this.environmentStore.getEnvironment(environmentName, false);
+    const pkg = await environment.getPackage(packageName, false);
+    const connectionCache = new Map;
+    for (const entry of Object.values(entries)) {
+      const connectionName = entry.connectionName;
+      const physicalTableName = entry.physicalTableName;
+      if (!connectionName || !physicalTableName) {
+        logger.warn("Skipping manifest entry with no connection/table", {
+          materializationId: m.id,
+          buildId: entry.buildId
+        });
+        continue;
+      }
+      try {
+        let connection = connectionCache.get(connectionName);
+        if (!connection) {
+          connection = await pkg.getMalloyConnection(connectionName);
+          connectionCache.set(connectionName, connection);
+        }
+        await connection.runSQL(`DROP TABLE IF EXISTS ${physicalTableName}`);
+        await connection.runSQL(`DROP TABLE IF EXISTS ${physicalTableName}${stagingSuffix(entry.buildId)}`);
+        recordDropTables("success");
+        logger.info("Dropped materialized table on delete", {
+          materializationId: m.id,
+          physicalTableName,
+          connectionName
+        });
+      } catch (err) {
+        recordDropTables("failure");
+        logger.warn("Failed to drop materialized table on delete", {
+          materializationId: m.id,
+          physicalTableName,
+          connectionName,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  async commitManifest(id, entries, metadata) {
+    await this.transition(id, "MANIFEST_ROWS_READY");
+    const manifest = {
+      builtAt: new Date().toISOString(),
+      entries,
+      strict: false
     };
+    await this.transition(id, "MANIFEST_FILE_READY", {
+      completedAt: new Date,
+      manifest,
+      metadata
+    });
   }
   async compilePackageBuildPlan(pkg, signal) {
-    const modelPaths = pkg.getModelPaths();
     const allGraphs = [];
     const allSources = {};
-    for (const modelPath of modelPaths) {
-      if (signal.aborted)
+    for (const modelPath of pkg.getModelPaths()) {
+      if (signal?.aborted)
         throw new Error("Build cancelled");
       const { runtime, modelURL, importBaseURL } = await Model.getModelRuntime(pkg.getPackagePath(), modelPath, pkg.getMalloyConfig());
-      const modelMaterializer = runtime.loadModel(modelURL, {
-        importBaseURL
-      });
-      const malloyModel = await modelMaterializer.getModel();
-      const modelTag = malloyModel.annotations.parseAsTag("!").tag;
-      if (!modelTag.has("experimental", "persistence")) {
-        logger.debug("Model has no ##! experimental.persistence tag, skipping", { modelPath });
-        continue;
-      }
+      const malloyModel = await runtime.loadModel(modelURL, { importBaseURL }).getModel();
       const buildPlan = malloyModel.getBuildPlan();
       for (const msg of buildPlan.tagParseLog) {
         logger.warn("Persist annotation issue", {
           modelPath,
           message: msg.message,
-          severity: msg.severity,
-          code: msg.code
+          severity: msg.severity
         });
       }
-      if (buildPlan.graphs.length > 0) {
-        allGraphs.push(...buildPlan.graphs);
-        for (const [sourceID, source] of Object.entries(buildPlan.sources)) {
-          if (allSources[sourceID]) {
-            logger.warn(`Duplicate sourceID "${sourceID}" from model ${modelPath}, overwriting previous definition`);
-          }
-          allSources[sourceID] = source;
-        }
-      }
-    }
-    logger.info("Build plan", {
-      sourceCount: Object.keys(allSources).length,
-      graphCount: allGraphs.length
-    });
-    const tableOwners = new Map;
-    for (const [sourceID, source] of Object.entries(allSources)) {
-      const tableName = source.annotations.parseAsTag("@").tag.text("name") || source.name;
-      const key = `${source.connectionName}::${tableName}`;
-      const existing = tableOwners.get(key);
-      if (existing) {
-        throw new BadRequestError(`Persist target collision: sources '${existing}' and '${sourceID}' both resolve to table '${tableName}' on connection '${source.connectionName}'. Disambiguate with '#@ persist name=...'.`);
+      if (buildPlan.graphs.length === 0)
+        continue;
+      allGraphs.push(...buildPlan.graphs);
+      for (const [sourceID, source] of Object.entries(buildPlan.sources)) {
+        allSources[sourceID] = source;
       }
-      tableOwners.set(key, sourceID);
     }
     const connections = await resolvePackageConnections(pkg, allGraphs.map((g) => g.connectionName));
     const connectionDigests = {};
@@ -239542,92 +239637,56 @@ class MaterializationService {
       connections
     };
   }
-  async buildOneSource(persistSource, manifest, connection, connectionDigests, forceRefresh, environmentId, packageName, knownMaterializedTables) {
-    const buildIdSQL = persistSource.getSQL();
-    const digest = connectionDigests[persistSource.connectionName];
-    const buildId = persistSource.makeBuildId(digest, buildIdSQL);
-    if (manifest.buildManifest.entries[buildId] && !forceRefresh) {
-      manifest.touch(buildId);
-      logger.info(`Source ${persistSource.name} up to date, skipping`, {
-        buildId
-      });
-      return { name: persistSource.name, status: "skipped", buildId };
-    }
-    const buildSQL = persistSource.getSQL({
-      buildManifest: manifest.buildManifest,
-      connectionDigests
-    });
-    const connectionName = persistSource.connectionName;
-    const tableName = persistSource.annotations.parseAsTag("@").tag.text("name") || persistSource.name;
-    const { bareName } = splitTablePath(tableName);
-    const stagingTableName = `${tableName}${stagingSuffix(buildId)}`;
-    const tableKey = manifestTableKey(connectionName, tableName);
-    if (!knownMaterializedTables.has(tableKey)) {
-      if (await tablePhysicallyExists(connection, tableName)) {
-        throw new BadRequestError(`Refusing to materialize source '${persistSource.name}': ` + `target table '${tableName}' already exists on connection ` + `'${connectionName}' but was not created by a previous ` + `materialization build. Use '#@ persist name=...' to ` + `choose a different table name, or drop the existing ` + `table manually if it is no longer needed.`);
-      }
+  deriveBuildPlan(graphs, sources, connectionDigests, sourceNames) {
+    const include = sourceNames ? new Set(sourceNames) : null;
+    const wireGraphs = graphs.map((graph) => ({
+      connectionName: graph.connectionName,
+      nodes: graph.nodes.map((level) => level.map((node) => ({
+        sourceID: node.sourceID,
+        dependsOn: flattenDependsOn(node)
+      })))
+    }));
+    const wireSources = {};
+    for (const [sourceID, source] of Object.entries(sources)) {
+      if (include && !include.has(source.name))
+        continue;
+      wireSources[sourceID] = {
+        name: source.name,
+        sourceID: source.sourceID,
+        connectionName: source.connectionName,
+        dialect: source.dialectName,
+        buildId: computeBuildId(source, connectionDigests),
+        sql: source.getSQL(),
+        columns: deriveColumns(source)
+      };
     }
-    logger.info(`Building source ${persistSource.name}`, {
-      tableName,
-      connectionName
-    });
-    const startTime = performance.now();
-    await connection.runSQL(`DROP TABLE IF EXISTS ${stagingTableName}`);
-    try {
-      await connection.runSQL(`CREATE TABLE ${stagingTableName} AS (${buildSQL})`);
-      await connection.runSQL(`DROP TABLE IF EXISTS ${tableName}`);
-      await connection.runSQL(`ALTER TABLE ${stagingTableName} RENAME TO ${bareName}`);
-    } catch (err) {
+    return { graphs: wireGraphs, sources: wireSources };
+  }
+  recordRound(round, outcome, startedAtMs) {
+    recordMaterializationRound(round, outcome, Date.now() - startedAtMs);
+  }
+  runInBackground(id, run) {
+    const abortController = new AbortController;
+    this.runningAbortControllers.set(id, abortController);
+    run(abortController.signal).catch(async (err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      const next = abortController.signal.aborted ? "CANCELLED" : "FAILED";
       try {
-        await connection.runSQL(`DROP TABLE IF EXISTS ${stagingTableName}`);
-      } catch (cleanupErr) {
-        logger.warn("Build: failed to clean up staging table after a failed rebuild; physical leak", {
-          stagingTableName,
-          connectionName,
-          cleanupError: cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)
+        await this.repository.updateMaterialization(id, {
+          status: next,
+          completedAt: new Date,
+          error: abortController.signal.aborted ? "Cancelled" : message
+        });
+      } catch (transitionErr) {
+        logger.error("Failed to record materialization failure", {
+          materializationId: id,
+          originalError: message,
+          transitionError: transitionErr instanceof Error ? transitionErr.message : String(transitionErr)
         });
       }
-      throw err;
-    }
-    const duration = performance.now() - startTime;
-    knownMaterializedTables.add(tableKey);
-    manifest.update(buildId, { tableName });
-    await this.manifestService.writeEntry(environmentId, packageName, buildId, tableName, persistSource.name, connectionName);
-    logger.info(`Built source ${persistSource.name}`, {
-      tableName,
-      durationMs: Math.round(duration)
-    });
-    return {
-      name: persistSource.name,
-      status: "built",
-      buildId,
-      tableName,
-      durationMs: Math.round(duration)
-    };
-  }
-  async runPostBuildGc(manifest, environmentId, packageName, connections) {
-    const activeManifest = manifest.activeEntries;
-    const allDbEntries = await this.manifestService.listEntries(environmentId, packageName);
-    const liveTables = new Set;
-    for (const entry of allDbEntries) {
-      if (activeManifest.entries[entry.buildId]) {
-        liveTables.add(liveTableKey(entry.connectionName, entry.tableName));
-      }
-    }
-    const staleEntries = allDbEntries.filter((entry) => !activeManifest.entries[entry.buildId]);
-    const gcResult = await dropManifestEntries(staleEntries, {
-      connections,
-      manifestService: this.manifestService,
-      environmentId,
-      liveTables
+    }).finally(() => {
+      this.runningAbortControllers.delete(id);
     });
-    if (gcResult.errors.length > 0) {
-      logger.warn("Materialization GC surfaced errors", {
-        errorCount: gcResult.errors.length,
-        droppedCount: gcResult.dropped.length
-      });
-    }
-    return gcResult;
   }
   resolveEnvironmentId(environmentName) {
     return resolveEnvironmentId(this.repository, environmentName);
@@ -239636,7 +239695,7 @@ class MaterializationService {
 
 // src/service/package_memory_governor.ts
 init_logger();
-var import_api9 = __toESM(require_src(), 1);
+var import_api10 = __toESM(require_src(), 1);
 var DEFAULT_RSS_SAMPLER = () => process.memoryUsage().rss;
 
 class PackageMemoryGovernor {
@@ -239654,7 +239713,7 @@ class PackageMemoryGovernor {
     this.rssSampler = rssSampler ?? DEFAULT_RSS_SAMPLER;
     this.highWaterBytes = Math.floor(config.maxMemoryBytes * config.highWaterFraction);
     this.lowWaterBytes = Math.floor(config.maxMemoryBytes * config.lowWaterFraction);
-    const meter2 = import_api9.metrics.getMeter("publisher");
+    const meter2 = import_api10.metrics.getMeter("publisher");
     meter2.createObservableGauge("publisher_process_rss_bytes", {
       description: "Current resident set size of the publisher process in bytes",
       unit: "By"
@@ -239806,7 +239865,7 @@ var MCP_PORT = Number(process.env.MCP_PORT || 4040);
 var MCP_ENDPOINT = "/mcp";
 var SHUTDOWN_DRAIN_DURATION_SECONDS = Number(process.env.SHUTDOWN_DRAIN_DURATION_SECONDS || 0);
 var SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS = Number(process.env.SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS || 0);
-var __filename_esm = fileURLToPath4(import.meta.url);
+var __filename_esm = fileURLToPath5(import.meta.url);
 var ROOT = path11.join(path11.dirname(__filename_esm), "app");
 var SERVER_ROOT = path11.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
 var API_PREFIX2 = "/api/v0";
@@ -239816,7 +239875,6 @@ app.use(loggerMiddleware);
 app.use(httpMetricsMiddleware);
 checkHeapConfiguration();
 var environmentStore = new EnvironmentStore(SERVER_ROOT);
-var manifestService = new ManifestService(environmentStore);
 var watchModeController = new WatchModeController(environmentStore);
 var connectionController = new ConnectionController(environmentStore);
 var modelController = new ModelController(environmentStore);
@@ -239824,13 +239882,12 @@ var memoryGovernorConfig = getMemoryGovernorConfig();
 var memoryGovernor = memoryGovernorConfig ? new PackageMemoryGovernor(memoryGovernorConfig) : null;
 memoryGovernor?.start();
 environmentStore.setMemoryGovernor(memoryGovernor);
-var packageController = new PackageController(environmentStore, manifestService);
+var packageController = new PackageController(environmentStore);
 var databaseController = new DatabaseController(environmentStore);
 var queryController = new QueryController(environmentStore);
 var compileController = new CompileController(environmentStore);
-var materializationService = new MaterializationService(environmentStore, manifestService);
+var materializationService = new MaterializationService(environmentStore);
 var materializationController = new MaterializationController(materializationService);
-var manifestController = new ManifestController(environmentStore, manifestService);
 var mcpApp = import_express.default();
 registerHealthEndpoints(mcpApp);
 mcpApp.use(MCP_ENDPOINT, import_express.default.json());
@@ -239973,11 +240030,11 @@ app.get("/environments/:environmentName/packages/:packageName", (req, res, next)
 app.get("/environments/:environmentName/packages/:packageName/*", serveFromPackage);
 var PAGES_DEPTH_CAP = 3;
 async function listPackagePages(environmentName, packageName, publicRoot) {
-  const fs8 = await import("fs/promises");
+  const fs9 = await import("fs/promises");
   const out = [];
   let realPublicRoot;
   try {
-    realPublicRoot = await fs8.realpath(publicRoot);
+    realPublicRoot = await fs9.realpath(publicRoot);
   } catch {
     return out;
   }
@@ -239986,7 +240043,7 @@ async function listPackagePages(environmentName, packageName, publicRoot) {
       return;
     let entries;
     try {
-      entries = await fs8.readdir(dir, { withFileTypes: true });
+      entries = await fs9.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -239996,7 +240053,7 @@ async function listPackagePages(environmentName, packageName, publicRoot) {
       const full = path11.join(dir, entry.name);
       let realFull;
       try {
-        realFull = await fs8.realpath(full);
+        realFull = await fs9.realpath(full);
       } catch {
         continue;
       }
@@ -240009,7 +240066,7 @@ async function listPackagePages(environmentName, packageName, publicRoot) {
         const rel = path11.relative(publicRoot, full).replace(/\\/g, "/");
         let title = rel;
         try {
-          const fh = await fs8.open(full, "r");
+          const fh = await fs9.open(full, "r");
           try {
             const buf = Buffer.alloc(4096);
             const { bytesRead } = await fh.read(buf, 0, 4096, 0);
@@ -240320,15 +240377,6 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/conn
     res.status(status).json(json);
   }
 });
-app.get(`${API_PREFIX2}/environments/:environmentName/connections/:connectionName/sqlSource`, async (req, res) => {
-  try {
-    res.status(200).json(await connectionController.getConnectionSqlSource(req.params.environmentName, req.params.connectionName, req.query.sqlStatement));
-  } catch (error) {
-    logger.error(error);
-    const { json, status } = internalErrorToHttpError(error);
-    res.status(status).json(json);
-  }
-});
 app.post(`${API_PREFIX2}/environments/:environmentName/connections/:connectionName/sqlSource`, async (req, res) => {
   try {
     res.status(200).json(await connectionController.getConnectionSqlSource(req.params.environmentName, req.params.connectionName, req.body.sqlStatement));
@@ -240338,15 +240386,6 @@ app.post(`${API_PREFIX2}/environments/:environmentName/connections/:connectionNa
     res.status(status).json(json);
   }
 });
-app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/connections/:connectionName/sqlSource`, async (req, res) => {
-  try {
-    res.status(200).json(await connectionController.getConnectionSqlSource(req.params.environmentName, req.params.connectionName, req.query.sqlStatement, req.params.packageName));
-  } catch (error) {
-    logger.error(error);
-    const { json, status } = internalErrorToHttpError(error);
-    res.status(status).json(json);
-  }
-});
 app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/connections/:connectionName/sqlSource`, async (req, res) => {
   try {
     res.status(200).json(await connectionController.getConnectionSqlSource(req.params.environmentName, req.params.connectionName, req.body.sqlStatement, req.params.packageName));
@@ -240358,13 +240397,7 @@ app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/con
 });
 app.post(`${API_PREFIX2}/environments/:environmentName/connections/:connectionName/sqlQuery`, queryConcurrency(), async (req, res) => {
   try {
-    let options;
-    if (req.body?.options) {
-      options = req.body.options;
-    } else {
-      options = req.query.options;
-    }
-    res.status(200).json(await connectionController.getConnectionQueryData(req.params.environmentName, req.params.connectionName, req.body.sqlStatement, options));
+    res.status(200).json(await connectionController.getConnectionQueryData(req.params.environmentName, req.params.connectionName, req.body.sqlStatement, req.body?.options));
   } catch (error) {
     logger.error(error);
     const { json, status } = internalErrorToHttpError(error);
@@ -240373,31 +240406,7 @@ app.post(`${API_PREFIX2}/environments/:environmentName/connections/:connectionNa
 });
 app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/connections/:connectionName/sqlQuery`, queryConcurrency(), async (req, res) => {
   try {
-    let options;
-    if (req.body?.options) {
-      options = req.body.options;
-    } else {
-      options = req.query.options;
-    }
-    res.status(200).json(await connectionController.getConnectionQueryData(req.params.environmentName, req.params.connectionName, req.body.sqlStatement, options, req.params.packageName));
-  } catch (error) {
-    logger.error(error);
-    const { json, status } = internalErrorToHttpError(error);
-    res.status(status).json(json);
-  }
-});
-app.get(`${API_PREFIX2}/environments/:environmentName/connections/:connectionName/temporaryTable`, queryConcurrency(), async (req, res) => {
-  try {
-    res.status(200).json(await connectionController.getConnectionTemporaryTable(req.params.environmentName, req.params.connectionName, req.query.sqlStatement));
-  } catch (error) {
-    logger.error(error);
-    const { json, status } = internalErrorToHttpError(error);
-    res.status(status).json(json);
-  }
-});
-app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/connections/:connectionName/temporaryTable`, queryConcurrency(), async (req, res) => {
-  try {
-    res.status(200).json(await connectionController.getConnectionTemporaryTable(req.params.environmentName, req.params.connectionName, req.query.sqlStatement, req.params.packageName));
+    res.status(200).json(await connectionController.getConnectionQueryData(req.params.environmentName, req.params.connectionName, req.body.sqlStatement, req.body?.options, req.params.packageName));
   } catch (error) {
     logger.error(error);
     const { json, status } = internalErrorToHttpError(error);
@@ -240437,8 +240446,7 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages`, async (req, res
 });
 app.post(`${API_PREFIX2}/environments/:environmentName/packages`, async (req, res) => {
   try {
-    const autoLoadManifest = req.query.autoLoadManifest === "true";
-    const _package = await packageController.addPackage(req.params.environmentName, req.body, { autoLoadManifest });
+    const _package = await packageController.addPackage(req.params.environmentName, req.body);
     res.status(200).json(_package?.getPackageMetadata());
   } catch (error) {
     logger.error(error);
@@ -240651,26 +240659,17 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/mate
     res.status(status).json(json);
   }
 });
-app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/materializations/teardown`, async (req, res) => {
-  try {
-    const result = await materializationController.teardownPackage(req.params.environmentName, req.params.packageName, req.body || {});
-    res.status(200).json(result);
-  } catch (error) {
-    const { json, status } = internalErrorToHttpError(error);
-    res.status(status).json(json);
-  }
-});
 app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/materializations/:materializationId`, async (req, res) => {
   try {
     const action = req.query.action;
-    if (action === "start") {
-      const build = await materializationController.startMaterialization(req.params.environmentName, req.params.packageName, req.params.materializationId);
+    if (action === "build") {
+      const build = await materializationController.buildMaterialization(req.params.environmentName, req.params.packageName, req.params.materializationId, req.body || {});
       res.status(202).json(build);
     } else if (action === "stop") {
       const build = await materializationController.stopMaterialization(req.params.environmentName, req.params.packageName, req.params.materializationId);
       res.status(200).json(build);
     } else {
-      throw new BadRequestError(`Unsupported action '${String(action ?? "")}'. Expected 'start' or 'stop'.`);
+      throw new BadRequestError(`Unsupported action '${String(action ?? "")}'. Expected 'build' or 'stop'.`);
     }
   } catch (error) {
     const { json, status } = internalErrorToHttpError(error);
@@ -240679,38 +240678,13 @@ app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/mat
 });
 app.delete(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/materializations/:materializationId`, async (req, res) => {
   try {
-    await materializationController.deleteMaterialization(req.params.environmentName, req.params.packageName, req.params.materializationId);
+    await materializationController.deleteMaterialization(req.params.environmentName, req.params.packageName, req.params.materializationId, { dropTables: req.query.dropTables === "true" });
     res.status(204).send();
   } catch (error) {
     const { json, status } = internalErrorToHttpError(error);
     res.status(status).json(json);
   }
 });
-app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/manifest`, async (req, res) => {
-  try {
-    const manifest = await manifestController.getManifest(req.params.environmentName, req.params.packageName);
-    res.status(200).json(manifest);
-  } catch (error) {
-    logger.error("Get manifest error", { error });
-    const { json, status } = internalErrorToHttpError(error);
-    res.status(status).json(json);
-  }
-});
-app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/manifest`, async (req, res) => {
-  try {
-    const action = req.query.action;
-    if (action === "reload") {
-      const manifest = await manifestController.reloadManifest(req.params.environmentName, req.params.packageName);
-      res.status(200).json(manifest);
-    } else {
-      throw new BadRequestError(`Unsupported action '${String(action ?? "")}'. Expected 'reload'.`);
-    }
-  } catch (error) {
-    logger.error("Manifest action error", { error });
-    const { json, status } = internalErrorToHttpError(error);
-    res.status(status).json(json);
-  }
-});
 registerLegacyRoutes(app, {
   environmentStore,
   connectionController,
@@ -240719,8 +240693,7 @@ registerLegacyRoutes(app, {
   databaseController,
   queryController,
   compileController,
-  materializationController,
-  manifestController
+  materializationController
 });
 if (!isDevelopment) {
   const SPA_INDEX = path11.resolve(ROOT, "index.html");