@malloy-publisher/server 0.0.235 → 0.0.236

package/dist/server.mjs

@@ -156020,6 +156020,8 @@ function internalErrorToHttpError(error) {
     return httpError(400, error.message);
   } else if (error instanceof ConnectionNotFoundError) {
     return httpError(404, error.message);
+  } else if (error instanceof DestinationNotFoundError) {
+    return httpError(422, error.message);
   } else if (error instanceof ConnectionAuthError) {
     return httpError(422, error.message);
   } else if (error instanceof UnsupportedCatalogFormatError) {
@@ -156055,7 +156057,7 @@ function httpError(code, message) {
     }
   };
 }
-var NotImplementedError, BadRequestError, EnvironmentNotFoundError, PackageNotFoundError, ModelNotFoundError, ConnectionNotFoundError, ConnectionError, ConnectionAuthError, UnsupportedCatalogFormatError, ModelCompilationError, MaterializationEligibilityError, FrozenConfigError, AccessDeniedError, NotQueryableError, MaterializationNotFoundError, MaterializationConflictError, InvalidStateTransitionError, ServiceUnavailableError, PayloadTooLargeError, QueryTimeoutError;
+var NotImplementedError, BadRequestError, EnvironmentNotFoundError, PackageNotFoundError, ModelNotFoundError, ConnectionNotFoundError, ConnectionError, DestinationNotFoundError, ConnectionAuthError, UnsupportedCatalogFormatError, ModelCompilationError, MaterializationEligibilityError, FrozenConfigError, AccessDeniedError, NotQueryableError, MaterializationNotFoundError, MaterializationConflictError, InvalidStateTransitionError, ServiceUnavailableError, PayloadTooLargeError, QueryTimeoutError;
 var init_errors = __esm(() => {
   init_constants();
   NotImplementedError = class NotImplementedError extends Error {
@@ -156093,6 +156095,11 @@ var init_errors = __esm(() => {
       super(message);
     }
   };
+  DestinationNotFoundError = class DestinationNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
   ConnectionAuthError = class ConnectionAuthError extends Error {
     constructor(message) {
       super(message);
@@ -261655,6 +261662,7 @@ var getProcessedPublisherConfig = (serverRoot) => {
       name: environment.name,
       packages: validPackages,
       connections: convertConnectionsToApiConnections(environment.connections || []),
+      storageDestinations: Array.isArray(environment.storageDestinations) ? environment.storageDestinations : [],
       ...resolvedTheme ? { theme: resolvedTheme } : {}
     });
   }
@@ -265185,6 +265193,7 @@ function safeJoinUnderRoot(root, ...segments) {
 }
 
 // src/service/connection_config.ts
+init_errors();
 init_logger();
 import { createPrivateKey } from "crypto";
 import { existsSync } from "fs";
@@ -265865,6 +265874,106 @@ function validateConnectionShape(connection) {
     }
   }
 }
+var DECLARABLE_STORAGE_DESTINATION_TYPES = new Set(["ducklake"]);
+var STORAGE_DESTINATIONS_DIR = ".storage-destinations";
+function storageDestinationRoot(environmentPath) {
+  return path3.join(environmentPath, STORAGE_DESTINATIONS_DIR);
+}
+function validateStorageDestinations(destinations = []) {
+  const accepted = [];
+  const rejected = [];
+  if (!Array.isArray(destinations)) {
+    return {
+      accepted,
+      rejected: [{ reason: "the value is not a list of destinations." }]
+    };
+  }
+  const seen = new Set;
+  for (const destination of destinations) {
+    if (!destination || typeof destination !== "object") {
+      rejected.push({ reason: "the entry is not an object." });
+      continue;
+    }
+    const { name, type } = destination;
+    if (!name || typeof name !== "string") {
+      rejected.push({
+        reason: `the "name" field is missing or not a string.`
+      });
+      continue;
+    }
+    if (!type || !DECLARABLE_STORAGE_DESTINATION_TYPES.has(type)) {
+      rejected.push({
+        name,
+        reason: `the type "${type}" is not a supported destination type ` + `(supported: ${[...DECLARABLE_STORAGE_DESTINATION_TYPES].join(", ")}).`
+      });
+      continue;
+    }
+    if (name === "duckdb") {
+      rejected.push({
+        name,
+        reason: `the name "duckdb" is reserved for per-package sandboxes.`
+      });
+      continue;
+    }
+    if (seen.has(name)) {
+      rejected.push({
+        name,
+        reason: "an earlier entry already uses this name."
+      });
+      continue;
+    }
+    try {
+      validateConnectionShape(destination);
+    } catch (error) {
+      rejected.push({ name, reason: error.message });
+      continue;
+    }
+    seen.add(name);
+    const { resource: _resource, ...body } = destination;
+    accepted.push(body);
+  }
+  return { accepted, rejected };
+}
+function describeRejection(rejection) {
+  return rejection.name ? `storage destination "${rejection.name}": ${rejection.reason}` : `storage destination: ${rejection.reason}`;
+}
+function processStorageDestinations(destinations = []) {
+  const { accepted, rejected } = validateStorageDestinations(destinations);
+  for (const rejection of rejected) {
+    logger.warn(`Invalid ${describeRejection(rejection)} Skipping.`);
+  }
+  return accepted;
+}
+function processStorageDestinationsOrThrow(destinations = []) {
+  const { accepted, rejected } = validateStorageDestinations(destinations);
+  if (rejected.length > 0) {
+    throw new BadRequestError(`storageDestinations was not accepted — ${rejected.map(describeRejection).join(" ")}`);
+  }
+  return accepted;
+}
+function storageDestinationsEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  return canonicalDestinationList(left) === canonicalDestinationList(right);
+}
+function canonicalDestinationList(destinations) {
+  return JSON.stringify([...destinations].sort((left, right) => (left.name ?? "") < (right.name ?? "") ? -1 : 1).map(canonicalizeJsonValue));
+}
+function canonicalizeJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonicalizeJsonValue);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const entries = value;
+  const sorted = {};
+  for (const key of Object.keys(entries).sort()) {
+    sorted[key] = canonicalizeJsonValue(entries[key]);
+  }
+  return sorted;
+}
 function assembleEnvironmentConnections(connections = [], environmentPath = "") {
   const pojo = { connections: {} };
   const metadata = new Map;
@@ -266798,6 +266907,18 @@ async function deleteDuckLakeConnectionFile(connectionName, environmentPath) {
     }
   }
 }
+function restrictMalloyConfigToConnections(base, allowed) {
+  const restricted = new MalloyConfig({ connections: {} });
+  restricted.wrapConnections(() => ({
+    lookupConnection: async (name) => {
+      if (!name || !allowed.has(name)) {
+        throw new ConnectionNotFoundError(`Connection ${name ?? "(default)"} is not available to a materialization serve shape`);
+      }
+      return base.connections.lookupConnection(name);
+    }
+  }));
+  return restricted;
+}
 function entryToDuckDBOptions(name, entry, workingDirectory) {
   const { is: _is, ...rest } = entry;
   if (workingDirectory !== undefined) {
@@ -275885,6 +276006,66 @@ class EnvironmentRepository {
   }
 }
 
+// src/storage/duckdb/StorageDestinationRepository.ts
+class StorageDestinationRepository {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+  async list(environmentId) {
+    const rows = await this.db.all("SELECT * FROM storage_destinations WHERE environment_id = ? ORDER BY name", [environmentId]);
+    return rows.map(this.mapToDestination);
+  }
+  async getByName(environmentId, name) {
+    const row = await this.db.get("SELECT * FROM storage_destinations WHERE environment_id = ? AND name = ?", [environmentId, name]);
+    return row ? this.mapToDestination(row) : null;
+  }
+  async upsert(destination) {
+    const existing = await this.getByName(destination.environmentId, destination.name);
+    const now = new Date;
+    const configJson = JSON.stringify(destination.config);
+    if (existing) {
+      await this.db.run(`UPDATE storage_destinations
+                SET type = ?, config = ?, updated_at = ?
+              WHERE id = ?`, [destination.type, configJson, now.toISOString(), existing.id]);
+      return { ...existing, ...destination, updatedAt: now };
+    }
+    const id = this.generateId();
+    await this.db.run(`INSERT INTO storage_destinations
+             (id, environment_id, name, type, config, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+      id,
+      destination.environmentId,
+      destination.name,
+      destination.type,
+      configJson,
+      now.toISOString(),
+      now.toISOString()
+    ]);
+    return { id, ...destination, createdAt: now, updatedAt: now };
+  }
+  async deleteById(id) {
+    await this.db.run("DELETE FROM storage_destinations WHERE id = ?", [id]);
+  }
+  async deleteByEnvironmentId(environmentId) {
+    await this.db.run("DELETE FROM storage_destinations WHERE environment_id = ?", [environmentId]);
+  }
+  mapToDestination(row) {
+    return {
+      id: row.id,
+      environmentId: row.environment_id,
+      name: row.name,
+      type: row.type,
+      config: JSON.parse(row.config),
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+}
+
 // src/storage/duckdb/MaterializationRepository.ts
 var TERMINAL_STATUSES = new Set([
   "MANIFEST_FILE_READY",
@@ -276173,12 +276354,14 @@ class DuckDBRepository {
   environmentRepo;
   packageRepo;
   connectionRepo;
+  destinationRepo;
   materializationRepo;
   constructor(db) {
     this.db = db;
     this.environmentRepo = new EnvironmentRepository(db);
     this.packageRepo = new PackageRepository(db);
     this.connectionRepo = new ConnectionRepository(db);
+    this.destinationRepo = new StorageDestinationRepository(db);
     this.materializationRepo = new MaterializationRepository(db);
   }
   async listEnvironments() {
@@ -276199,6 +276382,7 @@ class DuckDBRepository {
   async deleteEnvironment(id) {
     await this.materializationRepo.deleteByEnvironmentId(id);
     await this.connectionRepo.deleteConnectionsByEnvironmentId(id);
+    await this.destinationRepo.deleteByEnvironmentId(id);
     await this.packageRepo.deletePackagesByEnvironmentId(id);
     await this.environmentRepo.deleteEnvironment(id);
   }
@@ -276248,6 +276432,21 @@ class DuckDBRepository {
   async deleteConnectionsByEnvironmentId(id) {
     return this.connectionRepo.deleteConnectionsByEnvironmentId(id);
   }
+  async listStorageDestinations(environmentId) {
+    return this.destinationRepo.list(environmentId);
+  }
+  async getStorageDestinationByName(environmentId, name) {
+    return this.destinationRepo.getByName(environmentId, name);
+  }
+  async upsertStorageDestination(destination) {
+    return this.destinationRepo.upsert(destination);
+  }
+  async deleteStorageDestination(id) {
+    return this.destinationRepo.deleteById(id);
+  }
+  async deleteStorageDestinationsByEnvironmentId(id) {
+    return this.destinationRepo.deleteByEnvironmentId(id);
+  }
   async listMaterializations(environmentId, packageName, options) {
     return this.materializationRepo.list(environmentId, packageName, options);
   }
@@ -276323,6 +276522,19 @@ async function initializeSchema(db, force = false) {
       UNIQUE (environment_id, name)
     )
   `);
+  await db.run(`
+    CREATE TABLE IF NOT EXISTS storage_destinations (
+      id VARCHAR PRIMARY KEY,
+      environment_id VARCHAR NOT NULL,
+      name VARCHAR NOT NULL,
+      type VARCHAR NOT NULL,
+      config JSON NOT NULL,
+      created_at TIMESTAMP NOT NULL,
+      updated_at TIMESTAMP NOT NULL,
+      FOREIGN KEY (environment_id) REFERENCES environments(id),
+      UNIQUE (environment_id, name)
+    )
+  `);
   await db.run(`
     CREATE TABLE IF NOT EXISTS materializations (
       id VARCHAR PRIMARY KEY,
@@ -276351,6 +276563,7 @@ async function initializeSchema(db, force = false) {
   await createEntityEmbeddingsTable(db);
   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_storage_destinations_environment_id ON storage_destinations(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)");
 }
@@ -276399,6 +276612,7 @@ async function dropAllTables(db) {
     "materializations",
     "packages",
     "connections",
+    "storage_destinations",
     "environments",
     "themes",
     "entity_embeddings"
@@ -276647,7 +276861,7 @@ function splitManifestEntries(entries, source) {
       });
       continue;
     }
-    if (entry.storageConnectionName) {
+    if (entry.storageDestinationName) {
       storageEntries[sourceEntityId] = entry;
       continue;
     }
@@ -276741,7 +276955,7 @@ import {
 function deriveServeBindings(entries) {
   const bindings = [];
   for (const entry of Object.values(entries)) {
-    if (!entry.sourceName || !entry.storageConnectionName || !entry.physicalTableName) {
+    if (!entry.sourceName || !entry.storageDestinationName || !entry.physicalTableName) {
       continue;
     }
     const schema = (entry.schema ?? []).filter((c) => c.name && c.type).map((c) => ({ name: c.name, type: c.type }));
@@ -276749,9 +276963,9 @@ function deriveServeBindings(entries) {
       continue;
     bindings.push({
       sourceName: entry.sourceName,
-      connectionName: entry.storageConnectionName,
+      destinationName: entry.storageDestinationName,
       virtualHandle: entry.sourceEntityId,
-      tablePath: `${entry.storageConnectionName}.${entry.physicalTableName}`,
+      tablePath: `${entry.storageDestinationName}.${entry.physicalTableName}`,
       schema,
       freshAsOf: entry.dataAsOf,
       freshnessWindowSeconds: entry.freshnessWindowSeconds,
@@ -276830,7 +277044,7 @@ function buildServeShapeModel(sourceName, binding) {
 type: ${shapeTypeName} is {
 ${fields}
 }
-source: ${sourceName} is ${binding.connectionName}.virtual('${binding.virtualHandle}')::${shapeTypeName}
+source: ${sourceName} is ${binding.destinationName}.virtual('${binding.virtualHandle}')::${shapeTypeName}
 `;
   return { modelText, shapeTypeName };
 }
@@ -276838,7 +277052,7 @@ function serveShapeFragment(binding) {
   const shapeTypeName = `${binding.sourceName}__shape`;
   const fields = binding.schema.map((c) => `   ${emitFieldName(c.name)}::${duckdbTypeToMalloy(c.type)}`).join(`,
 `);
-  let source = `source: ${binding.sourceName} is ` + `${binding.connectionName}.virtual('${binding.virtualHandle}')::${shapeTypeName}`;
+  let source = `source: ${binding.sourceName} is ` + `${binding.destinationName}.virtual('${binding.virtualHandle}')::${shapeTypeName}`;
   const refinements = binding.refinements ?? [];
   const lines = [];
   for (const r of refinements) {
@@ -277023,10 +277237,10 @@ function extractViews(fields, liftText) {
 function buildVirtualMap(bindings) {
   const map = new Map;
   for (const b of bindings) {
-    let inner = map.get(b.connectionName);
+    let inner = map.get(b.destinationName);
     if (!inner) {
       inner = new Map;
-      map.set(b.connectionName, inner);
+      map.set(b.destinationName, inner);
     }
     inner.set(b.virtualHandle, quoteManifestTablePath(b.tablePath, "duckdb"));
   }
@@ -277894,7 +278108,7 @@ class Model {
   modelMaterializer;
   modelDef;
   modelInfo;
-  serveMalloyConfig;
+  serveDestinationConfig;
   serveBindings = [];
   serveShapeCache;
   sources;
@@ -278282,7 +278496,6 @@ class Model {
     const modelMaterializer = runtime._loadModelFromModelDef(modelDef);
     const runnableNotebookCells = data.modelType === "notebook" ? hydrateNotebookCells(runtime, data.notebookCells) : undefined;
     const model = new Model(packageName, data.modelPath, dataStyles, data.modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, undefined, filterMap, givens, modelInfo);
-    model.setServeMalloyConfig(malloyConfig);
     return model;
   }
   static fromCompilationError(packageName, modelPath, modelType, error) {
@@ -278481,8 +278694,12 @@ class Model {
       throw new ModelNotFoundError(`${this.modelPath} is not a valid notebook name.  Notebook files must end in .malloynb.`);
     }
   }
-  setServeMalloyConfig(config) {
-    this.serveMalloyConfig = config;
+  setServeDestinationConfig(provider) {
+    this.serveDestinationConfig = provider;
+    this.invalidateServeShapeCache();
+  }
+  invalidateServeShapeCache() {
+    this.serveShapeCache = undefined;
   }
   setServeBindings(bindings) {
     this.serveBindings = bindings;
@@ -278502,7 +278719,7 @@ class Model {
     if (freshBindings.length === 0) {
       throw new Error("no fresh storage serve bindings for this query");
     }
-    const key = freshBindings.map((b) => `${b.sourceName}@${b.connectionName}/${b.virtualHandle}`).sort().join("|");
+    const key = freshBindings.map((b) => `${b.sourceName}@${b.destinationName}/${b.virtualHandle}`).sort().join("|");
     if (!this.serveShapeCache || this.serveShapeCache.key !== key) {
       this.serveShapeCache = {
         key,
@@ -278553,7 +278770,7 @@ class Model {
     const url2 = `${root}shape.malloy`;
     const runtime = new Runtime2({
       urlReader: new InMemoryURLReader2(new Map([[url2, modelText]])),
-      config: Model.toMalloyConfig(this.serveMalloyConfig)
+      config: restrictMalloyConfigToConnections(this.serveDestinationConfig(), new Set(bindings.map((binding) => binding.destinationName)))
     });
     return runtime.loadModel(new URL(url2), {
       importBaseURL: new URL(root)
@@ -278650,7 +278867,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       }
       runnable = this.modelMaterializer.loadRestrictedQuery(queryString);
       liveRunnable = runnable;
-      if (getPersistStorageMode() === "on" && this.serveBindings.length > 0 && this.serveMalloyConfig) {
+      if (getPersistStorageMode() === "on" && this.serveBindings.length > 0 && this.serveDestinationConfig) {
         try {
           const shaped = await this.loadServeShapeQuery(queryString);
           runnable = shaped.runnable;
@@ -279681,6 +279898,7 @@ class Package {
   models = new Map;
   packagePath;
   malloyConfig;
+  serveDestinationConfig;
   buildManifestEntries;
   freshnessEntries;
   storageServeBindings = [];
@@ -279940,7 +280158,7 @@ class Package {
     if (this.storageServeBindings.length > 0) {
       metadata.storageServeBindings = this.storageServeBindings.map((b) => ({
         sourceName: b.sourceName,
-        storageConnectionName: b.connectionName,
+        storageDestinationName: b.destinationName,
         tablePath: b.tablePath
       }));
     }
@@ -280016,6 +280234,22 @@ class Package {
       model.setServeBindings(this.storageServeBindings);
     }
   }
+  setServeDestinationConfig(provider) {
+    this.serveDestinationConfig = provider;
+    this.pushServeDestinationConfigToModels();
+  }
+  pushServeDestinationConfigToModels() {
+    if (!this.serveDestinationConfig)
+      return;
+    for (const model of this.models.values()) {
+      model.setServeDestinationConfig(this.serveDestinationConfig);
+    }
+  }
+  invalidateServeShapes() {
+    for (const model of this.models.values()) {
+      model.invalidateServeShapeCache();
+    }
+  }
   getInvalidExplores(exploresOverride) {
     const declared = exploresOverride ?? this.packageMetadata.explores;
     if (!declared || declared.length === 0)
@@ -280258,6 +280492,7 @@ class Package {
     }
     this.models = nextModels;
     this.pushStorageServeBindingsToModels();
+    this.pushServeDestinationConfigToModels();
     this.renderTagWarnings = renderTagWarnings;
     this.manifestWarnings = outcome.packageMetadata.manifestWarnings ?? [];
     this.packageMetadata.explores = outcome.packageMetadata.explores;
@@ -280435,6 +280670,11 @@ var STAGING_DIR_NAME = ".staging";
 var RETIRED_DIR_NAME = ".retired";
 var MANIFEST_FETCH_TIMEOUT_MS = 15000;
 var RETIRED_CONNECTION_DRAIN_MS = 30000;
+var DESTINATION_READ_FIELDS = new Set([
+  "name",
+  "type",
+  "resource"
+]);
 var queryAdmissionRejectionsCounter = null;
 var packageAdmissionRejectionsCounter = null;
 function getQueryAdmissionRejectionsCounter() {
@@ -280464,6 +280704,9 @@ class Environment {
   connectionMutex = new Mutex;
   retiredConnectionGenerations = new Set;
   apiConnections;
+  destinations;
+  destinationMalloyConfig;
+  destinationsAuthoritative = true;
   environmentPath;
   environmentName;
   storageBindingResolver;
@@ -280475,12 +280718,14 @@ class Environment {
   getEnvironmentName() {
     return this.environmentName;
   }
-  constructor(environmentName, environmentPath, malloyConfig, apiConnections) {
+  constructor(environmentName, environmentPath, malloyConfig, apiConnections, storageDestinations = []) {
     assertSafeEnvironmentPath(environmentPath);
     this.environmentName = environmentName;
     this.environmentPath = environmentPath;
     this.malloyConfig = malloyConfig;
     this.apiConnections = apiConnections;
+    this.destinations = [];
+    this.setStorageDestinations(storageDestinations);
     this.metadata = {
       resource: `${API_PREFIX}/environments/${this.environmentName}`,
       name: this.environmentName,
@@ -280501,6 +280746,11 @@ class Environment {
     }
   }
   async update(payload) {
+    if (payload.storageDestinations !== undefined) {
+      this.setStorageDestinations(payload.storageDestinations, {
+        rejectInvalid: true
+      });
+    }
     if (payload.readme !== undefined) {
       this.metadata.readme = payload.readme;
       await this.writeEnvironmentReadme(payload.readme);
@@ -280520,7 +280770,7 @@ class Environment {
     }
     return this;
   }
-  static async create(environmentName, environmentPath, connections) {
+  static async create(environmentName, environmentPath, connections, storageDestinations = []) {
     assertSafeEnvironmentPath(environmentPath);
     if (!(await fs7.promises.stat(environmentPath))?.isDirectory()) {
       throw new EnvironmentNotFoundError(`Environment path ${environmentPath} not found`);
@@ -280533,7 +280783,7 @@ class Environment {
         type: c.type
       }))
     });
-    const environment = new Environment(environmentName, environmentPath, malloyConfig, malloyConfig.apiConnections);
+    const environment = new Environment(environmentName, environmentPath, malloyConfig, malloyConfig.apiConnections, storageDestinations);
     await Environment.sweepStaleInstallDirs(environmentPath);
     return environment;
   }
@@ -280633,6 +280883,76 @@ ${source}` : source;
     }
     return connection;
   }
+  setStorageDestinations(storageDestinations, { rejectInvalid = false } = {}) {
+    const previous = this.destinations;
+    const requested = Array.isArray(storageDestinations) ? storageDestinations.map((destination) => this.resolveDestinationReference(destination)) : storageDestinations;
+    this.destinations = rejectInvalid ? processStorageDestinationsOrThrow(requested) : processStorageDestinations(requested);
+    this.destinationsAuthoritative = true;
+    if (this.destinationMalloyConfig && storageDestinationsEqual(previous, this.destinations)) {
+      return;
+    }
+    this.rebuildDestinationMalloyConfig();
+    if (previous.length > 0 || this.destinations.length > 0) {
+      logger.info(`Environment ${this.environmentName} has ${this.destinations.length} storage destination(s)`, { destinations: this.destinations.map((d) => d.name) });
+    }
+  }
+  resolveDestinationReference(destination) {
+    if (!destination || typeof destination !== "object") {
+      return destination;
+    }
+    const carriesOnlyReportedFields = Object.keys(destination).every((field) => DESTINATION_READ_FIELDS.has(field));
+    if (!carriesOnlyReportedFields) {
+      return destination;
+    }
+    return this.destinations.find((stored) => stored.name === destination.name) ?? destination;
+  }
+  attachDestinationServeConfig(_package) {
+    _package.setServeDestinationConfig(() => this.getStorageDestinationMalloyConfig());
+  }
+  rebuildDestinationMalloyConfig() {
+    const previous = this.destinationMalloyConfig;
+    try {
+      const destinationRoot = storageDestinationRoot(this.environmentPath);
+      if (this.destinations.length > 0) {
+        fs7.mkdirSync(destinationRoot, { recursive: true });
+      }
+      this.destinationMalloyConfig = buildEnvironmentMalloyConfig(this.destinations, destinationRoot);
+    } catch (error) {
+      logger.error(`Failed to assemble storage destinations for environment ${this.environmentName}; serving without them`, { error });
+      this.destinationMalloyConfig = buildEnvironmentMalloyConfig([], storageDestinationRoot(this.environmentPath));
+    }
+    if (previous && previous !== this.destinationMalloyConfig) {
+      this.retireConnectionGeneration(`environment ${this.environmentName} destinations`, () => previous.releaseConnections());
+      this.invalidateServeShapes();
+    }
+  }
+  invalidateServeShapes() {
+    for (const _package of this.packages.values()) {
+      _package.invalidateServeShapes();
+    }
+  }
+  getStorageDestinationMalloyConfig() {
+    return this.destinationMalloyConfig.malloyConfig;
+  }
+  markStorageDestinationsUnknown() {
+    this.destinationsAuthoritative = false;
+  }
+  hasAuthoritativeStorageDestinations() {
+    return this.destinationsAuthoritative;
+  }
+  listStorageDestinations() {
+    return this.destinations;
+  }
+  hasStorageDestination(destinationName) {
+    return this.destinations.some((destination) => destination.name === destinationName);
+  }
+  getStorageDestination(destinationName) {
+    const destination = this.destinations.find((destination2) => destination2.name === destinationName);
+    if (!destination) {
+      throw new DestinationNotFoundError(`Storage destination ${destinationName} not found`);
+    }
+    return destination;
+  }
   async getMalloyConnection(connectionName) {
     return this.malloyConfig.malloyConfig.connections.lookupConnection(connectionName);
   }
@@ -280804,6 +281124,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);
+      this.attachDestinationServeConfig(_package);
       await this.bindManifestIfConfigured(_package);
       await this.rebindServeBindingsFromLocalStore(_package);
       if (existingPackage !== undefined && reload) {
@@ -280845,7 +281166,9 @@ ${source}` : source;
     }
     this.setPackageStatus(packageName, "loading" /* LOADING */);
     try {
-      this.packages.set(packageName, await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig));
+      const addedPackage = await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig);
+      this.attachDestinationServeConfig(addedPackage);
+      this.packages.set(packageName, addedPackage);
     } catch (error) {
       logger.error("Error adding package", { error });
       this.deletePackageStatus(packageName);
@@ -280902,6 +281225,7 @@ ${source}` : source;
         await fs7.promises.rename(stagingPath, canonicalPath);
         this.setPackageStatus(packageName, "loading" /* LOADING */);
         newPackage = await Package.create(this.environmentName, packageName, canonicalPath, () => this.malloyConfig.malloyConfig, true);
+        this.attachDestinationServeConfig(newPackage);
         const validationMsg = validate?.(newPackage);
         if (validationMsg) {
           throw new BadRequestError(validationMsg);
@@ -281312,6 +281636,13 @@ ${source}` : source;
     } catch (error) {
       logger.error(`Error closing connections for environment ${this.environmentName}`, { error });
     }
+    try {
+      await this.destinationMalloyConfig.releaseConnections();
+    } catch (error) {
+      logger.error(`Error closing storage destinations for environment ${this.environmentName}`, { error: error instanceof Error ? error.message : String(error) });
+    }
+    this.destinations = [];
+    this.destinationsAuthoritative = false;
     await this.releaseAllRetiredConnectionGenerations();
     this.apiConnections = [];
     logger.info(`Closed all connections for environment ${this.environmentName}`);
@@ -281320,6 +281651,10 @@ ${source}` : source;
     return {
       ...this.metadata,
       connections: this.listApiConnections(),
+      storageDestinations: this.destinations.map(({ name, type }) => ({
+        name,
+        type
+      })),
       packages: await this.listPackages()
     };
   }
@@ -281609,6 +281944,9 @@ class EnvironmentStore {
         name: environment.name,
         resource: `${API_PREFIX}/environments/${environment.name}`,
         connections: environment.connections,
+        ...environment.storageDestinations.length ? {
+          storageDestinations: environment.storageDestinations
+        } : {},
         packages: environment.packages
       }, true);
     } catch (error) {
@@ -281641,15 +281979,16 @@ class EnvironmentStore {
           await Promise.all(existingEnvironments.map(async (dbEnvironment) => {
             try {
               const environmentExists = await fs8.promises.access(dbEnvironment.path).then(() => true).catch(() => false);
+              const environmentConfig = environmentManifest.environments.find((p) => p.name === dbEnvironment.name);
               if (!environmentExists) {
-                const environmentConfig = environmentManifest.environments.find((p) => p.name === dbEnvironment.name);
                 if (environmentConfig) {
                   const environmentInstance2 = await this.addEnvironment({
                     name: environmentConfig.name,
                     resource: `${API_PREFIX}/environments/${environmentConfig.name}`,
                     connections: environmentConfig.connections,
+                    storageDestinations: environmentConfig.storageDestinations,
                     packages: environmentConfig.packages
-                  }, true);
+                  }, true, { storageDestinationsAreFallback: true });
                   await repository.updateEnvironment(dbEnvironment.id, {
                     path: environmentInstance2.metadata.location
                   });
@@ -281660,12 +281999,30 @@ class EnvironmentStore {
                 }
               }
               const connections = await repository.listConnections(dbEnvironment.id);
+              let destinations = environmentConfig?.storageDestinations;
+              let destinationsRead = true;
+              try {
+                const stored = await repository.listStorageDestinations(dbEnvironment.id);
+                if (stored.length) {
+                  destinations = stored.map((row) => ({
+                    name: row.name,
+                    type: row.type,
+                    ...row.config
+                  }));
+                }
+              } catch (error) {
+                destinationsRead = false;
+                logger.error(`Error reading storage destinations for "${dbEnvironment.name}"; continuing without the stored ones`, { error });
+              }
               const environmentInstance = await Environment.create(dbEnvironment.name, dbEnvironment.path, connections.map((conn) => ({
                 name: conn.name,
                 type: conn.type,
                 resource: `${API_PREFIX}/connections/${conn.name}`,
                 ...conn.config
-              })));
+              })), destinations);
+              if (!destinationsRead) {
+                environmentInstance.markStorageDestinationsUnknown();
+              }
               environmentInstance.setMemoryGovernor(this.memoryGovernor);
               const envId = dbEnvironment.id;
               environmentInstance.setStorageBindingResolver(async (packageName) => {
@@ -281732,6 +282089,7 @@ class EnvironmentStore {
     const repository = this.storageManager.getRepository();
     const dbEnvironment = await this.addEnvironmentMetadata(environment, repository);
     await this.addConnections(environment, dbEnvironment.id, repository);
+    await this.syncStorageDestinations(environment, dbEnvironment.id, repository);
     await this.addPackages(environment, dbEnvironment.id, repository);
     logger.info(`Synced environment "${environmentName}" to database`);
   }
@@ -281832,6 +282190,38 @@ class EnvironmentStore {
       logger.error(`Error syncing connections for "${environmentName}":`, error);
     }
   }
+  async syncStorageDestinations(environment, environmentId, repository) {
+    try {
+      const destinations = environment.listStorageDestinations();
+      const kept = new Set;
+      for (const destination of destinations) {
+        if (!destination.name || !destination.type) {
+          continue;
+        }
+        kept.add(destination.name);
+        await repository.upsertStorageDestination({
+          environmentId,
+          name: destination.name,
+          type: destination.type,
+          config: destination
+        });
+      }
+      if (!environment.hasAuthoritativeStorageDestinations()) {
+        logger.warn(`Not reconciling stored storage destinations for "${environment.metadata?.name}": this environment's destinations were never read, so the in-memory list is not the desired state`);
+        return;
+      }
+      const stored = await repository.listStorageDestinations(environmentId);
+      for (const row of stored) {
+        if (!kept.has(row.name)) {
+          await repository.deleteStorageDestination(row.id);
+          logger.info(`Removed storage destination ${row.name} from environment ${environment.metadata?.name}`);
+        }
+      }
+    } catch (err) {
+      const error = err;
+      logger.error(`Error syncing storage destinations for "${environment.metadata?.name}":`, error);
+    }
+  }
   async addConnection(conn, environmentId, repository) {
     if (!conn.name) {
       logger.warn("Skipping connection with undefined name");
@@ -282055,11 +282445,14 @@ class EnvironmentStore {
       return await this.addEnvironment({
         name: environmentName,
         resource: `${API_PREFIX}/environments/${environmentName}`,
-        connections: environmentConfig?.connections || []
+        connections: environmentConfig?.connections || [],
+        ...environmentConfig?.storageDestinations?.length ? {
+          storageDestinations: environmentConfig.storageDestinations
+        } : {}
       });
     });
   }
-  async addEnvironment(environment, skipInitialization = false) {
+  async addEnvironment(environment, skipInitialization = false, { storageDestinationsAreFallback = false } = {}) {
     if (!skipInitialization) {
       await this.finishedInitialization;
     }
@@ -282075,6 +282468,9 @@ class EnvironmentStore {
     if (existingEnvironment) {
       const updatedEnvironment = await existingEnvironment.update(environment);
       this.environments.set(environmentName, updatedEnvironment);
+      if (storageDestinationsAreFallback) {
+        updatedEnvironment.markStorageDestinationsUnknown();
+      }
       await this.addEnvironmentToDatabase(updatedEnvironment);
       return updatedEnvironment;
     }
@@ -282094,7 +282490,7 @@ class EnvironmentStore {
     } else {
       absoluteEnvironmentPath = await this.scaffoldEnvironment(environment);
     }
-    const newEnvironment = await Environment.create(environmentName, absoluteEnvironmentPath, environment.connections || []);
+    const newEnvironment = await Environment.create(environmentName, absoluteEnvironmentPath, environment.connections || [], environment.storageDestinations || []);
     newEnvironment.setMemoryGovernor(this.memoryGovernor);
     if (!newEnvironment.metadata)
       newEnvironment.metadata = {};
@@ -282109,6 +282505,9 @@ class EnvironmentStore {
         newEnvironment.setPackageStatus(_package.name, "serving" /* SERVING */);
       }
     });
+    if (storageDestinationsAreFallback) {
+      newEnvironment.markStorageDestinationsUnknown();
+    }
     await this.addEnvironmentToDatabase(newEnvironment);
     return newEnvironment;
   }
@@ -282207,7 +282606,8 @@ class EnvironmentStore {
                     location: `./${entry.name}`
                   }
                 ],
-                connections: []
+                connections: [],
+                storageDestinations: []
               });
             }
           }
@@ -289910,7 +290310,8 @@ function registerLegacyRoutes(app, controllers) {
   });
   app.post(`${LEGACY_API_PREFIX}/projects`, async (req, res) => {
     try {
-      logger.info("Adding project", { body: req.body });
+      logger.info("Adding project", { body: redactSensitive(req.body) });
+      processStorageDestinationsOrThrow(req.body?.storageDestinations ?? []);
       const environment = await environmentStore.addEnvironment(req.body);
       res.status(200).json(await environment.serialize());
     } catch (error) {
@@ -290523,7 +290924,7 @@ import {
   InMemoryURLReader as InMemoryURLReader3,
   Runtime as Runtime4
 } from "@malloydata/malloy";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync as mkdirSync2, mkdtempSync, rmSync } from "node:fs";
 import os4 from "node:os";
 import path12 from "node:path";
 var sharedGateSession;
@@ -290616,7 +291017,7 @@ async function buildSourceIntoStorage(params) {
     const target = quoteManifestTablePath(`${destinationName}.${physicalTableName}`, "duckdb");
     const passthrough = wrapPassthrough(sourceType, federated.handle, buildSQL);
     const schema = await createTableAndDescribe(session, target, passthrough);
-    return { storageConnectionName: destinationName, schema };
+    return { storageDestinationName: destinationName, schema };
   } finally {
     await dispose();
   }
@@ -290668,7 +291069,7 @@ async function buildDownstreamIntoStorage(params) {
     const sql = projectToPublicColumns(downstream, downstream.getSQL({ virtualMap }));
     const target = quoteManifestTablePath(`${destinationName}.${physicalTableName}`, "duckdb");
     const schema = await createTableAndDescribe(session, target, sql);
-    return { storageConnectionName: destinationName, schema };
+    return { storageDestinationName: destinationName, schema };
   } finally {
     await dispose();
   }
@@ -290677,7 +291078,7 @@ async function assertStorageServeShapeCompiles(params) {
   const { destinationName, sourceName, virtualHandle, physicalTableName } = params;
   const binding = {
     sourceName,
-    connectionName: destinationName,
+    destinationName,
     virtualHandle,
     tablePath: `${destinationName}.${physicalTableName}`,
     schema: params.schema.filter((c) => c.name && c.type).map((c) => ({ name: c.name, type: c.type }))
@@ -290713,7 +291114,9 @@ async function attachDestinationReadWrite(session, destinationName, destinationC
     await attachDuckLakeReadWrite(session, destinationName, cfg);
     return;
   }
-  const dbPath = path12.join(environmentPath, `${destinationName}.duckdb`);
+  const destinationRoot = storageDestinationRoot(environmentPath);
+  mkdirSync2(destinationRoot, { recursive: true });
+  const dbPath = path12.join(destinationRoot, `${destinationName}.duckdb`);
   await session.runSQL(`ATTACH '${escapeSQL(dbPath)}' AS ${quoteIdentifier(destinationName, "duckdb")}`);
 }
 function assertSupportedDestination(destinationName, destinationConnection) {
@@ -290802,7 +291205,7 @@ function manifestExcludingStorage(manifest, builtEntries) {
   reduced.strict = manifest.strict;
   const quoted = manifest.buildManifest.entries;
   for (const [id, entry] of Object.entries(builtEntries)) {
-    if (!entry.storageConnectionName && quoted[id]) {
+    if (!entry.storageDestinationName && quoted[id]) {
       reduced.update(id, { tableName: quoted[id].tableName });
     }
   }
@@ -291050,7 +291453,7 @@ class MaterializationService {
           continue;
         seen.add(sourceEntityId);
         const prior = priorEntries[sourceEntityId];
-        if (prior && prior.physicalTableName && (prior.storageConnectionName ?? undefined) === destination) {
+        if (prior && prior.physicalTableName && (prior.storageDestinationName ?? undefined) === destination) {
           carried[sourceEntityId] = prior;
           continue;
         }
@@ -291159,7 +291562,7 @@ class MaterializationService {
   async autoLoadManifest(environment, packageName, entries) {
     const manifestEntries = {};
     for (const [sourceEntityId, entry] of Object.entries(entries)) {
-      if (entry.physicalTableName && !entry.storageConnectionName) {
+      if (entry.physicalTableName && !entry.storageDestinationName) {
         manifestEntries[sourceEntityId] = {
           tableName: entry.physicalTableName,
           connectionName: entry.connectionName
@@ -291254,7 +291657,7 @@ class MaterializationService {
           }
           const entry = await this.buildOneSource(persistSource, instruction, connection, connectionDigests, manifest, environment, entries, buildMetadata);
           entries[sourceEntityId] = entry;
-          if (entry.storageConnectionName)
+          if (entry.storageDestinationName)
             builtThisRun.push(entry);
         }
       }
@@ -291266,6 +291669,14 @@ class MaterializationService {
     }
     return entries;
   }
+  destinationForCleanup(environment, destinationName) {
+    try {
+      return environment.getStorageDestination(destinationName);
+    } catch (error) {
+      logger.warn("Skipping a table drop: its storage destination is no longer configured", { destinationName, error: errMessage(error) });
+      return;
+    }
+  }
   async reclaimStorageTablesFromFailedRun(builtThisRun, environment, owner) {
     if (builtThisRun.length === 0)
       return;
@@ -291277,14 +291688,14 @@ class MaterializationService {
         if (other.status !== "MANIFEST_FILE_READY")
           continue;
         for (const e of Object.values(other.manifest?.entries ?? {})) {
-          const dest = e.storageConnectionName ?? e.connectionName;
+          const dest = e.storageDestinationName ?? e.connectionName;
           if (dest && e.physicalTableName) {
             stillReferenced.add(tableKey(dest, e.physicalTableName));
           }
         }
       }
       for (const entry of builtThisRun) {
-        const dest = entry.storageConnectionName;
+        const dest = entry.storageDestinationName;
         const table = entry.physicalTableName;
         if (!dest || !table)
           continue;
@@ -291292,10 +291703,13 @@ class MaterializationService {
           logger.info("Keeping a table from a failed run: a live manifest still serves it", { destinationName: dest, physicalTableName: table });
           continue;
         }
+        const destinationConnection = this.destinationForCleanup(environment, dest);
+        if (!destinationConnection)
+          continue;
         try {
           await dropStorageTable({
             destinationName: dest,
-            destinationConnection: environment.getApiConnection(dest),
+            destinationConnection,
             physicalTableName: table,
             environmentPath: environment.getEnvironmentPath()
           });
@@ -291309,7 +291723,7 @@ class MaterializationService {
           logger.warn("Failed to reclaim a table stranded by a failed build", {
             destinationName: dest,
             physicalTableName: table,
-            error: redactConnectionSecrets(errMessage(dropErr), environment.getApiConnection(dest))
+            error: redactConnectionSecrets(errMessage(dropErr), destinationConnection)
           });
         }
       }
@@ -291415,7 +291829,7 @@ class MaterializationService {
     const physicalTableName = instruction.physicalTableName;
     const destinationName = instruction.destination;
     const sourceConnection = environment.getApiConnection(persistSource.connectionName);
-    const destinationConnection = environment.getApiConnection(destinationName);
+    const destinationConnection = environment.getStorageDestination(destinationName);
     const startTime = performance.now();
     let result;
     if (dependsOnStorageUpstream) {
@@ -291494,7 +291908,7 @@ class MaterializationService {
     recordSourceBuildDuration(durationMs, "storage");
     logger.info(`Built materialized source ${persistSource.name} into storage`, {
       physicalTableName,
-      storageConnectionName: result.storageConnectionName,
+      storageDestinationName: result.storageDestinationName,
       columns: result.schema.length,
       durationMs
     });
@@ -291504,14 +291918,14 @@ class MaterializationService {
       materializedTableId: instruction.materializedTableId,
       physicalTableName,
       connectionName: persistSource.connectionName,
-      storageConnectionName: result.storageConnectionName,
+      storageDestinationName: result.storageDestinationName,
       schema: result.schema,
       realization: instruction.realization,
       rowCount: null
     };
   }
   async buildDownstreamViaParents(persistSource, destinationName, destinationConnection, builtEntries, environment, physicalTableName) {
-    const upstreams = deriveServeBindings(builtEntries).filter((b) => b.connectionName === destinationName);
+    const upstreams = deriveServeBindings(builtEntries).filter((b) => b.destinationName === destinationName);
     if (upstreams.length === 0) {
       throw new MaterializationEligibilityError({
         message: "no materialized upstream is available in this destination to build on"
@@ -291618,7 +292032,7 @@ class MaterializationService {
       if (other.status !== "MANIFEST_FILE_READY")
         continue;
       for (const e of Object.values(other.manifest?.entries ?? {})) {
-        const dest = e.storageConnectionName ?? e.connectionName;
+        const dest = e.storageDestinationName ?? e.connectionName;
         if (dest && e.physicalTableName) {
           stillReferenced.add(tableKey(dest, e.physicalTableName));
         }
@@ -291634,7 +292048,7 @@ class MaterializationService {
         });
         continue;
       }
-      const destForKey = entry.storageConnectionName ?? connectionName;
+      const destForKey = entry.storageDestinationName ?? connectionName;
       if (stillReferenced.has(tableKey(destForKey, physicalTableName))) {
         logger.info("Skipping drop: table still referenced by another materialization", {
           materializationId: m.id,
@@ -291643,11 +292057,13 @@ class MaterializationService {
         });
         continue;
       }
-      if (entry.storageConnectionName) {
-        const destinationConnection = environment.getApiConnection(entry.storageConnectionName);
+      if (entry.storageDestinationName) {
+        const destinationConnection = this.destinationForCleanup(environment, entry.storageDestinationName);
+        if (!destinationConnection)
+          continue;
         try {
           await dropStorageTable({
-            destinationName: entry.storageConnectionName,
+            destinationName: entry.storageDestinationName,
             destinationConnection,
             physicalTableName,
             environmentPath: environment.getEnvironmentPath()
@@ -291656,14 +292072,14 @@ class MaterializationService {
           logger.info("Dropped materialized storage table on delete", {
             materializationId: m.id,
             physicalTableName,
-            storageConnectionName: entry.storageConnectionName
+            storageDestinationName: entry.storageDestinationName
           });
         } catch (err) {
           recordDropTables("failure", "storage");
           logger.warn("Failed to drop a storage-materialized table", {
             materializationId: m.id,
             physicalTableName,
-            storageConnectionName: entry.storageConnectionName,
+            storageDestinationName: entry.storageDestinationName,
             error: redactConnectionSecrets(errMessage(err), destinationConnection)
           });
         }
@@ -292461,7 +292877,8 @@ app.get(`${API_PREFIX2}/environments`, async (_req, res) => {
 });
 app.post(`${API_PREFIX2}/environments`, async (req, res) => {
   try {
-    logger.info("Adding environment", { body: req.body });
+    logger.info("Adding environment", { body: redactSensitive(req.body) });
+    processStorageDestinationsOrThrow(req.body?.storageDestinations ?? []);
     const environment = await environmentStore.addEnvironment(req.body);
     res.status(200).json(await environment.serialize());
   } catch (error) {