@malloy-publisher/server 0.0.197-dev → 0.0.197

package/dist/server.mjs

@@ -199378,14 +199378,14 @@ var require_brace_expansion = __commonJS((exports, module) => {
 var require_minimatch = __commonJS((exports, module) => {
   module.exports = minimatch;
   minimatch.Minimatch = Minimatch;
-  var path6 = function() {
+  var path7 = function() {
     try {
       return __require("path");
     } catch (e) {}
   }() || {
     sep: "/"
   };
-  minimatch.sep = path6.sep;
+  minimatch.sep = path7.sep;
   var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
   var expand = require_brace_expansion();
   var plTypes = {
@@ -199476,8 +199476,8 @@ var require_minimatch = __commonJS((exports, module) => {
     if (!options)
       options = {};
     pattern = pattern.trim();
-    if (!options.allowWindowsEscape && path6.sep !== "/") {
-      pattern = pattern.split(path6.sep).join("/");
+    if (!options.allowWindowsEscape && path7.sep !== "/") {
+      pattern = pattern.split(path7.sep).join("/");
     }
     this.options = options;
     this.set = [];
@@ -199854,8 +199854,8 @@ var require_minimatch = __commonJS((exports, module) => {
     if (f === "/" && partial)
       return true;
     var options = this.options;
-    if (path6.sep !== "/") {
-      f = f.split(path6.sep).join("/");
+    if (path7.sep !== "/") {
+      f = f.split(path7.sep).join("/");
     }
     f = f.split(slashSplit);
     this.debug(this.pattern, "split", f);
@@ -199966,9 +199966,9 @@ var require_recursive_readdir = __commonJS((exports, module) => {
   var p = __require("path");
   var minimatch = require_minimatch();
   function patternMatcher(pattern) {
-    return function(path6, stats) {
+    return function(path7, stats) {
       var minimatcher = new minimatch.Minimatch(pattern, { matchBase: true });
-      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path6);
+      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path7);
     };
   }
   function toMatcherFunction(ignoreEntry) {
@@ -199978,14 +199978,14 @@ var require_recursive_readdir = __commonJS((exports, module) => {
       return patternMatcher(ignoreEntry);
     }
   }
-  function readdir3(path6, ignores, callback) {
+  function readdir3(path7, ignores, callback) {
     if (typeof ignores == "function") {
       callback = ignores;
       ignores = [];
     }
     if (!callback) {
       return new Promise(function(resolve3, reject) {
-        readdir3(path6, ignores || [], function(err, data) {
+        readdir3(path7, ignores || [], function(err, data) {
           if (err) {
             reject(err);
           } else {
@@ -199996,7 +199996,7 @@ var require_recursive_readdir = __commonJS((exports, module) => {
     }
     ignores = ignores.map(toMatcherFunction);
     var list = [];
-    fs4.readdir(path6, function(err, files) {
+    fs4.readdir(path7, function(err, files) {
       if (err) {
         return callback(err);
       }
@@ -200005,7 +200005,7 @@ var require_recursive_readdir = __commonJS((exports, module) => {
         return callback(null, list);
       }
       files.forEach(function(file) {
-        var filePath = p.join(path6, file);
+        var filePath = p.join(path7, file);
         fs4.stat(filePath, function(_err, stats) {
           if (_err) {
             return callback(_err);
@@ -200851,8 +200851,8 @@ var require_uri_all = __commonJS((exports, module) => {
           wsComponents.secure = undefined;
         }
         if (wsComponents.resourceName) {
-          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path11 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
-          wsComponents.path = path11 && path11 !== "/" ? path11 : undefined;
+          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path12 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
+          wsComponents.path = path12 && path12 !== "/" ? path12 : undefined;
           wsComponents.query = query;
           wsComponents.resourceName = undefined;
         }
@@ -201245,12 +201245,12 @@ var require_util13 = __commonJS((exports, module) => {
     return "'" + escapeQuotes(str) + "'";
   }
   function getPathExpr(currentPath, expr, jsonPointers, isNumber2) {
-    var path11 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
-    return joinPaths(currentPath, path11);
+    var path12 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
+    return joinPaths(currentPath, path12);
   }
   function getPath(currentPath, prop, jsonPointers) {
-    var path11 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
-    return joinPaths(currentPath, path11);
+    var path12 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
+    return joinPaths(currentPath, path12);
   }
   var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
   var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
@@ -207304,11 +207304,11 @@ var require_ast = __commonJS((exports, module) => {
       helperExpression: function helperExpression(node) {
         return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
       },
-      scopedId: function scopedId(path11) {
-        return /^\.|this\b/.test(path11.original);
+      scopedId: function scopedId(path12) {
+        return /^\.|this\b/.test(path12.original);
       },
-      simpleId: function simpleId(path11) {
-        return path11.parts.length === 1 && !AST.helpers.scopedId(path11) && !path11.depth;
+      simpleId: function simpleId(path12) {
+        return path12.parts.length === 1 && !AST.helpers.scopedId(path12) && !path12.depth;
       }
     }
   };
@@ -208368,12 +208368,12 @@ var require_helpers3 = __commonJS((exports) => {
       loc
     };
   }
-  function prepareMustache(path11, params, hash, open2, strip, locInfo) {
+  function prepareMustache(path12, params, hash, open2, strip, locInfo) {
     var escapeFlag = open2.charAt(3) || open2.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
     var decorator = /\*/.test(open2);
     return {
       type: decorator ? "Decorator" : "MustacheStatement",
-      path: path11,
+      path: path12,
       params,
       hash,
       escaped,
@@ -208637,9 +208637,9 @@ var require_compiler = __commonJS((exports) => {
     },
     DecoratorBlock: function DecoratorBlock(decorator) {
       var program = decorator.program && this.compileProgram(decorator.program);
-      var params = this.setupFullMustacheParams(decorator, program, undefined), path11 = decorator.path;
+      var params = this.setupFullMustacheParams(decorator, program, undefined), path12 = decorator.path;
       this.useDecorators = true;
-      this.opcode("registerDecorator", params.length, path11.original);
+      this.opcode("registerDecorator", params.length, path12.original);
     },
     PartialStatement: function PartialStatement(partial) {
       this.usePartial = true;
@@ -208702,46 +208702,46 @@ var require_compiler = __commonJS((exports) => {
       }
     },
     ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse) {
-      var path11 = sexpr.path, name = path11.parts[0], isBlock = program != null || inverse != null;
-      this.opcode("getContext", path11.depth);
+      var path12 = sexpr.path, name = path12.parts[0], isBlock = program != null || inverse != null;
+      this.opcode("getContext", path12.depth);
       this.opcode("pushProgram", program);
       this.opcode("pushProgram", inverse);
-      path11.strict = true;
-      this.accept(path11);
+      path12.strict = true;
+      this.accept(path12);
       this.opcode("invokeAmbiguous", name, isBlock);
     },
     simpleSexpr: function simpleSexpr(sexpr) {
-      var path11 = sexpr.path;
-      path11.strict = true;
-      this.accept(path11);
+      var path12 = sexpr.path;
+      path12.strict = true;
+      this.accept(path12);
       this.opcode("resolvePossibleLambda");
     },
     helperSexpr: function helperSexpr(sexpr, program, inverse) {
-      var params = this.setupFullMustacheParams(sexpr, program, inverse), path11 = sexpr.path, name = path11.parts[0];
+      var params = this.setupFullMustacheParams(sexpr, program, inverse), path12 = sexpr.path, name = path12.parts[0];
       if (this.options.knownHelpers[name]) {
         this.opcode("invokeKnownHelper", params.length, name);
       } else if (this.options.knownHelpersOnly) {
         throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
       } else {
-        path11.strict = true;
-        path11.falsy = true;
-        this.accept(path11);
-        this.opcode("invokeHelper", params.length, path11.original, _ast2["default"].helpers.simpleId(path11));
+        path12.strict = true;
+        path12.falsy = true;
+        this.accept(path12);
+        this.opcode("invokeHelper", params.length, path12.original, _ast2["default"].helpers.simpleId(path12));
       }
     },
-    PathExpression: function PathExpression(path11) {
-      this.addDepth(path11.depth);
-      this.opcode("getContext", path11.depth);
-      var name = path11.parts[0], scoped = _ast2["default"].helpers.scopedId(path11), blockParamId = !path11.depth && !scoped && this.blockParamIndex(name);
+    PathExpression: function PathExpression(path12) {
+      this.addDepth(path12.depth);
+      this.opcode("getContext", path12.depth);
+      var name = path12.parts[0], scoped = _ast2["default"].helpers.scopedId(path12), blockParamId = !path12.depth && !scoped && this.blockParamIndex(name);
       if (blockParamId) {
-        this.opcode("lookupBlockParam", blockParamId, path11.parts);
+        this.opcode("lookupBlockParam", blockParamId, path12.parts);
       } else if (!name) {
         this.opcode("pushContext");
-      } else if (path11.data) {
+      } else if (path12.data) {
         this.options.data = true;
-        this.opcode("lookupData", path11.depth, path11.parts, path11.strict);
+        this.opcode("lookupData", path12.depth, path12.parts, path12.strict);
       } else {
-        this.opcode("lookupOnContext", path11.parts, path11.falsy, path11.strict, scoped);
+        this.opcode("lookupOnContext", path12.parts, path12.falsy, path12.strict, scoped);
       }
     },
     StringLiteral: function StringLiteral(string2) {
@@ -209085,16 +209085,16 @@ var require_util14 = __commonJS((exports) => {
   }
   exports.urlGenerate = urlGenerate;
   function normalize2(aPath) {
-    var path11 = aPath;
+    var path12 = aPath;
     var url2 = urlParse(aPath);
     if (url2) {
       if (!url2.path) {
         return aPath;
       }
-      path11 = url2.path;
+      path12 = url2.path;
     }
-    var isAbsolute3 = exports.isAbsolute(path11);
-    var parts = path11.split(/\/+/);
+    var isAbsolute3 = exports.isAbsolute(path12);
+    var parts = path12.split(/\/+/);
     for (var part, up = 0, i = parts.length - 1;i >= 0; i--) {
       part = parts[i];
       if (part === ".") {
@@ -209111,15 +209111,15 @@ var require_util14 = __commonJS((exports) => {
         }
       }
     }
-    path11 = parts.join("/");
-    if (path11 === "") {
-      path11 = isAbsolute3 ? "/" : ".";
+    path12 = parts.join("/");
+    if (path12 === "") {
+      path12 = isAbsolute3 ? "/" : ".";
     }
     if (url2) {
-      url2.path = path11;
+      url2.path = path12;
       return urlGenerate(url2);
     }
-    return path11;
+    return path12;
   }
   exports.normalize = normalize2;
   function join9(aRoot, aPath) {
@@ -211676,8 +211676,8 @@ var require_printer = __commonJS((exports) => {
     return this.accept(sexpr.path) + " " + params + hash;
   };
   PrintVisitor.prototype.PathExpression = function(id) {
-    var path11 = id.parts.join("/");
-    return (id.data ? "@" : "") + "PATH:" + path11;
+    var path12 = id.parts.join("/");
+    return (id.data ? "@" : "") + "PATH:" + path12;
   };
   PrintVisitor.prototype.StringLiteral = function(string2) {
     return '"' + string2.value + '"';
@@ -211754,9 +211754,7 @@ var getLogLevel = () => {
 };
 var logger = import_winston.default.createLogger({
   level: getLogLevel(),
-  format: isTelemetryEnabled ? import_winston.default.format.combine(import_winston.default.format.uncolorize(), import_winston.default.format.timestamp(), import_winston.default.format.metadata({
-    fillExcept: ["message", "level", "timestamp"]
-  }), import_winston.default.format.json()) : import_winston.default.format.combine(import_winston.default.format.colorize(), import_winston.default.format.simple()),
+  format: isTelemetryEnabled ? import_winston.default.format.combine(import_winston.default.format.uncolorize(), import_winston.default.format.timestamp(), import_winston.default.format.errors({ stack: true }), import_winston.default.format.json()) : import_winston.default.format.combine(import_winston.default.format.colorize(), import_winston.default.format.simple()),
   transports: [new import_winston.default.transports.Console]
 });
 function extractTraceIdFromTraceparent(traceparent) {
@@ -216941,13 +216939,13 @@ class StreamableHTTPServerTransport {
 }
 
 // src/server.ts
-var import_body_parser = __toESM(require_body_parser(), 1);
+var import_body_parser2 = __toESM(require_body_parser(), 1);
 var import_cors = __toESM(require_lib7(), 1);
 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 fileURLToPath2 } from "url";
+import * as path12 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/controller/compile.controller.ts
 class CompileController {
@@ -216998,6 +216996,8 @@ function internalErrorToHttpError(error) {
     return httpError(400, error.message);
   } else if (error instanceof ConnectionNotFoundError) {
     return httpError(404, error.message);
+  } else if (error instanceof ConnectionAuthError) {
+    return httpError(422, error.message);
   } else if (error instanceof ModelCompilationError) {
     return httpError(424, error.message);
   } else if (error instanceof ConnectionError) {
@@ -217064,6 +217064,12 @@ class ConnectionError extends Error {
   }
 }
 
+class ConnectionAuthError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+
 class ModelCompilationError extends Error {
   constructor(error) {
     super(error.message);
@@ -220380,6 +220386,63 @@ var {
 import fs from "fs/promises";
 import path2 from "path";
 
+// src/pg_helpers.ts
+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/service/connection_config.ts
 import { createPrivateKey } from "crypto";
 import path from "path";
@@ -220563,7 +220626,7 @@ function validateConnectionShape(connection) {
       {
         const attached = connection.duckdbConnection.attachedDatabases ?? [];
         if (attached.length === 0) {
-          throw new Error("DuckDB connection must have at least one attached database");
+          throw new Error(`DuckDB connection "${connection.name}" has no attached databases. Add at least one foreign database (BigQuery, Snowflake, Postgres, GCS, S3, Azure) to attachedDatabases, or remove this connection entirely — each package already gets a per-package DuckDB sandbox named "duckdb" automatically.`);
         }
       }
       break;
@@ -220636,7 +220699,7 @@ function assembleEnvironmentConnections(connections = [], environmentPath = "")
       continue;
     }
     if (connection.name === "duckdb") {
-      throw new Error("DuckDB connection name cannot be 'duckdb'; it is reserved for Publisher package sandboxes.");
+      throw new Error("Connection name 'duckdb' is reserved for per-package sandboxes. Choose a different name for environment-level DuckDB connections (e.g. 'shared_duckdb').");
     }
     processedConnections.add(connection.name);
     validateDuckdbApiSurface(connection);
@@ -221005,13 +221068,13 @@ async function attachDuckLake(connection, dbName, ducklakeConfig) {
   }
   const pg = ducklakeConfig.catalog.postgresConnection;
   const pgConnString = buildPgConnectionString(pg);
-  logger.info(`pgConnString: ${pgConnString}`);
+  logger.info(`pgConnString: ${redactPgSecrets(pgConnString)}`);
   const escapedPgConnString = escapeSQL(pgConnString);
-  logger.info(`Final escaped connection string: ${escapedPgConnString}`);
+  logger.info(`Final escaped connection string: ${redactPgSecrets(escapedPgConnString)}`);
   const escapedBucketUrl = escapeSQL(ducklakeConfig.storage.bucketUrl);
   logger.info(`escapedBucketUrl: ${escapedBucketUrl}`);
   const attachCommand = `ATTACH OR REPLACE 'ducklake:postgres:${escapedPgConnString}' AS ${dbName} (DATA_PATH '${escapedBucketUrl}', OVERRIDE_DATA_PATH true, READ_ONLY true);`;
-  logger.info(`Attaching DuckLake database using command: ${attachCommand}`);
+  logger.info(`Attaching DuckLake database using command: ${redactPgSecrets(attachCommand)}`);
   try {
     await connection.runSQL(attachCommand);
     logger.info(`Successfully attached DuckLake database in READ_ONLY mode: ${dbName}`);
@@ -222783,7 +222846,7 @@ function validateAzureAttachedDatabases(connectionConfig) {
 }
 function validateAdminAuthoredConnection(connectionName, connectionConfig) {
   if (connectionName === "duckdb" || connectionConfig.name === "duckdb") {
-    throw new BadRequestError("DuckDB connection name cannot be 'duckdb'; it is reserved for Publisher package sandboxes.");
+    throw new BadRequestError("Connection name 'duckdb' is reserved for per-package sandboxes. Choose a different name for environment-level DuckDB connections (e.g. 'shared_duckdb').");
   }
   try {
     validateDuckdbApiSurface(connectionConfig);
@@ -224801,7 +224864,7 @@ function watch(paths, options = {}) {
 var esm_default = { watch, FSWatcher };
 
 // src/controller/watch-mode.controller.ts
-import path10 from "path";
+import path11 from "path";
 
 // src/service/environment_store.ts
 var import_client_s32 = __toESM(require_dist_cjs75(), 1);
@@ -225019,7 +225082,7 @@ class Mutex {
 // src/service/environment_store.ts
 import crypto4 from "crypto";
 import * as fs7 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist11(), 1);
@@ -229007,6 +229070,25 @@ import { Writable } from "stream";
 // src/config.ts
 import fs2 from "fs";
 import path4 from "path";
+import { fileURLToPath } from "url";
+var BUNDLED_DEFAULT_CONFIG_PATH = path4.join(path4.dirname(fileURLToPath(import.meta.url)), "default-publisher.config.json");
+function resolvePublisherConfigPath(serverRoot) {
+  const explicitPath = process.env.PUBLISHER_CONFIG_PATH;
+  if (explicitPath && explicitPath.length > 0) {
+    if (!fs2.existsSync(explicitPath)) {
+      return null;
+    }
+    return { path: explicitPath, isBundledDefault: false };
+  }
+  const serverRootPath = path4.join(serverRoot, PUBLISHER_CONFIG_NAME);
+  if (fs2.existsSync(serverRootPath)) {
+    return { path: serverRootPath, isBundledDefault: false };
+  }
+  if (process.env.PUBLISHER_USE_BUNDLED_DEFAULT === "true" && fs2.existsSync(BUNDLED_DEFAULT_CONFIG_PATH)) {
+    return { path: BUNDLED_DEFAULT_CONFIG_PATH, isBundledDefault: true };
+  }
+  return null;
+}
 function substituteEnvVars(value) {
   const envVarPattern = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
   return value.replace(envVarPattern, (_match, varName) => {
@@ -229034,13 +229116,20 @@ function processConfigValue(value) {
   return value;
 }
 var getPublisherConfig = (serverRoot) => {
-  const publisherConfigPath = path4.join(serverRoot, PUBLISHER_CONFIG_NAME);
-  if (!fs2.existsSync(publisherConfigPath)) {
+  const resolved = resolvePublisherConfigPath(serverRoot);
+  if (!resolved) {
+    if (process.env.PUBLISHER_CONFIG_PATH && process.env.PUBLISHER_CONFIG_PATH.length > 0) {
+      logger.error(`--config path not found: ${process.env.PUBLISHER_CONFIG_PATH}. Using default empty config.`);
+    }
     return {
       frozenConfig: false,
       environments: []
     };
   }
+  const publisherConfigPath = resolved.path;
+  if (resolved.isBundledDefault) {
+    logger.info(`No publisher.config.json found at ${path4.join(serverRoot, PUBLISHER_CONFIG_NAME)}; falling back to bundled DuckDB-only default. Pass --config <path> or place a config in the server root to override.`);
+  }
   let rawConfig;
   try {
     const fileContent = fs2.readFileSync(publisherConfigPath, "utf8");
@@ -229058,6 +229147,10 @@ var getPublisherConfig = (serverRoot) => {
     };
   }
   const processedConfig = processConfigValue(rawConfig);
+  if (processedConfig && typeof processedConfig === "object" && !("environments" in processedConfig) && "projects" in processedConfig) {
+    logger.warn(`${PUBLISHER_CONFIG_NAME} uses deprecated "projects" key; rename to "environments".`);
+    processedConfig.environments = processedConfig.projects;
+  }
   if (processedConfig && typeof processedConfig === "object" && "environments" in processedConfig && processedConfig.environments && typeof processedConfig.environments === "object" && !Array.isArray(processedConfig.environments)) {
     logger.error(`Invalid ${PUBLISHER_CONFIG_NAME}: the "environments" field must be a JSON array. Using default empty config.`);
     return {
@@ -229181,6 +229274,15 @@ function markReady() {
     logger.error("Service is already draining - cannot mark as ready");
   }
 }
+function markDegraded() {
+  if (operationalState !== "draining") {
+    operationalState = "degraded";
+    ready = false;
+    logger.warn("Service marked as degraded; one or more environments failed to initialize. Readiness probe will fail until the config is fixed and the process restarts.");
+  } else {
+    logger.error("Service is already draining - cannot mark as degraded");
+  }
+}
 function markNotReady() {
   ready = false;
   logger.info("Service marked as not ready - readiness probe will fail");
@@ -230075,6 +230177,7 @@ async function initializeSchema(db, force = false) {
     logger.info("Reinitializing database schema dropping and recreating all tables");
     await dropAllTables(db);
   } else {
+    await dropLegacyProjectSchema(db);
     logger.info("Creating database schema for the first time...");
   }
   await db.run(`
@@ -230152,6 +230255,27 @@ async function initializeSchema(db, force = false) {
   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",
+  "materializations",
+  "packages",
+  "connections",
+  "projects"
+];
+async function dropLegacyProjectSchema(db) {
+  const legacy = await db.all("SELECT name FROM sqlite_master WHERE type='table' AND name='projects'");
+  if (!legacy || legacy.length === 0) {
+    return;
+  }
+  logger.warn("Detected legacy 'projects' schema. Dropping legacy tables; existing environments/packages/connections/materializations data will be lost. Re-create them via the API after upgrade.");
+  for (const table of LEGACY_TABLES_DROP_ORDER) {
+    try {
+      await db.run(`DROP TABLE IF EXISTS ${table}`);
+    } catch (err) {
+      logger.warn(`Failed to drop legacy table ${table}:`, err);
+    }
+  }
+}
 async function dropAllTables(db) {
   const tables = [
     "build_manifests",
@@ -230267,6 +230391,7 @@ class StorageManager {
   defaultManifestStore = null;
   environmentManifestStores = new Map;
   attachedCatalogs = new Map;
+  duckLakeAttachMutex = new Mutex;
   config;
   constructor(config) {
     this.config = config;
@@ -230304,12 +230429,15 @@ class StorageManager {
       throw new Error("Storage not initialized. Call initialize() first.");
     }
     const key = configKey(config);
-    let catalogName = this.attachedCatalogs.get(key);
-    if (!catalogName) {
-      catalogName = catalogNameForConfig(config);
-      await this.attachDuckLakeCatalog(config, catalogName);
-      this.attachedCatalogs.set(key, catalogName);
-    }
+    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);
@@ -230326,9 +230454,13 @@ class StorageManager {
     if (isPostgres) {
       await connection.run("INSTALL postgres; LOAD postgres;");
     }
-    const escapedCatalogUrl = escapeSQL2(config.catalogUrl);
+    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;");
+    }
     let attachCmd = `ATTACH 'ducklake:${escapedCatalogUrl}' AS ${catalogName}`;
     const attachOpts = [
       `DATA_PATH '${escapedDataPath}'`,
@@ -230338,8 +230470,22 @@ class StorageManager {
       attachOpts.push("OVERRIDE_DATA_PATH true");
     }
     attachCmd += ` (${attachOpts.join(", ")});`;
-    logger.info(`Attaching DuckLake manifest catalog: ${attachCmd}`);
-    await connection.run(attachCmd);
+    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) {
@@ -230378,26 +230524,30 @@ class StorageManager {
 // src/service/environment.ts
 import { MalloyError as MalloyError3, Runtime as Runtime2 } from "@malloydata/malloy";
 import * as fs6 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 
 // src/utils.ts
 import * as fs3 from "fs";
-import { fileURLToPath } from "url";
+import * as path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var URL_READER = {
   readURL: (url2) => {
-    let path6 = url2.toString();
+    let path7 = url2.toString();
     if (url2.protocol == "file:") {
-      path6 = fileURLToPath(url2);
+      path7 = fileURLToPath2(url2);
     }
-    return fs3.promises.readFile(path6, "utf8");
+    return fs3.promises.readFile(path7, "utf8");
   }
 };
+function ignoreDotfiles(file) {
+  return path6.basename(file).startsWith(".");
+}
 
 // src/service/package.ts
 var import_api3 = __toESM(require_src(), 1);
 var import_recursive_readdir = __toESM(require_recursive_readdir(), 1);
 import * as fs5 from "fs/promises";
-import * as path7 from "path";
+import * as path8 from "path";
 import { DuckDBConnection as DuckDBConnection3 } from "@malloydata/db-duckdb";
 import"@malloydata/db-duckdb/native";
 import {
@@ -230425,7 +230575,7 @@ import {
 } from "@malloydata/malloy-sql";
 import * as fs4 from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import * as path6 from "path";
+import * as path7 from "path";
 
 // src/data_styles.ts
 function compileDataStyles(styles) {
@@ -231036,7 +231186,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
     };
   }
   static async getModelRuntime(packagePath, modelPath, malloyConfig, options) {
-    const fullModelPath = path6.join(packagePath, modelPath);
+    const fullModelPath = path7.join(packagePath, modelPath);
     try {
       if (!(await fs4.stat(fullModelPath)).isFile()) {
         throw new ModelNotFoundError(`${modelPath} is not a file.`);
@@ -231249,7 +231399,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
     return this.modelType;
   }
   async getFileText(packagePath) {
-    const fullPath = path6.join(packagePath, this.modelPath);
+    const fullPath = path7.join(packagePath, this.modelPath);
     try {
       return await fs4.readFile(fullPath, "utf8");
     } catch {
@@ -231484,17 +231634,17 @@ class Package {
   static async getModelPaths(packagePath) {
     let files = undefined;
     try {
-      files = await import_recursive_readdir.default(packagePath);
+      files = await import_recursive_readdir.default(packagePath, [ignoreDotfiles]);
     } catch (error) {
       logger.error(error);
       throw new PackageNotFoundError(`Package config for ${packagePath} does not exist.`);
     }
     return files.map((fullPath) => {
-      return path7.relative(packagePath, fullPath).replace(/\\/g, "/");
+      return path8.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => modelPath.endsWith(MODEL_FILE_SUFFIX) || modelPath.endsWith(NOTEBOOK_FILE_SUFFIX));
   }
   static async validatePackageManifestExistsOrThrowError(packagePath) {
-    const packageConfigPath = path7.join(packagePath, PACKAGE_MANIFEST_NAME);
+    const packageConfigPath = path8.join(packagePath, PACKAGE_MANIFEST_NAME);
     try {
       await fs5.stat(packageConfigPath);
     } catch {
@@ -231503,7 +231653,7 @@ class Package {
     }
   }
   static async readPackageConfig(packagePath) {
-    const packageConfigPath = path7.join(packagePath, PACKAGE_MANIFEST_NAME);
+    const packageConfigPath = path8.join(packagePath, PACKAGE_MANIFEST_NAME);
     const packageConfigContents = await fs5.readFile(packageConfigPath);
     const packageManifest = JSON.parse(packageConfigContents.toString());
     return {
@@ -231522,14 +231672,13 @@ class Package {
     }));
   }
   static async getDatabasePaths(packagePath) {
-    let files = undefined;
-    files = await import_recursive_readdir.default(packagePath);
+    const files = await import_recursive_readdir.default(packagePath, [ignoreDotfiles]);
     return files.map((fullPath) => {
-      return path7.relative(packagePath, fullPath).replace(/\\/g, "/");
+      return path8.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => modelPath.endsWith(".parquet") || modelPath.endsWith(".csv"));
   }
   static async getDatabaseInfo(packagePath, databasePath) {
-    const fullPath = path7.join(packagePath, databasePath);
+    const fullPath = path8.join(packagePath, databasePath);
     const runtime = new ConnectionRuntime({
       urlReader: new EmptyURLReader,
       connections: [new DuckDBConnection3("duckdb")]
@@ -231586,7 +231735,7 @@ class Environment {
   async writeEnvironmentReadme(readme) {
     if (readme === undefined)
       return;
-    const readmePath = path8.join(this.environmentPath, "README.md");
+    const readmePath = path9.join(this.environmentPath, "README.md");
     try {
       await fs6.promises.writeFile(readmePath, readme, "utf-8");
       logger.info(`Updated README.md for environment ${this.environmentName}`);
@@ -231633,7 +231782,7 @@ class Environment {
   async reloadEnvironmentMetadata() {
     let readme = "";
     try {
-      readme = (await fs6.promises.readFile(path8.join(this.environmentPath, README_NAME))).toString();
+      readme = (await fs6.promises.readFile(path9.join(this.environmentPath, README_NAME))).toString();
     } catch {}
     this.metadata = {
       ...this.metadata,
@@ -231644,10 +231793,10 @@ class Environment {
     return this.metadata;
   }
   async compileSource(packageName, modelName, source, includeSql = false) {
-    const modelDir = path8.dirname(path8.join(this.environmentPath, packageName, modelName));
-    const virtualUri = `file://${path8.join(modelDir, "__compile_check.malloy")}`;
+    const modelDir = path9.dirname(path9.join(this.environmentPath, packageName, modelName));
+    const virtualUri = `file://${path9.join(modelDir, "__compile_check.malloy")}`;
     const virtualUrl = new URL(virtualUri);
-    const modelPath = path8.join(this.environmentPath, packageName, modelName);
+    const modelPath = path9.join(this.environmentPath, packageName, modelName);
     let modelContent = "";
     try {
       modelContent = await fs6.promises.readFile(modelPath, "utf8");
@@ -231759,24 +231908,30 @@ ${source}` : source;
       throw error;
     }
   }
+  getOrCreatePackageMutex(packageName) {
+    let packageMutex = this.packageMutexes.get(packageName);
+    if (packageMutex === undefined) {
+      packageMutex = new Mutex;
+      this.packageMutexes.set(packageName, packageMutex);
+    }
+    return packageMutex;
+  }
   async getPackage(packageName, reload = false) {
     const _package = this.packages.get(packageName);
     if (_package !== undefined && !reload) {
       return _package;
     }
-    let packageMutex = this.packageMutexes.get(packageName);
-    if (packageMutex?.isLocked()) {
+    const packageMutex = this.getOrCreatePackageMutex(packageName);
+    if (packageMutex.isLocked()) {
       logger.debug(`Package ${packageName} is being loaded, waiting for unlock...`);
       await packageMutex.waitForUnlock();
       logger.debug(`Package ${packageName} unlocked`);
       const existingPackage = this.packages.get(packageName);
-      if (existingPackage) {
+      if (existingPackage !== undefined && !reload) {
         logger.debug(`Package ${packageName} loaded by another request`);
         return existingPackage;
       }
     }
-    packageMutex = new Mutex;
-    this.packageMutexes.set(packageName, packageMutex);
     return packageMutex.runExclusive(async () => {
       const existingPackage = this.packages.get(packageName);
       if (existingPackage !== undefined && !reload) {
@@ -231785,7 +231940,7 @@ ${source}` : source;
       this.setPackageStatus(packageName, "loading" /* LOADING */);
       try {
         logger.debug(`Loading package ${packageName}...`);
-        const packagePath = path8.join(this.environmentPath, packageName);
+        const packagePath = path9.join(this.environmentPath, packageName);
         const _package2 = await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig);
         if (existingPackage !== undefined && reload) {
           this.retireConnectionGeneration(`package ${packageName}`, () => existingPackage.getMalloyConfig().releaseConnections());
@@ -231803,7 +231958,7 @@ ${source}` : source;
     });
   }
   async addPackage(packageName) {
-    const packagePath = path8.join(this.environmentPath, packageName);
+    const packagePath = path9.join(this.environmentPath, packageName);
     if (!await fs6.promises.access(packagePath).then(() => true).catch(() => false) || !(await fs6.promises.stat(packagePath))?.isDirectory()) {
       throw new PackageNotFoundError(`Package ${packageName} not found`);
     }
@@ -231811,20 +231966,35 @@ ${source}` : source;
       packagePath,
       malloyConfig: this.malloyConfig.malloyConfig
     });
-    this.setPackageStatus(packageName, "loading" /* LOADING */);
-    try {
-      this.packages.set(packageName, await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig));
-    } catch (error) {
-      logger.error("Error adding package", { error });
-      this.deletePackageStatus(packageName);
-      throw error;
+    const packageMutex = this.getOrCreatePackageMutex(packageName);
+    if (packageMutex.isLocked()) {
+      logger.debug(`Package ${packageName} is being loaded, waiting before addPackage...`);
+      await packageMutex.waitForUnlock();
+      const alreadyLoaded = this.packages.get(packageName);
+      if (alreadyLoaded !== undefined) {
+        return alreadyLoaded;
+      }
     }
-    this.setPackageStatus(packageName, "serving" /* SERVING */);
-    return this.packages.get(packageName);
+    return packageMutex.runExclusive(async () => {
+      const existingPackage = this.packages.get(packageName);
+      if (existingPackage !== undefined) {
+        return existingPackage;
+      }
+      this.setPackageStatus(packageName, "loading" /* LOADING */);
+      try {
+        this.packages.set(packageName, await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig));
+      } catch (error) {
+        logger.error("Error adding package", { error });
+        this.deletePackageStatus(packageName);
+        throw error;
+      }
+      this.setPackageStatus(packageName, "serving" /* SERVING */);
+      return this.packages.get(packageName);
+    });
   }
   async writePackageManifest(packageName, metadata) {
-    const packagePath = path8.join(this.environmentPath, packageName);
-    const manifestPath = path8.join(packagePath, "publisher.json");
+    const packagePath = path9.join(this.environmentPath, packageName);
+    const manifestPath = path9.join(packagePath, "publisher.json");
     try {
       let existingManifest = {};
       try {
@@ -231896,7 +232066,7 @@ ${source}` : source;
     }
     await _package.getMalloyConfig().releaseConnections();
     try {
-      await fs6.promises.rm(path8.join(this.environmentPath, packageName), {
+      await fs6.promises.rm(path9.join(this.environmentPath, packageName), {
         recursive: true,
         force: true
       });
@@ -231960,7 +232130,7 @@ ${source}` : source;
     };
   }
   async deleteDuckDBConnection(connectionName) {
-    const duckdbPath = path8.join(this.environmentPath, `${connectionName}.duckdb`);
+    const duckdbPath = path9.join(this.environmentPath, `${connectionName}.duckdb`);
     try {
       await fs6.promises.rm(duckdbPath, { force: true });
       logger.info(`Removed DuckDB connection file ${connectionName} from environment ${this.environmentName}`);
@@ -232029,6 +232199,7 @@ class EnvironmentStore {
   publisherConfigIsFrozen;
   finishedInitialization;
   isInitialized = false;
+  failedEnvironments = [];
   storageManager;
   s3Client = new import_client_s32.S3({
     followRegionRedirects: true
@@ -232040,7 +232211,7 @@ class EnvironmentStore {
     const storageConfig = {
       type: "duckdb",
       duckdb: {
-        path: path9.join(serverRootPath, "publisher.db")
+        path: path10.join(serverRootPath, "publisher.db")
       }
     };
     this.storageManager = new StorageManager(storageConfig);
@@ -232061,6 +232232,10 @@ class EnvironmentStore {
   logEnvironmentInitializationError(environmentName, error) {
     const label = environmentName ? ` "${environmentName}"` : "";
     logger.error(`Error initializing environment${label}; skipping environment`, this.extractErrorDataFromError(error));
+    this.failedEnvironments.push({
+      name: environmentName ?? "<unknown>",
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
   async initialize() {
     const reInit = process.env.INITIALIZE_STORAGE === "true";
@@ -232123,7 +232298,11 @@ class EnvironmentStore {
         }
       }
       this.isInitialized = true;
-      markReady();
+      if (this.failedEnvironments.length > 0) {
+        markDegraded();
+      } else {
+        markReady();
+      }
       const initializationDuration = performance.now() - initialTime;
       logger.info(`Environment store successfully initialized in ${formatDuration(initializationDuration)}`);
     } catch (error) {
@@ -232327,7 +232506,7 @@ class EnvironmentStore {
     const reInit = process.env.INITIALIZE_STORAGE === "true";
     await fs7.promises.mkdir(this.serverRootPath, { recursive: true });
     if (reInit) {
-      const uploadDocsPath2 = path9.join(this.serverRootPath, PUBLISHER_DATA_DIR);
+      const uploadDocsPath2 = path10.join(this.serverRootPath, PUBLISHER_DATA_DIR);
       logger.info(`Reinitialization mode: Cleaning up upload documents path ${uploadDocsPath2}`);
       try {
         await fs7.promises.rm(uploadDocsPath2, {
@@ -232344,7 +232523,7 @@ class EnvironmentStore {
     } else {
       logger.info(`Using existing publisher path`);
     }
-    const uploadDocsPath = path9.join(this.serverRootPath, PUBLISHER_DATA_DIR);
+    const uploadDocsPath = path10.join(this.serverRootPath, PUBLISHER_DATA_DIR);
     await fs7.promises.mkdir(uploadDocsPath, { recursive: true });
   }
   async listEnvironments(skipInitializationCheck = false) {
@@ -232359,7 +232538,12 @@ class EnvironmentStore {
       environments: [],
       initialized: this.isInitialized,
       frozenConfig: isPublisherConfigFrozen(this.serverRootPath),
-      operationalState: getOperationalState()
+      operationalState: getOperationalState(),
+      ...this.failedEnvironments.length > 0 && {
+        failedEnvironments: [
+          ...this.failedEnvironments
+        ]
+      }
     };
     const environments = await this.listEnvironments(true);
     await Promise.all(environments.map(async (environment) => {
@@ -232576,12 +232760,12 @@ class EnvironmentStore {
     const absoluteEnvironmentPath = `${this.serverRootPath}/${PUBLISHER_DATA_DIR}/${environmentName}`;
     await fs7.promises.mkdir(absoluteEnvironmentPath, { recursive: true });
     if (environment.readme) {
-      await fs7.promises.writeFile(path9.join(absoluteEnvironmentPath, "README.md"), environment.readme);
+      await fs7.promises.writeFile(path10.join(absoluteEnvironmentPath, "README.md"), environment.readme);
     }
     return absoluteEnvironmentPath;
   }
   isLocalPath(location) {
-    return location.startsWith("./") || location.startsWith("../") || location.startsWith("~/") || location.startsWith("/") || path9.isAbsolute(location);
+    return location.startsWith("./") || location.startsWith("../") || location.startsWith("~/") || location.startsWith("/") || path10.isAbsolute(location);
   }
   isGitHubURL(location) {
     return location.startsWith("https://github.com/") || location.startsWith("git@github.com:");
@@ -232637,7 +232821,7 @@ class EnvironmentStore {
             if (githubInfo && githubInfo.packagePath) {
               const subPathMatch = _package.location.match(/\/tree\/[^/]+\/(.+)$/);
               if (subPathMatch) {
-                sourcePath = path9.join(tempDownloadPath, subPathMatch[1]);
+                sourcePath = path10.join(tempDownloadPath, subPathMatch[1]);
               } else {
                 sourcePath = tempDownloadPath;
               }
@@ -232648,7 +232832,7 @@ class EnvironmentStore {
             if (this.isLocalPath(_package.location)) {
               sourcePath = _package.location;
             } else {
-              sourcePath = path9.join(tempDownloadPath, groupedLocation);
+              sourcePath = path10.join(tempDownloadPath, groupedLocation);
             }
           }
           const sourceExists = await fs7.promises.access(sourcePath).then(() => true).catch(() => false);
@@ -232724,7 +232908,7 @@ class EnvironmentStore {
       }
     }
     if (this.isLocalPath(location)) {
-      const packagePath = path9.isAbsolute(location) ? location : path9.join(this.serverRootPath, location);
+      const packagePath = path10.isAbsolute(location) ? location : path10.join(this.serverRootPath, location);
       try {
         logger.info(`Mounting local directory at "${packagePath}" to "${targetPath}"`);
         await this.mountLocalDirectory(packagePath, targetPath, environmentName, packageName);
@@ -232778,11 +232962,11 @@ class EnvironmentStore {
     }
     await Promise.all(files.map(async (file) => {
       const relativeFilePath = file.name.replace(prefix, "");
-      const absoluteFilePath = isCompressedFile ? absoluteDirPath : path9.join(absoluteDirPath, relativeFilePath);
+      const absoluteFilePath = isCompressedFile ? absoluteDirPath : path10.join(absoluteDirPath, relativeFilePath);
       if (file.name.endsWith("/")) {
         return;
       }
-      await fs7.promises.mkdir(path9.dirname(absoluteFilePath), {
+      await fs7.promises.mkdir(path10.dirname(absoluteFilePath), {
         recursive: true
       });
       return fs7.promises.writeFile(absoluteFilePath, await file.download());
@@ -232798,7 +232982,7 @@ class EnvironmentStore {
     const prefix = prefixParts.join("/");
     if (isCompressedFile) {
       const zipFilePath = `${absoluteDirPath}.zip`;
-      await fs7.promises.mkdir(path9.dirname(zipFilePath), {
+      await fs7.promises.mkdir(path10.dirname(zipFilePath), {
         recursive: true
       });
       const command = new import_client_s32.GetObjectCommand({
@@ -232837,8 +233021,8 @@ class EnvironmentStore {
       if (!relativeFilePath || relativeFilePath.endsWith("/")) {
         return;
       }
-      const absoluteFilePath = path9.join(absoluteDirPath, relativeFilePath);
-      await fs7.promises.mkdir(path9.dirname(absoluteFilePath), {
+      const absoluteFilePath = path10.join(absoluteDirPath, relativeFilePath);
+      await fs7.promises.mkdir(path10.dirname(absoluteFilePath), {
         recursive: true
       });
       const command = new import_client_s32.GetObjectCommand({
@@ -232900,7 +233084,7 @@ class EnvironmentStore {
       logger.info(`Successfully cloned entire repository to: ${absoluteDirPath}`);
       return;
     }
-    const packageFullPath = path9.join(absoluteDirPath, cleanPackagePath);
+    const packageFullPath = path10.join(absoluteDirPath, cleanPackagePath);
     const packageExists = await fs7.promises.access(packageFullPath).then(() => true).catch(() => false);
     if (!packageExists) {
       throw new Error(`Package path "${cleanPackagePath}" does not exist in the cloned repository.`);
@@ -232908,7 +233092,7 @@ class EnvironmentStore {
     const dirContents = await fs7.promises.readdir(absoluteDirPath);
     for (const entry of dirContents) {
       if (entry !== cleanPackagePath.replace(/^\/+/, "").split("/")[0]) {
-        await fs7.promises.rm(path9.join(absoluteDirPath, entry), {
+        await fs7.promises.rm(path10.join(absoluteDirPath, entry), {
           recursive: true,
           force: true
         });
@@ -232916,7 +233100,7 @@ class EnvironmentStore {
     }
     const packageContents = await fs7.promises.readdir(packageFullPath);
     for (const entry of packageContents) {
-      await fs7.promises.rename(path9.join(packageFullPath, entry), path9.join(absoluteDirPath, entry));
+      await fs7.promises.rename(path10.join(packageFullPath, entry), path10.join(absoluteDirPath, entry));
     }
     await fs7.promises.rm(packageFullPath, { recursive: true, force: true });
   }
@@ -232964,9 +233148,9 @@ class WatchModeController {
       });
       return;
     }
-    this.watchingPath = path10.join(this.environmentStore.serverRootPath, watchName);
+    this.watchingPath = path11.join(this.environmentStore.serverRootPath, watchName);
     this.watcher = esm_default.watch(this.watchingPath, {
-      ignored: (path11, stats) => !!stats?.isFile() && !path11.endsWith(".malloy") && !path11.endsWith(".md"),
+      ignored: (path12, stats) => !!stats?.isFile() && !path12.endsWith(".malloy") && !path12.endsWith(".md"),
       ignoreInitial: true
     });
     const reloadEnvironment = async () => {
@@ -232974,16 +233158,16 @@ class WatchModeController {
       await this.environmentStore.addEnvironment(environment2.metadata);
       logger.info(`Reloaded environment ${watchName}`);
     };
-    this.watcher.on("add", async (path11) => {
-      logger.info(`Detected new file ${path11}, reloading environment ${watchName}`);
+    this.watcher.on("add", async (path12) => {
+      logger.info(`Detected new file ${path12}, reloading environment ${watchName}`);
       await reloadEnvironment();
     });
-    this.watcher.on("unlink", async (path11) => {
-      logger.info(`Detected deletion of ${path11}, reloading environment ${watchName}`);
+    this.watcher.on("unlink", async (path12) => {
+      logger.info(`Detected deletion of ${path12}, reloading environment ${watchName}`);
       await reloadEnvironment();
     });
-    this.watcher.on("change", async (path11) => {
-      logger.info(`Detected change on ${path11}, reloading environment ${watchName}`);
+    this.watcher.on("change", async (path12) => {
+      logger.info(`Detected change on ${path12}, reloading environment ${watchName}`);
       await reloadEnvironment();
     });
     res.json();
@@ -236074,25 +236258,25 @@ async function getModelForQuery(environmentStore, environmentName, packageName,
   }
 }
 function buildMalloyUri(components, fragment) {
-  let path11 = "/environment/";
+  let path12 = "/environment/";
   if (components.environment) {
-    path11 += encodeURIComponent(components.environment);
+    path12 += encodeURIComponent(components.environment);
   } else {
-    path11 += "home";
+    path12 += "home";
   }
   if (components.package) {
-    path11 += "/package/" + encodeURIComponent(components.package);
+    path12 += "/package/" + encodeURIComponent(components.package);
   }
   if (components.resourceType) {
-    path11 += "/" + components.resourceType;
+    path12 += "/" + components.resourceType;
     if (components.resourceName) {
-      path11 += "/" + encodeURIComponent(components.resourceName);
+      path12 += "/" + encodeURIComponent(components.resourceName);
       if (components.subResourceType && components.subResourceName) {
-        path11 += "/" + components.subResourceType + "/" + encodeURIComponent(components.subResourceName);
+        path12 += "/" + components.subResourceType + "/" + encodeURIComponent(components.subResourceName);
       }
     }
   }
-  let uriString = "malloy:/" + path11;
+  let uriString = "malloy:/" + path12;
   if (fragment) {
     uriString += "#" + fragment;
   }
@@ -236986,6 +237170,581 @@ function initializeMcpServer(environmentStore) {
   return mcpServer;
 }
 
+// src/server-old.ts
+var import_body_parser = __toESM(require_body_parser(), 1);
+var LEGACY_API_PREFIX = "/api/v0";
+function remapMaterializationResponse(mat) {
+  if (!mat || typeof mat !== "object")
+    return mat;
+  if (Array.isArray(mat)) {
+    return mat.map(remapMaterializationResponse);
+  }
+  const out = { ...mat };
+  if ("environmentId" in out) {
+    out.projectId = out.environmentId;
+    delete out.environmentId;
+  }
+  return out;
+}
+var setVersionIdError = (res) => {
+  const { json, status } = internalErrorToHttpError(new NotImplementedError("Version IDs not implemented."));
+  res.status(status).json(json);
+};
+function registerLegacyRoutes(app, controllers) {
+  const {
+    environmentStore,
+    connectionController,
+    modelController,
+    packageController,
+    databaseController,
+    queryController,
+    compileController,
+    materializationController,
+    manifestController
+  } = controllers;
+  app.get(`${LEGACY_API_PREFIX}/projects`, async (_req, res) => {
+    try {
+      res.status(200).json(await environmentStore.listEnvironments());
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.post(`${LEGACY_API_PREFIX}/projects`, async (req, res) => {
+    try {
+      logger.info("Adding project", { body: req.body });
+      const environment = await environmentStore.addEnvironment(req.body);
+      res.status(200).json(await environment.serialize());
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName`, async (req, res) => {
+    try {
+      const environment = await environmentStore.getEnvironment(req.params.projectName, req.query.reload === "true");
+      res.status(200).json(await environment.serialize());
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.patch(`${LEGACY_API_PREFIX}/projects/:projectName`, async (req, res) => {
+    try {
+      const environment = await environmentStore.updateEnvironment(req.body);
+      res.status(200).json(await environment.serialize());
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.delete(`${LEGACY_API_PREFIX}/projects/:projectName`, async (req, res) => {
+    try {
+      const environment = await environmentStore.deleteEnvironment(req.params.projectName);
+      res.status(200).json(await environment?.serialize());
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/connections`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.listConnections(req.params.projectName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.getConnection(req.params.projectName, req.params.connectionName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.post(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName`, async (req, res) => {
+    try {
+      const result = await connectionController.addConnection(req.params.projectName, req.params.connectionName, req.body);
+      res.status(201).json(result);
+    } catch (error) {
+      logger.error("Error creating connection", { error });
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.patch(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName`, async (req, res) => {
+    try {
+      const result = await connectionController.updateConnection(req.params.projectName, req.params.connectionName, req.body);
+      res.status(200).json(result);
+    } catch (error) {
+      logger.error("Error updating connection", { error });
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.delete(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName`, async (req, res) => {
+    try {
+      const result = await connectionController.deleteConnection(req.params.projectName, req.params.connectionName);
+      res.status(200).json(result);
+    } catch (error) {
+      logger.error("Error deleting connection", { error });
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/schemas`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.listSchemas(req.params.projectName, req.params.connectionName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/schemas/:schemaName/tables`, async (req, res) => {
+    try {
+      const results = await connectionController.listTables(req.params.projectName, req.params.connectionName, req.params.schemaName, normalizeQueryArray(req.query.tableNames));
+      res.status(200).json(results);
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/schemas/:schemaName/tables/:tablePath`, async (req, res) => {
+    try {
+      const results = await connectionController.getTable(req.params.projectName, req.params.connectionName, req.params.schemaName, req.params.tablePath);
+      res.status(200).json(results);
+    } 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/schemas`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.listSchemas(req.params.projectName, req.params.connectionName, req.params.packageName));
+    } 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/schemas/:schemaName/tables`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.listTables(req.params.projectName, req.params.connectionName, req.params.schemaName, normalizeQueryArray(req.query.tableNames), req.params.packageName));
+    } 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/schemas/:schemaName/tables/:tablePath`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.getTable(req.params.projectName, req.params.connectionName, req.params.schemaName, req.params.tablePath, req.params.packageName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      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));
+    } 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/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));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/queryData`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.getConnectionQueryData(req.params.projectName, req.params.connectionName, req.query.sqlStatement, req.query.options));
+    } 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/queryData`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.getConnectionQueryData(req.params.projectName, req.params.connectionName, req.query.sqlStatement, req.query.options, 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/sqlQuery`, 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.projectName, req.params.connectionName, req.body.sqlStatement, options));
+    } 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/sqlQuery`, 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.projectName, 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(`${LEGACY_API_PREFIX}/projects/:projectName/connections/:connectionName/temporaryTable`, 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`, 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`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.getConnectionTemporaryTable(req.params.projectName, req.params.connectionName, req.body.sqlStatement));
+    } 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/sqlTemporaryTable`, async (req, res) => {
+    try {
+      res.status(200).json(await connectionController.getConnectionTemporaryTable(req.params.projectName, req.params.connectionName, req.body.sqlStatement, req.params.packageName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages`, async (req, res) => {
+    if (req.query.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      res.status(200).json(await packageController.listPackages(req.params.projectName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  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 });
+      res.status(200).json(_package?.getPackageMetadata());
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName`, async (req, res) => {
+    if (req.query.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      res.status(200).json(await packageController.getPackage(req.params.projectName, req.params.packageName, req.query.reload === "true"));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.patch(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName`, async (req, res) => {
+    try {
+      res.status(200).json(await packageController.updatePackage(req.params.projectName, req.params.packageName, req.body));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.delete(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName`, async (req, res) => {
+    try {
+      res.status(200).json(await packageController.deletePackage(req.params.projectName, req.params.packageName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/models`, async (req, res) => {
+    if (req.query.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      res.status(200).json(await modelController.listModels(req.params.projectName, req.params.packageName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/models/*?`, async (req, res) => {
+    if (req.query.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      const modelPath = req.params["0"];
+      res.status(200).json(await modelController.getModel(req.params.projectName, req.params.packageName, modelPath));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.post(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/models/*?/query`, async (req, res) => {
+    if (req.body.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      const modelPath = req.params["0"];
+      res.status(200).json(await queryController.getQuery(req.params.projectName, req.params.packageName, modelPath, req.body.sourceName, req.body.queryName, req.body.query, req.body.compactJson === true, req.body.filterParams ?? req.body.sourceFilters, req.body.bypassFilters === true ? true : undefined));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.post(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/models/:modelName/compile`, async (req, res) => {
+    try {
+      const result = await compileController.compile(req.params.projectName, req.params.packageName, req.params.modelName, req.body.source, req.body.includeSql === true);
+      res.status(200).json(result);
+    } catch (error) {
+      logger.error("Compilation error", { error });
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/notebooks`, async (req, res) => {
+    if (req.query.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      res.status(200).json(await modelController.listNotebooks(req.params.projectName, req.params.packageName));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/notebooks/*/cells/:cellIndex`, async (req, res) => {
+    if (req.query.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      const cellIndex = parseInt(req.params.cellIndex, 10);
+      if (isNaN(cellIndex)) {
+        res.status(400).json({ error: "Invalid cell index" });
+        return;
+      }
+      const notebookPath = req.params["0"];
+      let filterParams;
+      if (typeof req.query.filter_params === "string") {
+        try {
+          filterParams = JSON.parse(req.query.filter_params);
+        } catch {
+          res.status(400).json({
+            error: "Invalid filter_params: must be valid JSON"
+          });
+          return;
+        }
+      }
+      const bypassFilters = req.query.bypass_filters === "true" ? true : undefined;
+      res.status(200).json(await modelController.executeNotebookCell(req.params.projectName, req.params.packageName, notebookPath, cellIndex, filterParams, bypassFilters));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/notebooks/*?`, async (req, res) => {
+    if (req.query.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      const notebookPath = req.params["0"];
+      res.status(200).json(await modelController.getNotebook(req.params.projectName, req.params.packageName, notebookPath));
+    } catch (error) {
+      logger.error(error);
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/databases`, async (req, res) => {
+    if (req.query.versionId) {
+      setVersionIdError(res);
+      return;
+    }
+    try {
+      res.status(200).json(await databaseController.listDatabases(req.params.projectName, 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/materializations`, async (req, res) => {
+    try {
+      const build = await materializationController.createMaterialization(req.params.projectName, req.params.packageName, req.body || {});
+      res.status(201).json(remapMaterializationResponse(build));
+    } catch (error) {
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/materializations`, async (req, res) => {
+    try {
+      const limit = req.query.limit ? parseInt(req.query.limit, 10) : undefined;
+      const offset = req.query.offset ? parseInt(req.query.offset, 10) : undefined;
+      const builds = await materializationController.listMaterializations(req.params.projectName, req.params.packageName, { limit, offset });
+      res.status(200).json(remapMaterializationResponse(builds));
+    } catch (error) {
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  app.get(`${LEGACY_API_PREFIX}/projects/:projectName/packages/:packageName/materializations/:materializationId`, async (req, res) => {
+    try {
+      const build = await materializationController.getMaterialization(req.params.projectName, req.params.packageName, req.params.materializationId);
+      res.status(200).json(remapMaterializationResponse(build));
+    } catch (error) {
+      const { json, status } = internalErrorToHttpError(error);
+      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);
+        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'.`);
+      }
+    } catch (error) {
+      const { json, status } = internalErrorToHttpError(error);
+      res.status(status).json(json);
+    }
+  });
+  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);
+      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
 class ManifestService {
   environmentStore;
@@ -237036,8 +237795,8 @@ import {
 } from "@malloydata/malloy";
 
 // src/service/quoting.ts
-function quoteTablePath(path11, dialect) {
-  return path11.split(".").map((seg) => dialect.quoteTablePath(seg)).join(".");
+function quoteTablePath(path12, dialect) {
+  return path12.split(".").map((seg) => dialect.quoteTablePath(seg)).join(".");
 }
 function splitTablePath(tableName) {
   const lastDot = tableName.lastIndexOf(".");
@@ -237635,6 +238394,8 @@ function normalizeQueryArray(value) {
 }
 function parseArgs() {
   const args = process.argv.slice(2);
+  let sawServerRoot = false;
+  let sawConfig = false;
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--port" && args[i + 1]) {
@@ -237644,8 +238405,13 @@ function parseArgs() {
       process.env.PUBLISHER_HOST = args[i + 1];
       i++;
     } else if (arg === "--server_root" && args[i + 1]) {
+      sawServerRoot = true;
       process.env.SERVER_ROOT = args[i + 1];
       i++;
+    } else if (arg === "--config" && args[i + 1]) {
+      sawConfig = true;
+      process.env.PUBLISHER_CONFIG_PATH = args[i + 1];
+      i++;
     } else if (arg === "--mcp_port" && args[i + 1]) {
       process.env.MCP_PORT = args[i + 1];
       i++;
@@ -237666,6 +238432,7 @@ function parseArgs() {
       console.log("  --port <number>        Port to run the server on (default: 4000)");
       console.log("  --host <string>        Host to bind the server to (default: localhost)");
       console.log("  --server_root <path>   Root directory to serve files from (default: .)");
+      console.log("  --config <path>        Path to publisher.config.json (default: <server_root>/publisher.config.json; falls back to bundled DuckDB-only sample config if missing)");
       console.log("  --mcp_port <number>    Port for MCP server (default: 4040)");
       console.log("  --shutdown_drain_duration_seconds <number>  Time in seconds to keep service in draining state before closing servers (default: 0)");
       console.log("  --shutdown_graceful_close_timeout_seconds <number>  Time in seconds to wait after closing servers before exit (default: 0)");
@@ -237674,6 +238441,9 @@ function parseArgs() {
       process.exit(0);
     }
   }
+  if (!sawServerRoot && !sawConfig && true) {
+    process.env.PUBLISHER_USE_BUNDLED_DEFAULT = "true";
+  }
 }
 parseArgs();
 var PUBLISHER_PORT = Number(process.env.PUBLISHER_PORT || 4000);
@@ -237682,9 +238452,9 @@ 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 = fileURLToPath2(import.meta.url);
-var ROOT = path11.join(path11.dirname(__filename_esm), "app");
-var SERVER_ROOT = path11.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
+var __filename_esm = fileURLToPath3(import.meta.url);
+var ROOT = path12.join(path12.dirname(__filename_esm), "app");
+var SERVER_ROOT = path12.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
 var API_PREFIX2 = "/api/v0";
 var isDevelopment = process.env["NODE_ENV"] === "development";
 var app = import_express.default();
@@ -237765,17 +238535,17 @@ mcpApp.all(MCP_ENDPOINT, async (req, res) => {
 });
 if (!isDevelopment) {
   app.use("/", import_express.default.static(ROOT));
-  app.use("/api-doc.html", import_express.default.static(path11.join(ROOT, "api-doc.html")));
+  app.use("/api-doc.html", import_express.default.static(path12.join(ROOT, "api-doc.html")));
 } else {
   app.use(`${API_PREFIX2}`, loggerMiddleware);
   app.use(import_http_proxy_middleware.createProxyMiddleware({
     target: "http://localhost:5173",
     changeOrigin: true,
     ws: true,
-    pathFilter: (path12) => !path12.startsWith("/api/") && !path12.startsWith("/metrics") && !path12.startsWith("/health")
+    pathFilter: (path13) => !path13.startsWith("/api/") && !path13.startsWith("/metrics") && !path13.startsWith("/health")
   }));
 }
-var setVersionIdError = (res) => {
+var setVersionIdError2 = (res) => {
   const { json, status } = internalErrorToHttpError(new NotImplementedError("Version IDs not implemented."));
   res.status(status).json(json);
 };
@@ -237783,7 +238553,7 @@ app.use(import_cors.default({
   origin: "http://localhost:5173",
   credentials: true
 }));
-app.use(import_body_parser.default.json({ limit: "1mb" }));
+app.use(import_body_parser2.default.json({ limit: "1mb" }));
 registerHealthEndpoints(app);
 try {
   const metricsHandler = getPrometheusMetricsHandler();
@@ -238094,7 +238864,7 @@ app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/con
 });
 app.get(`${API_PREFIX2}/environments/:environmentName/packages`, async (req, res) => {
   if (req.query.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238118,7 +238888,7 @@ app.post(`${API_PREFIX2}/environments/:environmentName/packages`, async (req, re
 });
 app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName`, async (req, res) => {
   if (req.query.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238149,7 +238919,7 @@ app.delete(`${API_PREFIX2}/environments/:environmentName/packages/:packageName`,
 });
 app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/models`, async (req, res) => {
   if (req.query.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238162,7 +238932,7 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/mode
 });
 app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/models/*?`, async (req, res) => {
   if (req.query.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238176,7 +238946,7 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/mode
 });
 app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/notebooks`, async (req, res) => {
   if (req.query.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238189,7 +238959,7 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/note
 });
 app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/notebooks/*/cells/:cellIndex`, async (req, res) => {
   if (req.query.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238222,7 +238992,7 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/note
 });
 app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/notebooks/*?`, async (req, res) => {
   if (req.query.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238236,7 +239006,7 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/note
 });
 app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/models/*?/query`, async (req, res) => {
   if (req.body.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238250,7 +239020,7 @@ app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/mod
 });
 app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/databases`, async (req, res) => {
   if (req.query.versionId) {
-    setVersionIdError(res);
+    setVersionIdError2(res);
     return;
   }
   try {
@@ -238360,8 +239130,19 @@ app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/man
     res.status(status).json(json);
   }
 });
+registerLegacyRoutes(app, {
+  environmentStore,
+  connectionController,
+  modelController,
+  packageController,
+  databaseController,
+  queryController,
+  compileController,
+  materializationController,
+  manifestController
+});
 if (!isDevelopment) {
-  app.get("*", (_req, res) => res.sendFile(path11.resolve(ROOT, "index.html")));
+  app.get("*", (_req, res) => res.sendFile(path12.resolve(ROOT, "index.html")));
 }
 app.use((err, _req, res, _next) => {
   logger.error("Unhandled error:", err);